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

18 files changed, 3032 insertions, 3032 deletions

diff --git a/contrib/libs/zstd/lib/compress/fse_compress.c b/contrib/libs/zstd/lib/compress/fse_compress.c
index 5547b4ac099..a31a545b8ce 100644
--- a/contrib/libs/zstd/lib/compress/fse_compress.c
+++ b/contrib/libs/zstd/lib/compress/fse_compress.c
@@ -18,7 +18,7 @@
 #include "../common/compiler.h"
 #include "../common/mem.h"        /* U32, U16, etc. */
 #include "../common/debug.h"      /* assert, DEBUGLOG */
-#include "hist.h"       /* HIST_count_wksp */
+#include "hist.h"       /* HIST_count_wksp */ 
 #include "../common/bitstream.h"
 #define FSE_STATIC_LINKING_ONLY
 #include "../common/fse.h"
@@ -64,9 +64,9 @@
  * wkspSize should be sized to handle worst case situation, which is `1<<max_tableLog * sizeof(FSE_FUNCTION_TYPE)`
  * workSpace must also be properly aligned with FSE_FUNCTION_TYPE requirements
  */
-size_t FSE_buildCTable_wksp(FSE_CTable* ct,
-                      const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
-                            void* workSpace, size_t wkspSize)
+size_t FSE_buildCTable_wksp(FSE_CTable* ct, 
+                      const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, 
+                            void* workSpace, size_t wkspSize) 
 {
     U32 const tableSize = 1 << tableLog;
     U32 const tableMask = tableSize - 1;
@@ -87,15 +87,15 @@ size_t FSE_buildCTable_wksp(FSE_CTable* ct,
     /* CTable header */
     tableU16[-2] = (U16) tableLog;
     tableU16[-1] = (U16) maxSymbolValue;
-    assert(tableLog < 16);   /* required for threshold strategy to work */
+    assert(tableLog < 16);   /* required for threshold strategy to work */ 
 
     /* For explanations on how to distribute symbol values over the table :
-     * http://fastcompression.blogspot.fr/2014/02/fse-distributing-symbol-values.html */
+     * http://fastcompression.blogspot.fr/2014/02/fse-distributing-symbol-values.html */ 
 
-     #ifdef __clang_analyzer__
+     #ifdef __clang_analyzer__ 
      ZSTD_memset(tableSymbol, 0, sizeof(*tableSymbol) * tableSize);   /* useless initialization, just to keep scan-build happy */
-     #endif
-
+     #endif 
+ 
     /* symbol start positions */
     {   U32 u;
         cumul[0] = 0;
@@ -154,15 +154,15 @@ size_t FSE_buildCTable_wksp(FSE_CTable* ct,
         U32 position = 0;
         U32 symbol;
         for (symbol=0; symbol<maxSV1; symbol++) {
-            int nbOccurrences;
-            int const freq = normalizedCounter[symbol];
-            for (nbOccurrences=0; nbOccurrences<freq; nbOccurrences++) {
+            int nbOccurrences; 
+            int const freq = normalizedCounter[symbol]; 
+            for (nbOccurrences=0; nbOccurrences<freq; nbOccurrences++) { 
                 tableSymbol[position] = (FSE_FUNCTION_TYPE)symbol;
                 position = (position + step) & tableMask;
-                while (position > highThreshold)
-                    position = (position + step) & tableMask;   /* Low proba area */
+                while (position > highThreshold) 
+                    position = (position + step) & tableMask;   /* Low proba area */ 
         }   }
-        assert(position==0);  /* Must have initialized all positions */
+        assert(position==0);  /* Must have initialized all positions */ 
     }
 
     /* Build table */
@@ -177,10 +177,10 @@ size_t FSE_buildCTable_wksp(FSE_CTable* ct,
         for (s=0; s<=maxSymbolValue; s++) {
             switch (normalizedCounter[s])
             {
-            case  0:
-                /* filling nonetheless, for compatibility with FSE_getMaxNbBits() */
-                symbolTT[s].deltaNbBits = ((tableLog+1) << 16) - (1<<tableLog);
-                break;
+            case  0: 
+                /* filling nonetheless, for compatibility with FSE_getMaxNbBits() */ 
+                symbolTT[s].deltaNbBits = ((tableLog+1) << 16) - (1<<tableLog); 
+                break; 
 
             case -1:
             case  1:
@@ -198,17 +198,17 @@ size_t FSE_buildCTable_wksp(FSE_CTable* ct,
                     total +=  (unsigned)normalizedCounter[s];
     }   }   }   }
 
-#if 0  /* debug : symbol costs */
-    DEBUGLOG(5, "\n --- table statistics : ");
-    {   U32 symbol;
-        for (symbol=0; symbol<=maxSymbolValue; symbol++) {
-            DEBUGLOG(5, "%3u: w=%3i,   maxBits=%u, fracBits=%.2f",
-                symbol, normalizedCounter[symbol],
-                FSE_getMaxNbBits(symbolTT, symbol),
-                (double)FSE_bitCost(symbolTT, tableLog, symbol, 8) / 256);
+#if 0  /* debug : symbol costs */ 
+    DEBUGLOG(5, "\n --- table statistics : "); 
+    {   U32 symbol; 
+        for (symbol=0; symbol<=maxSymbolValue; symbol++) { 
+            DEBUGLOG(5, "%3u: w=%3i,   maxBits=%u, fracBits=%.2f", 
+                symbol, normalizedCounter[symbol], 
+                FSE_getMaxNbBits(symbolTT, symbol), 
+                (double)FSE_bitCost(symbolTT, tableLog, symbol, 8) / 256); 
     }   }
-#endif
-
+#endif 
+ 
     return 0;
 }
 
@@ -217,7 +217,7 @@ size_t FSE_buildCTable_wksp(FSE_CTable* ct,
 #ifndef FSE_COMMONDEFS_ONLY
 
 /*-**************************************************************
-*  FSE NCount encoding
+*  FSE NCount encoding 
 ****************************************************************/
 size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog)
 {
@@ -229,10 +229,10 @@ size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog)
     return maxSymbolValue ? maxHeaderSize : FSE_NCOUNTBOUND;  /* maxSymbolValue==0 ? use default */
 }
 
-static size_t
-FSE_writeNCount_generic (void* header, size_t headerBufferSize,
-                   const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
-                         unsigned writeIsSafe)
+static size_t 
+FSE_writeNCount_generic (void* header, size_t headerBufferSize, 
+                   const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, 
+                         unsigned writeIsSafe) 
 {
     BYTE* const ostart = (BYTE*) header;
     BYTE* out = ostart;
@@ -241,11 +241,11 @@ FSE_writeNCount_generic (void* header, size_t headerBufferSize,
     const int tableSize = 1 << tableLog;
     int remaining;
     int threshold;
-    U32 bitStream = 0;
-    int bitCount = 0;
-    unsigned symbol = 0;
-    unsigned const alphabetSize = maxSymbolValue + 1;
-    int previousIs0 = 0;
+    U32 bitStream = 0; 
+    int bitCount = 0; 
+    unsigned symbol = 0; 
+    unsigned const alphabetSize = maxSymbolValue + 1; 
+    int previousIs0 = 0; 
 
     /* Table Size */
     bitStream += (tableLog-FSE_MIN_TABLELOG) << bitCount;
@@ -256,53 +256,53 @@ FSE_writeNCount_generic (void* header, size_t headerBufferSize,
     threshold = tableSize;
     nbBits = tableLog+1;
 
-    while ((symbol < alphabetSize) && (remaining>1)) {  /* stops at 1 */
-        if (previousIs0) {
-            unsigned start = symbol;
-            while ((symbol < alphabetSize) && !normalizedCounter[symbol]) symbol++;
-            if (symbol == alphabetSize) break;   /* incorrect distribution */
-            while (symbol >= start+24) {
+    while ((symbol < alphabetSize) && (remaining>1)) {  /* stops at 1 */ 
+        if (previousIs0) { 
+            unsigned start = symbol; 
+            while ((symbol < alphabetSize) && !normalizedCounter[symbol]) symbol++; 
+            if (symbol == alphabetSize) break;   /* incorrect distribution */ 
+            while (symbol >= start+24) { 
                 start+=24;
                 bitStream += 0xFFFFU << bitCount;
-                if ((!writeIsSafe) && (out > oend-2))
-                    return ERROR(dstSize_tooSmall);   /* Buffer overflow */
+                if ((!writeIsSafe) && (out > oend-2)) 
+                    return ERROR(dstSize_tooSmall);   /* Buffer overflow */ 
                 out[0] = (BYTE) bitStream;
                 out[1] = (BYTE)(bitStream>>8);
                 out+=2;
                 bitStream>>=16;
             }
-            while (symbol >= start+3) {
+            while (symbol >= start+3) { 
                 start+=3;
                 bitStream += 3 << bitCount;
                 bitCount += 2;
             }
-            bitStream += (symbol-start) << bitCount;
+            bitStream += (symbol-start) << bitCount; 
             bitCount += 2;
             if (bitCount>16) {
-                if ((!writeIsSafe) && (out > oend - 2))
-                    return ERROR(dstSize_tooSmall);   /* Buffer overflow */
+                if ((!writeIsSafe) && (out > oend - 2)) 
+                    return ERROR(dstSize_tooSmall);   /* Buffer overflow */ 
                 out[0] = (BYTE)bitStream;
                 out[1] = (BYTE)(bitStream>>8);
                 out += 2;
                 bitStream >>= 16;
                 bitCount -= 16;
         }   }
-        {   int count = normalizedCounter[symbol++];
-            int const max = (2*threshold-1) - remaining;
+        {   int count = normalizedCounter[symbol++]; 
+            int const max = (2*threshold-1) - remaining; 
             remaining -= count < 0 ? -count : count;
             count++;   /* +1 for extra accuracy */
-            if (count>=threshold)
-                count += max;   /* [0..max[ [max..threshold[ (...) [threshold+max 2*threshold[ */
+            if (count>=threshold) 
+                count += max;   /* [0..max[ [max..threshold[ (...) [threshold+max 2*threshold[ */ 
             bitStream += count << bitCount;
             bitCount  += nbBits;
             bitCount  -= (count<max);
-            previousIs0  = (count==1);
+            previousIs0  = (count==1); 
             if (remaining<1) return ERROR(GENERIC);
             while (remaining<threshold) { nbBits--; threshold>>=1; }
         }
         if (bitCount>16) {
-            if ((!writeIsSafe) && (out > oend - 2))
-                return ERROR(dstSize_tooSmall);   /* Buffer overflow */
+            if ((!writeIsSafe) && (out > oend - 2)) 
+                return ERROR(dstSize_tooSmall);   /* Buffer overflow */ 
             out[0] = (BYTE)bitStream;
             out[1] = (BYTE)(bitStream>>8);
             out += 2;
@@ -310,13 +310,13 @@ FSE_writeNCount_generic (void* header, size_t headerBufferSize,
             bitCount -= 16;
     }   }
 
-    if (remaining != 1)
-        return ERROR(GENERIC);  /* incorrect normalized distribution */
-    assert(symbol <= alphabetSize);
-
+    if (remaining != 1) 
+        return ERROR(GENERIC);  /* incorrect normalized distribution */ 
+    assert(symbol <= alphabetSize); 
+ 
     /* flush remaining bitStream */
-    if ((!writeIsSafe) && (out > oend - 2))
-        return ERROR(dstSize_tooSmall);   /* Buffer overflow */
+    if ((!writeIsSafe) && (out > oend - 2)) 
+        return ERROR(dstSize_tooSmall);   /* Buffer overflow */ 
     out[0] = (BYTE)bitStream;
     out[1] = (BYTE)(bitStream>>8);
     out+= (bitCount+7) /8;
@@ -325,8 +325,8 @@ FSE_writeNCount_generic (void* header, size_t headerBufferSize,
 }
 
 
-size_t FSE_writeNCount (void* buffer, size_t bufferSize,
-                  const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
+size_t FSE_writeNCount (void* buffer, size_t bufferSize, 
+                  const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) 
 {
     if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);   /* Unsupported */
     if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC);   /* Unsupported */
@@ -334,7 +334,7 @@ size_t FSE_writeNCount (void* buffer, size_t bufferSize,
     if (bufferSize < FSE_NCountWriteBound(maxSymbolValue, tableLog))
         return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 0);
 
-    return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 1 /* write in buffer is safe */);
+    return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 1 /* write in buffer is safe */); 
 }
 
 
@@ -355,7 +355,7 @@ void FSE_freeCTable (FSE_CTable* ct) { ZSTD_free(ct); }
 /* provides the minimum logSize to safely represent a distribution */
 static unsigned FSE_minTableLog(size_t srcSize, unsigned maxSymbolValue)
 {
-    U32 minBitsSrc = BIT_highbit32((U32)(srcSize)) + 1;
+    U32 minBitsSrc = BIT_highbit32((U32)(srcSize)) + 1; 
     U32 minBitsSymbols = BIT_highbit32(maxSymbolValue) + 2;
     U32 minBits = minBitsSrc < minBitsSymbols ? minBitsSrc : minBitsSymbols;
     assert(srcSize > 1); /* Not supported, RLE should be used instead */
@@ -417,9 +417,9 @@ static size_t FSE_normalizeM2(short* norm, U32 tableLog, const unsigned* count,
     }
     ToDistribute = (1 << tableLog) - distributed;
 
-    if (ToDistribute == 0)
-        return 0;
-
+    if (ToDistribute == 0) 
+        return 0; 
+ 
     if ((total / ToDistribute) > lowOne) {
         /* risk of rounding to zero */
         lowOne = (U32)((total * 3) / (ToDistribute * 2));
@@ -520,11 +520,11 @@ size_t FSE_normalizeCount (short* normalizedCounter, unsigned tableLog,
         U32 s;
         U32 nTotal = 0;
         for (s=0; s<=maxSymbolValue; s++)
-            RAWLOG(2, "%3i: %4i \n", s, normalizedCounter[s]);
+            RAWLOG(2, "%3i: %4i \n", s, normalizedCounter[s]); 
         for (s=0; s<=maxSymbolValue; s++)
             nTotal += abs(normalizedCounter[s]);
         if (nTotal != (1U<<tableLog))
-            RAWLOG(2, "Warning !!! Total == %u != %u !!!", nTotal, 1U<<tableLog);
+            RAWLOG(2, "Warning !!! Total == %u != %u !!!", nTotal, 1U<<tableLog); 
         getchar();
     }
 #endif
@@ -675,7 +675,7 @@ size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src, size_t src
     BYTE* op = ostart;
     BYTE* const oend = ostart + dstSize;
 
-    unsigned count[FSE_MAX_SYMBOL_VALUE+1];
+    unsigned count[FSE_MAX_SYMBOL_VALUE+1]; 
     S16   norm[FSE_MAX_SYMBOL_VALUE+1];
     FSE_CTable* CTable = (FSE_CTable*)workSpace;
     size_t const CTableSize = FSE_CTABLE_SIZE_U32(tableLog, maxSymbolValue);
@@ -689,7 +689,7 @@ size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src, size_t src
     if (!tableLog) tableLog = FSE_DEFAULT_TABLELOG;
 
     /* Scan input and build symbol stats */
-    {   CHECK_V_F(maxCount, HIST_count_wksp(count, &maxSymbolValue, src, srcSize, scratchBuffer, scratchBufferSize) );
+    {   CHECK_V_F(maxCount, HIST_count_wksp(count, &maxSymbolValue, src, srcSize, scratchBuffer, scratchBufferSize) ); 
         if (maxCount == srcSize) return 1;   /* only a single symbol in src : rle */
         if (maxCount == 1) return 0;         /* each symbol present maximum once => not compressible */
         if (maxCount < (srcSize >> 7)) return 0;   /* Heuristic : not compressible enough */
diff --git a/contrib/libs/zstd/lib/compress/hist.c b/contrib/libs/zstd/lib/compress/hist.c
index 073c57e7527..0131b859c31 100644
--- a/contrib/libs/zstd/lib/compress/hist.c
+++ b/contrib/libs/zstd/lib/compress/hist.c
@@ -1,4 +1,4 @@
-/* ******************************************************************
+/* ****************************************************************** 
  * hist : Histogram functions
  * part of Finite State Entropy project
  * Copyright (c) Yann Collet, Facebook, Inc.
@@ -11,158 +11,158 @@
  * 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.
-****************************************************************** */
-
-/* --- dependencies --- */
+****************************************************************** */ 
+ 
+/* --- dependencies --- */ 
 #include "../common/mem.h"             /* U32, BYTE, etc. */
 #include "../common/debug.h"           /* assert, DEBUGLOG */
 #include "../common/error_private.h"   /* ERROR */
-#include "hist.h"
-
-
-/* --- Error management --- */
-unsigned HIST_isError(size_t code) { return ERR_isError(code); }
-
-/*-**************************************************************
- *  Histogram functions
- ****************************************************************/
-unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,
-                           const void* src, size_t srcSize)
-{
-    const BYTE* ip = (const BYTE*)src;
-    const BYTE* const end = ip + srcSize;
-    unsigned maxSymbolValue = *maxSymbolValuePtr;
-    unsigned largestCount=0;
-
+#include "hist.h" 
+ 
+ 
+/* --- Error management --- */ 
+unsigned HIST_isError(size_t code) { return ERR_isError(code); } 
+ 
+/*-************************************************************** 
+ *  Histogram functions 
+ ****************************************************************/ 
+unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr, 
+                           const void* src, size_t srcSize) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    const BYTE* const end = ip + srcSize; 
+    unsigned maxSymbolValue = *maxSymbolValuePtr; 
+    unsigned largestCount=0; 
+ 
     ZSTD_memset(count, 0, (maxSymbolValue+1) * sizeof(*count));
-    if (srcSize==0) { *maxSymbolValuePtr = 0; return 0; }
-
-    while (ip<end) {
-        assert(*ip <= maxSymbolValue);
-        count[*ip++]++;
-    }
-
-    while (!count[maxSymbolValue]) maxSymbolValue--;
-    *maxSymbolValuePtr = maxSymbolValue;
-
-    {   U32 s;
-        for (s=0; s<=maxSymbolValue; s++)
-            if (count[s] > largestCount) largestCount = count[s];
-    }
-
-    return largestCount;
-}
-
-typedef enum { trustInput, checkMaxSymbolValue } HIST_checkInput_e;
-
-/* HIST_count_parallel_wksp() :
- * store histogram into 4 intermediate tables, recombined at the end.
- * this design makes better use of OoO cpus,
- * and is noticeably faster when some values are heavily repeated.
- * But it needs some additional workspace for intermediate tables.
+    if (srcSize==0) { *maxSymbolValuePtr = 0; return 0; } 
+ 
+    while (ip<end) { 
+        assert(*ip <= maxSymbolValue); 
+        count[*ip++]++; 
+    } 
+ 
+    while (!count[maxSymbolValue]) maxSymbolValue--; 
+    *maxSymbolValuePtr = maxSymbolValue; 
+ 
+    {   U32 s; 
+        for (s=0; s<=maxSymbolValue; s++) 
+            if (count[s] > largestCount) largestCount = count[s]; 
+    } 
+ 
+    return largestCount; 
+} 
+ 
+typedef enum { trustInput, checkMaxSymbolValue } HIST_checkInput_e; 
+ 
+/* HIST_count_parallel_wksp() : 
+ * store histogram into 4 intermediate tables, recombined at the end. 
+ * this design makes better use of OoO cpus, 
+ * and is noticeably faster when some values are heavily repeated. 
+ * But it needs some additional workspace for intermediate tables. 
  * `workSpace` must be a U32 table of size >= HIST_WKSP_SIZE_U32.
- * @return : largest histogram frequency,
+ * @return : largest histogram frequency, 
  *           or an error code (notably when histogram's alphabet is larger than *maxSymbolValuePtr) */
-static size_t HIST_count_parallel_wksp(
-                                unsigned* count, unsigned* maxSymbolValuePtr,
-                                const void* source, size_t sourceSize,
-                                HIST_checkInput_e check,
-                                U32* const workSpace)
-{
-    const BYTE* ip = (const BYTE*)source;
-    const BYTE* const iend = ip+sourceSize;
+static size_t HIST_count_parallel_wksp( 
+                                unsigned* count, unsigned* maxSymbolValuePtr, 
+                                const void* source, size_t sourceSize, 
+                                HIST_checkInput_e check, 
+                                U32* const workSpace) 
+{ 
+    const BYTE* ip = (const BYTE*)source; 
+    const BYTE* const iend = ip+sourceSize; 
     size_t const countSize = (*maxSymbolValuePtr + 1) * sizeof(*count);
-    unsigned max=0;
-    U32* const Counting1 = workSpace;
-    U32* const Counting2 = Counting1 + 256;
-    U32* const Counting3 = Counting2 + 256;
-    U32* const Counting4 = Counting3 + 256;
-
-    /* safety checks */
+    unsigned max=0; 
+    U32* const Counting1 = workSpace; 
+    U32* const Counting2 = Counting1 + 256; 
+    U32* const Counting3 = Counting2 + 256; 
+    U32* const Counting4 = Counting3 + 256; 
+ 
+    /* safety checks */ 
     assert(*maxSymbolValuePtr <= 255);
-    if (!sourceSize) {
+    if (!sourceSize) { 
         ZSTD_memset(count, 0, countSize);
-        *maxSymbolValuePtr = 0;
-        return 0;
-    }
+        *maxSymbolValuePtr = 0; 
+        return 0; 
+    } 
     ZSTD_memset(workSpace, 0, 4*256*sizeof(unsigned));
-
-    /* by stripes of 16 bytes */
-    {   U32 cached = MEM_read32(ip); ip += 4;
-        while (ip < iend-15) {
-            U32 c = cached; cached = MEM_read32(ip); ip += 4;
-            Counting1[(BYTE) c     ]++;
-            Counting2[(BYTE)(c>>8) ]++;
-            Counting3[(BYTE)(c>>16)]++;
-            Counting4[       c>>24 ]++;
-            c = cached; cached = MEM_read32(ip); ip += 4;
-            Counting1[(BYTE) c     ]++;
-            Counting2[(BYTE)(c>>8) ]++;
-            Counting3[(BYTE)(c>>16)]++;
-            Counting4[       c>>24 ]++;
-            c = cached; cached = MEM_read32(ip); ip += 4;
-            Counting1[(BYTE) c     ]++;
-            Counting2[(BYTE)(c>>8) ]++;
-            Counting3[(BYTE)(c>>16)]++;
-            Counting4[       c>>24 ]++;
-            c = cached; cached = MEM_read32(ip); ip += 4;
-            Counting1[(BYTE) c     ]++;
-            Counting2[(BYTE)(c>>8) ]++;
-            Counting3[(BYTE)(c>>16)]++;
-            Counting4[       c>>24 ]++;
-        }
-        ip-=4;
-    }
-
-    /* finish last symbols */
-    while (ip<iend) Counting1[*ip++]++;
-
+ 
+    /* by stripes of 16 bytes */ 
+    {   U32 cached = MEM_read32(ip); ip += 4; 
+        while (ip < iend-15) { 
+            U32 c = cached; cached = MEM_read32(ip); ip += 4; 
+            Counting1[(BYTE) c     ]++; 
+            Counting2[(BYTE)(c>>8) ]++; 
+            Counting3[(BYTE)(c>>16)]++; 
+            Counting4[       c>>24 ]++; 
+            c = cached; cached = MEM_read32(ip); ip += 4; 
+            Counting1[(BYTE) c     ]++; 
+            Counting2[(BYTE)(c>>8) ]++; 
+            Counting3[(BYTE)(c>>16)]++; 
+            Counting4[       c>>24 ]++; 
+            c = cached; cached = MEM_read32(ip); ip += 4; 
+            Counting1[(BYTE) c     ]++; 
+            Counting2[(BYTE)(c>>8) ]++; 
+            Counting3[(BYTE)(c>>16)]++; 
+            Counting4[       c>>24 ]++; 
+            c = cached; cached = MEM_read32(ip); ip += 4; 
+            Counting1[(BYTE) c     ]++; 
+            Counting2[(BYTE)(c>>8) ]++; 
+            Counting3[(BYTE)(c>>16)]++; 
+            Counting4[       c>>24 ]++; 
+        } 
+        ip-=4; 
+    } 
+ 
+    /* finish last symbols */ 
+    while (ip<iend) Counting1[*ip++]++; 
+ 
     {   U32 s;
         for (s=0; s<256; s++) {
-            Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s];
+            Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s]; 
             if (Counting1[s] > max) max = Counting1[s];
-    }   }
-
+    }   } 
+ 
     {   unsigned maxSymbolValue = 255;
         while (!Counting1[maxSymbolValue]) maxSymbolValue--;
         if (check && maxSymbolValue > *maxSymbolValuePtr) return ERROR(maxSymbolValue_tooSmall);
         *maxSymbolValuePtr = maxSymbolValue;
         ZSTD_memmove(count, Counting1, countSize);   /* in case count & Counting1 are overlapping */
     }
-    return (size_t)max;
-}
-
-/* HIST_countFast_wksp() :
- * Same as HIST_countFast(), but using an externally provided scratch buffer.
- * `workSpace` is a writable buffer which must be 4-bytes aligned,
- * `workSpaceSize` must be >= HIST_WKSP_SIZE
- */
-size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
-                          const void* source, size_t sourceSize,
-                          void* workSpace, size_t workSpaceSize)
-{
-    if (sourceSize < 1500) /* heuristic threshold */
-        return HIST_count_simple(count, maxSymbolValuePtr, source, sourceSize);
-    if ((size_t)workSpace & 3) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */
-    if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);
-    return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, trustInput, (U32*)workSpace);
-}
-
-/* HIST_count_wksp() :
- * Same as HIST_count(), but using an externally provided scratch buffer.
- * `workSpace` size must be table of >= HIST_WKSP_SIZE_U32 unsigned */
-size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
-                       const void* source, size_t sourceSize,
-                       void* workSpace, size_t workSpaceSize)
-{
-    if ((size_t)workSpace & 3) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */
-    if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);
-    if (*maxSymbolValuePtr < 255)
-        return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, checkMaxSymbolValue, (U32*)workSpace);
-    *maxSymbolValuePtr = 255;
-    return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, workSpace, workSpaceSize);
-}
-
+    return (size_t)max; 
+} 
+ 
+/* HIST_countFast_wksp() : 
+ * Same as HIST_countFast(), but using an externally provided scratch buffer. 
+ * `workSpace` is a writable buffer which must be 4-bytes aligned, 
+ * `workSpaceSize` must be >= HIST_WKSP_SIZE 
+ */ 
+size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr, 
+                          const void* source, size_t sourceSize, 
+                          void* workSpace, size_t workSpaceSize) 
+{ 
+    if (sourceSize < 1500) /* heuristic threshold */ 
+        return HIST_count_simple(count, maxSymbolValuePtr, source, sourceSize); 
+    if ((size_t)workSpace & 3) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */ 
+    if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall); 
+    return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, trustInput, (U32*)workSpace); 
+} 
+ 
+/* HIST_count_wksp() : 
+ * Same as HIST_count(), but using an externally provided scratch buffer. 
+ * `workSpace` size must be table of >= HIST_WKSP_SIZE_U32 unsigned */ 
+size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr, 
+                       const void* source, size_t sourceSize, 
+                       void* workSpace, size_t workSpaceSize) 
+{ 
+    if ((size_t)workSpace & 3) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */ 
+    if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall); 
+    if (*maxSymbolValuePtr < 255) 
+        return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, checkMaxSymbolValue, (U32*)workSpace); 
+    *maxSymbolValuePtr = 255; 
+    return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, workSpace, workSpaceSize); 
+} 
+ 
 #ifndef ZSTD_NO_UNUSED_FUNCTIONS
 /* fast variant (unsafe : won't check if src contains values beyond count[] limit) */
 size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
@@ -172,10 +172,10 @@ size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
     return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, tmpCounters, sizeof(tmpCounters));
 }
 
-size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr,
-                 const void* src, size_t srcSize)
-{
-    unsigned tmpCounters[HIST_WKSP_SIZE_U32];
-    return HIST_count_wksp(count, maxSymbolValuePtr, src, srcSize, tmpCounters, sizeof(tmpCounters));
-}
+size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr, 
+                 const void* src, size_t srcSize) 
+{ 
+    unsigned tmpCounters[HIST_WKSP_SIZE_U32]; 
+    return HIST_count_wksp(count, maxSymbolValuePtr, src, srcSize, tmpCounters, sizeof(tmpCounters)); 
+} 
 #endif
diff --git a/contrib/libs/zstd/lib/compress/hist.h b/contrib/libs/zstd/lib/compress/hist.h
index 228ed48a71d..93fe145262a 100644
--- a/contrib/libs/zstd/lib/compress/hist.h
+++ b/contrib/libs/zstd/lib/compress/hist.h
@@ -1,4 +1,4 @@
-/* ******************************************************************
+/* ****************************************************************** 
  * hist : Histogram functions
  * part of Finite State Entropy project
  * Copyright (c) Yann Collet, Facebook, Inc.
@@ -11,65 +11,65 @@
  * 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.
-****************************************************************** */
-
-/* --- dependencies --- */
+****************************************************************** */ 
+ 
+/* --- dependencies --- */ 
 #include "../common/zstd_deps.h"   /* size_t */
-
-
-/* --- simple histogram functions --- */
-
-/*! HIST_count():
- *  Provides the precise count of each byte within a table 'count'.
- * 'count' is a table of unsigned int, of minimum size (*maxSymbolValuePtr+1).
- *  Updates *maxSymbolValuePtr with actual largest symbol value detected.
- * @return : count of the most frequent symbol (which isn't identified).
- *           or an error code, which can be tested using HIST_isError().
- *           note : if return == srcSize, there is only one symbol.
- */
-size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr,
-                  const void* src, size_t srcSize);
-
-unsigned HIST_isError(size_t code);  /**< tells if a return value is an error code */
-
-
-/* --- advanced histogram functions --- */
-
-#define HIST_WKSP_SIZE_U32 1024
-#define HIST_WKSP_SIZE    (HIST_WKSP_SIZE_U32 * sizeof(unsigned))
-/** HIST_count_wksp() :
- *  Same as HIST_count(), but using an externally provided scratch buffer.
- *  Benefit is this function will use very little stack space.
- * `workSpace` is a writable buffer which must be 4-bytes aligned,
- * `workSpaceSize` must be >= HIST_WKSP_SIZE
- */
-size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
-                       const void* src, size_t srcSize,
-                       void* workSpace, size_t workSpaceSize);
-
-/** HIST_countFast() :
- *  same as HIST_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr.
- *  This function is unsafe, and will segfault if any value within `src` is `> *maxSymbolValuePtr`
- */
-size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
-                      const void* src, size_t srcSize);
-
-/** HIST_countFast_wksp() :
- *  Same as HIST_countFast(), but using an externally provided scratch buffer.
- * `workSpace` is a writable buffer which must be 4-bytes aligned,
- * `workSpaceSize` must be >= HIST_WKSP_SIZE
- */
-size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
-                           const void* src, size_t srcSize,
-                           void* workSpace, size_t workSpaceSize);
-
-/*! HIST_count_simple() :
- *  Same as HIST_countFast(), this function is unsafe,
- *  and will segfault if any value within `src` is `> *maxSymbolValuePtr`.
- *  It is also a bit slower for large inputs.
- *  However, it does not need any additional memory (not even on stack).
- * @return : count of the most frequent symbol.
- *  Note this function doesn't produce any error (i.e. it must succeed).
- */
-unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,
-                           const void* src, size_t srcSize);
+ 
+ 
+/* --- simple histogram functions --- */ 
+ 
+/*! HIST_count(): 
+ *  Provides the precise count of each byte within a table 'count'. 
+ * 'count' is a table of unsigned int, of minimum size (*maxSymbolValuePtr+1). 
+ *  Updates *maxSymbolValuePtr with actual largest symbol value detected. 
+ * @return : count of the most frequent symbol (which isn't identified). 
+ *           or an error code, which can be tested using HIST_isError(). 
+ *           note : if return == srcSize, there is only one symbol. 
+ */ 
+size_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr, 
+                  const void* src, size_t srcSize); 
+ 
+unsigned HIST_isError(size_t code);  /**< tells if a return value is an error code */ 
+ 
+ 
+/* --- advanced histogram functions --- */ 
+ 
+#define HIST_WKSP_SIZE_U32 1024 
+#define HIST_WKSP_SIZE    (HIST_WKSP_SIZE_U32 * sizeof(unsigned)) 
+/** HIST_count_wksp() : 
+ *  Same as HIST_count(), but using an externally provided scratch buffer. 
+ *  Benefit is this function will use very little stack space. 
+ * `workSpace` is a writable buffer which must be 4-bytes aligned, 
+ * `workSpaceSize` must be >= HIST_WKSP_SIZE 
+ */ 
+size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr, 
+                       const void* src, size_t srcSize, 
+                       void* workSpace, size_t workSpaceSize); 
+ 
+/** HIST_countFast() : 
+ *  same as HIST_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr. 
+ *  This function is unsafe, and will segfault if any value within `src` is `> *maxSymbolValuePtr` 
+ */ 
+size_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr, 
+                      const void* src, size_t srcSize); 
+ 
+/** HIST_countFast_wksp() : 
+ *  Same as HIST_countFast(), but using an externally provided scratch buffer. 
+ * `workSpace` is a writable buffer which must be 4-bytes aligned, 
+ * `workSpaceSize` must be >= HIST_WKSP_SIZE 
+ */ 
+size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr, 
+                           const void* src, size_t srcSize, 
+                           void* workSpace, size_t workSpaceSize); 
+ 
+/*! HIST_count_simple() : 
+ *  Same as HIST_countFast(), this function is unsafe, 
+ *  and will segfault if any value within `src` is `> *maxSymbolValuePtr`. 
+ *  It is also a bit slower for large inputs. 
+ *  However, it does not need any additional memory (not even on stack). 
+ * @return : count of the most frequent symbol. 
+ *  Note this function doesn't produce any error (i.e. it must succeed). 
+ */ 
+unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr, 
+                           const void* src, size_t srcSize); 
diff --git a/contrib/libs/zstd/lib/compress/huf_compress.c b/contrib/libs/zstd/lib/compress/huf_compress.c
index 2b3d6adc2a2..c057c61a188 100644
--- a/contrib/libs/zstd/lib/compress/huf_compress.c
+++ b/contrib/libs/zstd/lib/compress/huf_compress.c
@@ -26,7 +26,7 @@
 #include "../common/zstd_deps.h"     /* ZSTD_memcpy, ZSTD_memset */
 #include "../common/compiler.h"
 #include "../common/bitstream.h"
-#include "hist.h"
+#include "hist.h" 
 #define FSE_STATIC_LINKING_ONLY   /* FSE_optimalTableLog_internal */
 #include "../common/fse.h"        /* header compression */
 #define HUF_STATIC_LINKING_ONLY
@@ -38,7 +38,7 @@
 *  Error Management
 ****************************************************************/
 #define HUF_isError ERR_isError
-#define HUF_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)   /* use only *after* variable declarations */
+#define HUF_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)   /* use only *after* variable declarations */ 
 
 
 /* **************************************************************
@@ -95,7 +95,7 @@ static size_t HUF_compressWeights(void* dst, size_t dstSize, const void* weightT
     BYTE* op = ostart;
     BYTE* const oend = ostart + dstSize;
 
-    unsigned maxSymbolValue = HUF_TABLELOG_MAX;
+    unsigned maxSymbolValue = HUF_TABLELOG_MAX; 
     U32 tableLog = MAX_FSE_TABLELOG_FOR_HUFF_HEADER;
     HUF_CompressWeightsWksp* wksp = (HUF_CompressWeightsWksp*)HUF_alignUpWorkspace(workspace, &workspaceSize, ZSTD_ALIGNOF(U32));
 
@@ -107,7 +107,7 @@ static size_t HUF_compressWeights(void* dst, size_t dstSize, const void* weightT
     /* Scan input and build symbol stats */
     {   unsigned const maxCount = HIST_count_simple(wksp->count, &maxSymbolValue, weightTable, wtSize);   /* never fails */
         if (maxCount == wtSize) return 1;   /* only a single symbol in src : rle */
-        if (maxCount == 1) return 0;        /* each symbol present maximum once => not compressible */
+        if (maxCount == 1) return 0;        /* each symbol present maximum once => not compressible */ 
     }
 
     tableLog = FSE_optimalTableLog(tableLog, wtSize, maxSymbolValue);
@@ -271,13 +271,13 @@ size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void
 }
 
 U32 HUF_getNbBitsFromCTable(HUF_CElt const* CTable, U32 symbolValue)
-{
+{ 
     const HUF_CElt* ct = CTable + 1;
-    assert(symbolValue <= HUF_SYMBOLVALUE_MAX);
+    assert(symbolValue <= HUF_SYMBOLVALUE_MAX); 
     return (U32)HUF_getNbBits(ct[symbolValue]);
-}
-
+} 
 
+ 
 typedef struct nodeElt_s {
     U32 count;
     U16 parent;
@@ -1139,14 +1139,14 @@ size_t HUF_compress4X_usingCTable_bmi2(void* dst, size_t dstSize, const void* sr
     return HUF_compress4X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, bmi2);
 }
 
-typedef enum { HUF_singleStream, HUF_fourStreams } HUF_nbStreams_e;
+typedef enum { HUF_singleStream, HUF_fourStreams } HUF_nbStreams_e; 
 
 static size_t HUF_compressCTable_internal(
                 BYTE* const ostart, BYTE* op, BYTE* const oend,
                 const void* src, size_t srcSize,
-                HUF_nbStreams_e nbStreams, const HUF_CElt* CTable, const int bmi2)
+                HUF_nbStreams_e nbStreams, const HUF_CElt* CTable, const int bmi2) 
 {
-    size_t const cSize = (nbStreams==HUF_singleStream) ?
+    size_t const cSize = (nbStreams==HUF_singleStream) ? 
                          HUF_compress1X_usingCTable_internal(op, (size_t)(oend - op), src, srcSize, CTable, bmi2) :
                          HUF_compress4X_usingCTable_internal(op, (size_t)(oend - op), src, srcSize, CTable, bmi2);
     if (HUF_isError(cSize)) { return cSize; }
@@ -1159,7 +1159,7 @@ static size_t HUF_compressCTable_internal(
 }
 
 typedef struct {
-    unsigned count[HUF_SYMBOLVALUE_MAX + 1];
+    unsigned count[HUF_SYMBOLVALUE_MAX + 1]; 
     HUF_CElt CTable[HUF_CTABLE_SIZE_ST(HUF_SYMBOLVALUE_MAX)];
     union {
         HUF_buildCTable_wksp_tables buildCTable_wksp;
@@ -1174,13 +1174,13 @@ typedef struct {
 /* HUF_compress_internal() :
  * `workSpace_align4` must be aligned on 4-bytes boundaries,
  * and occupies the same space as a table of HUF_WORKSPACE_SIZE_U64 unsigned */
-static size_t
-HUF_compress_internal (void* dst, size_t dstSize,
-                 const void* src, size_t srcSize,
-                       unsigned maxSymbolValue, unsigned huffLog,
-                       HUF_nbStreams_e nbStreams,
+static size_t 
+HUF_compress_internal (void* dst, size_t dstSize, 
+                 const void* src, size_t srcSize, 
+                       unsigned maxSymbolValue, unsigned huffLog, 
+                       HUF_nbStreams_e nbStreams, 
                        void* workSpace, size_t wkspSize,
-                       HUF_CElt* oldHufTable, HUF_repeat* repeat, int preferRepeat,
+                       HUF_CElt* oldHufTable, HUF_repeat* repeat, int preferRepeat, 
                  const int bmi2, unsigned suspectUncompressible)
 {
     HUF_compress_tables_t* const table = (HUF_compress_tables_t*)HUF_alignUpWorkspace(workSpace, &wkspSize, ZSTD_ALIGNOF(size_t));
@@ -1204,7 +1204,7 @@ HUF_compress_internal (void* dst, size_t dstSize,
     if (preferRepeat && repeat && *repeat == HUF_repeat_valid) {
         return HUF_compressCTable_internal(ostart, op, oend,
                                            src, srcSize,
-                                           nbStreams, oldHufTable, bmi2);
+                                           nbStreams, oldHufTable, bmi2); 
     }
 
     /* If uncompressible data is suspected, do a smaller sampling first */
@@ -1225,7 +1225,7 @@ HUF_compress_internal (void* dst, size_t dstSize,
     /* Scan input and build symbol stats */
     {   CHECK_V_F(largest, HIST_count_wksp (table->count, &maxSymbolValue, (const BYTE*)src, srcSize, table->wksps.hist_wksp, sizeof(table->wksps.hist_wksp)) );
         if (largest == srcSize) { *ostart = ((const BYTE*)src)[0]; return 1; }   /* single symbol, rle */
-        if (largest <= (srcSize >> 7)+4) return 0;   /* heuristic : probably not compressible enough */
+        if (largest <= (srcSize >> 7)+4) return 0;   /* heuristic : probably not compressible enough */ 
     }
 
     /* Check validity of previous table */
@@ -1238,15 +1238,15 @@ HUF_compress_internal (void* dst, size_t dstSize,
     if (preferRepeat && repeat && *repeat != HUF_repeat_none) {
         return HUF_compressCTable_internal(ostart, op, oend,
                                            src, srcSize,
-                                           nbStreams, oldHufTable, bmi2);
+                                           nbStreams, oldHufTable, bmi2); 
     }
 
     /* Build Huffman Tree */
     huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue);
-    {   size_t const maxBits = HUF_buildCTable_wksp(table->CTable, table->count,
-                                            maxSymbolValue, huffLog,
+    {   size_t const maxBits = HUF_buildCTable_wksp(table->CTable, table->count, 
+                                            maxSymbolValue, huffLog, 
                                             &table->wksps.buildCTable_wksp, sizeof(table->wksps.buildCTable_wksp));
-        CHECK_F(maxBits);
+        CHECK_F(maxBits); 
         huffLog = (U32)maxBits;
     }
     /* Zero unused symbols in CTable, so we can check it for validity */
@@ -1266,7 +1266,7 @@ HUF_compress_internal (void* dst, size_t dstSize,
             if (oldSize <= hSize + newSize || hSize + 12 >= srcSize) {
                 return HUF_compressCTable_internal(ostart, op, oend,
                                                    src, srcSize,
-                                                   nbStreams, oldHufTable, bmi2);
+                                                   nbStreams, oldHufTable, bmi2); 
         }   }
 
         /* Use the new huffman table */
@@ -1278,7 +1278,7 @@ HUF_compress_internal (void* dst, size_t dstSize,
     }
     return HUF_compressCTable_internal(ostart, op, oend,
                                        src, srcSize,
-                                       nbStreams, table->CTable, bmi2);
+                                       nbStreams, table->CTable, bmi2); 
 }
 
 
@@ -1288,7 +1288,7 @@ size_t HUF_compress1X_wksp (void* dst, size_t dstSize,
                       void* workSpace, size_t wkspSize)
 {
     return HUF_compress_internal(dst, dstSize, src, srcSize,
-                                 maxSymbolValue, huffLog, HUF_singleStream,
+                                 maxSymbolValue, huffLog, HUF_singleStream, 
                                  workSpace, wkspSize,
                                  NULL, NULL, 0, 0 /*bmi2*/, 0);
 }
@@ -1301,7 +1301,7 @@ size_t HUF_compress1X_repeat (void* dst, size_t dstSize,
                       int bmi2, unsigned suspectUncompressible)
 {
     return HUF_compress_internal(dst, dstSize, src, srcSize,
-                                 maxSymbolValue, huffLog, HUF_singleStream,
+                                 maxSymbolValue, huffLog, HUF_singleStream, 
                                  workSpace, wkspSize, hufTable,
                                  repeat, preferRepeat, bmi2, suspectUncompressible);
 }
@@ -1315,7 +1315,7 @@ size_t HUF_compress4X_wksp (void* dst, size_t dstSize,
                       void* workSpace, size_t wkspSize)
 {
     return HUF_compress_internal(dst, dstSize, src, srcSize,
-                                 maxSymbolValue, huffLog, HUF_fourStreams,
+                                 maxSymbolValue, huffLog, HUF_fourStreams, 
                                  workSpace, wkspSize,
                                  NULL, NULL, 0, 0 /*bmi2*/, 0);
 }
@@ -1331,7 +1331,7 @@ size_t HUF_compress4X_repeat (void* dst, size_t dstSize,
                       HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2, unsigned suspectUncompressible)
 {
     return HUF_compress_internal(dst, dstSize, src, srcSize,
-                                 maxSymbolValue, huffLog, HUF_fourStreams,
+                                 maxSymbolValue, huffLog, HUF_fourStreams, 
                                  workSpace, wkspSize,
                                  hufTable, repeat, preferRepeat, bmi2, suspectUncompressible);
 }
diff --git a/contrib/libs/zstd/lib/compress/zstd_compress.c b/contrib/libs/zstd/lib/compress/zstd_compress.c
index f06456af926..815b51f9172 100644
--- a/contrib/libs/zstd/lib/compress/zstd_compress.c
+++ b/contrib/libs/zstd/lib/compress/zstd_compress.c
@@ -13,7 +13,7 @@
 ***************************************/
 #include "../common/zstd_deps.h"  /* INT_MAX, ZSTD_memset, ZSTD_memcpy */
 #include "../common/mem.h"
-#include "hist.h"           /* HIST_countFast_wksp */
+#include "hist.h"           /* HIST_countFast_wksp */ 
 #define FSE_STATIC_LINKING_ONLY   /* FSE_encodeSymbol */
 #include "../common/fse.h"
 #define HUF_STATIC_LINKING_ONLY
@@ -94,18 +94,18 @@ ZSTD_CCtx* ZSTD_createCCtx(void)
     return ZSTD_createCCtx_advanced(ZSTD_defaultCMem);
 }
 
-static void ZSTD_initCCtx(ZSTD_CCtx* cctx, ZSTD_customMem memManager)
-{
-    assert(cctx != NULL);
+static void ZSTD_initCCtx(ZSTD_CCtx* cctx, ZSTD_customMem memManager) 
+{ 
+    assert(cctx != NULL); 
     ZSTD_memset(cctx, 0, sizeof(*cctx));
-    cctx->customMem = memManager;
+    cctx->customMem = memManager; 
     cctx->bmi2 = ZSTD_cpuSupportsBmi2();
-    {   size_t const err = ZSTD_CCtx_reset(cctx, ZSTD_reset_parameters);
-        assert(!ZSTD_isError(err));
-        (void)err;
-    }
-}
-
+    {   size_t const err = ZSTD_CCtx_reset(cctx, ZSTD_reset_parameters); 
+        assert(!ZSTD_isError(err)); 
+        (void)err; 
+    } 
+} 
+ 
 ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem)
 {
     ZSTD_STATIC_ASSERT(zcss_init==0);
@@ -113,7 +113,7 @@ ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem)
     if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;
     {   ZSTD_CCtx* const cctx = (ZSTD_CCtx*)ZSTD_customMalloc(sizeof(ZSTD_CCtx), customMem);
         if (!cctx) return NULL;
-        ZSTD_initCCtx(cctx, customMem);
+        ZSTD_initCCtx(cctx, customMem); 
         return cctx;
     }
 }
@@ -142,41 +142,41 @@ ZSTD_CCtx* ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize)
     return cctx;
 }
 
-/**
- * Clears and frees all of the dictionaries in the CCtx.
- */
-static void ZSTD_clearAllDicts(ZSTD_CCtx* cctx)
+/** 
+ * Clears and frees all of the dictionaries in the CCtx. 
+ */ 
+static void ZSTD_clearAllDicts(ZSTD_CCtx* cctx) 
 {
     ZSTD_customFree(cctx->localDict.dictBuffer, cctx->customMem);
-    ZSTD_freeCDict(cctx->localDict.cdict);
+    ZSTD_freeCDict(cctx->localDict.cdict); 
     ZSTD_memset(&cctx->localDict, 0, sizeof(cctx->localDict));
     ZSTD_memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));
-    cctx->cdict = NULL;
-}
-
-static size_t ZSTD_sizeof_localDict(ZSTD_localDict dict)
-{
-    size_t const bufferSize = dict.dictBuffer != NULL ? dict.dictSize : 0;
-    size_t const cdictSize = ZSTD_sizeof_CDict(dict.cdict);
-    return bufferSize + cdictSize;
-}
-
-static void ZSTD_freeCCtxContent(ZSTD_CCtx* cctx)
-{
-    assert(cctx != NULL);
-    assert(cctx->staticSize == 0);
-    ZSTD_clearAllDicts(cctx);
+    cctx->cdict = NULL; 
+} 
+ 
+static size_t ZSTD_sizeof_localDict(ZSTD_localDict dict) 
+{ 
+    size_t const bufferSize = dict.dictBuffer != NULL ? dict.dictSize : 0; 
+    size_t const cdictSize = ZSTD_sizeof_CDict(dict.cdict); 
+    return bufferSize + cdictSize; 
+} 
+ 
+static void ZSTD_freeCCtxContent(ZSTD_CCtx* cctx) 
+{ 
+    assert(cctx != NULL); 
+    assert(cctx->staticSize == 0); 
+    ZSTD_clearAllDicts(cctx); 
 #ifdef ZSTD_MULTITHREAD
     ZSTDMT_freeCCtx(cctx->mtctx); cctx->mtctx = NULL;
 #endif
     ZSTD_cwksp_free(&cctx->workspace, cctx->customMem);
-}
-
-size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx)
-{
-    if (cctx==NULL) return 0;   /* support free on NULL */
-    RETURN_ERROR_IF(cctx->staticSize, memory_allocation,
-                    "not compatible with static CCtx");
+} 
+ 
+size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx) 
+{ 
+    if (cctx==NULL) return 0;   /* support free on NULL */ 
+    RETURN_ERROR_IF(cctx->staticSize, memory_allocation, 
+                    "not compatible with static CCtx"); 
     {
         int cctxInWorkspace = ZSTD_cwksp_owns_buffer(&cctx->workspace, cctx);
         ZSTD_freeCCtxContent(cctx);
@@ -184,7 +184,7 @@ size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx)
             ZSTD_customFree(cctx, cctx->customMem);
         }
     }
-    return 0;
+    return 0; 
 }
 
 
@@ -193,7 +193,7 @@ static size_t ZSTD_sizeof_mtctx(const ZSTD_CCtx* cctx)
 #ifdef ZSTD_MULTITHREAD
     return ZSTDMT_sizeof_CCtx(cctx->mtctx);
 #else
-    (void)cctx;
+    (void)cctx; 
     return 0;
 #endif
 }
@@ -205,7 +205,7 @@ size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx)
     /* cctx may be in the workspace */
     return (cctx->workspace.workspace == cctx ? 0 : sizeof(*cctx))
            + ZSTD_cwksp_sizeof(&cctx->workspace)
-           + ZSTD_sizeof_localDict(cctx->localDict)
+           + ZSTD_sizeof_localDict(cctx->localDict) 
            + ZSTD_sizeof_mtctx(cctx);
 }
 
@@ -383,154 +383,154 @@ static void ZSTD_CCtxParams_setZstdParams(
     cctxParams->compressionLevel = ZSTD_NO_CLEVEL;
 }
 
-ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param)
-{
-    ZSTD_bounds bounds = { 0, 0, 0 };
-
-    switch(param)
-    {
-    case ZSTD_c_compressionLevel:
-        bounds.lowerBound = ZSTD_minCLevel();
-        bounds.upperBound = ZSTD_maxCLevel();
-        return bounds;
-
-    case ZSTD_c_windowLog:
-        bounds.lowerBound = ZSTD_WINDOWLOG_MIN;
-        bounds.upperBound = ZSTD_WINDOWLOG_MAX;
-        return bounds;
-
-    case ZSTD_c_hashLog:
-        bounds.lowerBound = ZSTD_HASHLOG_MIN;
-        bounds.upperBound = ZSTD_HASHLOG_MAX;
-        return bounds;
-
-    case ZSTD_c_chainLog:
-        bounds.lowerBound = ZSTD_CHAINLOG_MIN;
-        bounds.upperBound = ZSTD_CHAINLOG_MAX;
-        return bounds;
-
-    case ZSTD_c_searchLog:
-        bounds.lowerBound = ZSTD_SEARCHLOG_MIN;
-        bounds.upperBound = ZSTD_SEARCHLOG_MAX;
-        return bounds;
-
-    case ZSTD_c_minMatch:
-        bounds.lowerBound = ZSTD_MINMATCH_MIN;
-        bounds.upperBound = ZSTD_MINMATCH_MAX;
-        return bounds;
-
-    case ZSTD_c_targetLength:
-        bounds.lowerBound = ZSTD_TARGETLENGTH_MIN;
-        bounds.upperBound = ZSTD_TARGETLENGTH_MAX;
-        return bounds;
-
-    case ZSTD_c_strategy:
-        bounds.lowerBound = ZSTD_STRATEGY_MIN;
-        bounds.upperBound = ZSTD_STRATEGY_MAX;
-        return bounds;
-
-    case ZSTD_c_contentSizeFlag:
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_checksumFlag:
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_dictIDFlag:
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_nbWorkers:
-        bounds.lowerBound = 0;
+ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param) 
+{ 
+    ZSTD_bounds bounds = { 0, 0, 0 }; 
+
+    switch(param) 
+    { 
+    case ZSTD_c_compressionLevel: 
+        bounds.lowerBound = ZSTD_minCLevel(); 
+        bounds.upperBound = ZSTD_maxCLevel(); 
+        return bounds; 
+
+    case ZSTD_c_windowLog: 
+        bounds.lowerBound = ZSTD_WINDOWLOG_MIN; 
+        bounds.upperBound = ZSTD_WINDOWLOG_MAX; 
+        return bounds; 
+ 
+    case ZSTD_c_hashLog: 
+        bounds.lowerBound = ZSTD_HASHLOG_MIN; 
+        bounds.upperBound = ZSTD_HASHLOG_MAX; 
+        return bounds; 
+ 
+    case ZSTD_c_chainLog: 
+        bounds.lowerBound = ZSTD_CHAINLOG_MIN; 
+        bounds.upperBound = ZSTD_CHAINLOG_MAX; 
+        return bounds; 
+ 
+    case ZSTD_c_searchLog: 
+        bounds.lowerBound = ZSTD_SEARCHLOG_MIN; 
+        bounds.upperBound = ZSTD_SEARCHLOG_MAX; 
+        return bounds; 
+ 
+    case ZSTD_c_minMatch: 
+        bounds.lowerBound = ZSTD_MINMATCH_MIN; 
+        bounds.upperBound = ZSTD_MINMATCH_MAX; 
+        return bounds; 
+ 
+    case ZSTD_c_targetLength: 
+        bounds.lowerBound = ZSTD_TARGETLENGTH_MIN; 
+        bounds.upperBound = ZSTD_TARGETLENGTH_MAX; 
+        return bounds; 
+ 
+    case ZSTD_c_strategy: 
+        bounds.lowerBound = ZSTD_STRATEGY_MIN; 
+        bounds.upperBound = ZSTD_STRATEGY_MAX; 
+        return bounds; 
+ 
+    case ZSTD_c_contentSizeFlag: 
+        bounds.lowerBound = 0; 
+        bounds.upperBound = 1; 
+        return bounds; 
+ 
+    case ZSTD_c_checksumFlag: 
+        bounds.lowerBound = 0; 
+        bounds.upperBound = 1; 
+        return bounds; 
+ 
+    case ZSTD_c_dictIDFlag: 
+        bounds.lowerBound = 0; 
+        bounds.upperBound = 1; 
+        return bounds; 
+ 
+    case ZSTD_c_nbWorkers: 
+        bounds.lowerBound = 0; 
+#ifdef ZSTD_MULTITHREAD 
+        bounds.upperBound = ZSTDMT_NBWORKERS_MAX; 
+#else 
+        bounds.upperBound = 0; 
+#endif 
+        return bounds; 
+ 
+    case ZSTD_c_jobSize: 
+        bounds.lowerBound = 0; 
+#ifdef ZSTD_MULTITHREAD 
+        bounds.upperBound = ZSTDMT_JOBSIZE_MAX; 
+#else 
+        bounds.upperBound = 0; 
+#endif 
+        return bounds; 
+ 
+    case ZSTD_c_overlapLog: 
 #ifdef ZSTD_MULTITHREAD
-        bounds.upperBound = ZSTDMT_NBWORKERS_MAX;
+        bounds.lowerBound = ZSTD_OVERLAPLOG_MIN; 
+        bounds.upperBound = ZSTD_OVERLAPLOG_MAX; 
 #else
-        bounds.upperBound = 0;
-#endif
-        return bounds;
-
-    case ZSTD_c_jobSize:
         bounds.lowerBound = 0;
-#ifdef ZSTD_MULTITHREAD
-        bounds.upperBound = ZSTDMT_JOBSIZE_MAX;
-#else
         bounds.upperBound = 0;
 #endif
-        return bounds;
-
-    case ZSTD_c_overlapLog:
-#ifdef ZSTD_MULTITHREAD
-        bounds.lowerBound = ZSTD_OVERLAPLOG_MIN;
-        bounds.upperBound = ZSTD_OVERLAPLOG_MAX;
-#else
-        bounds.lowerBound = 0;
-        bounds.upperBound = 0;
-#endif
-        return bounds;
-
+        return bounds; 
+ 
     case ZSTD_c_enableDedicatedDictSearch:
         bounds.lowerBound = 0;
         bounds.upperBound = 1;
         return bounds;
 
-    case ZSTD_c_enableLongDistanceMatching:
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_ldmHashLog:
-        bounds.lowerBound = ZSTD_LDM_HASHLOG_MIN;
-        bounds.upperBound = ZSTD_LDM_HASHLOG_MAX;
-        return bounds;
-
-    case ZSTD_c_ldmMinMatch:
-        bounds.lowerBound = ZSTD_LDM_MINMATCH_MIN;
-        bounds.upperBound = ZSTD_LDM_MINMATCH_MAX;
-        return bounds;
-
-    case ZSTD_c_ldmBucketSizeLog:
-        bounds.lowerBound = ZSTD_LDM_BUCKETSIZELOG_MIN;
-        bounds.upperBound = ZSTD_LDM_BUCKETSIZELOG_MAX;
-        return bounds;
-
-    case ZSTD_c_ldmHashRateLog:
-        bounds.lowerBound = ZSTD_LDM_HASHRATELOG_MIN;
-        bounds.upperBound = ZSTD_LDM_HASHRATELOG_MAX;
-        return bounds;
-
-    /* experimental parameters */
-    case ZSTD_c_rsyncable:
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_forceMaxWindow :
-        bounds.lowerBound = 0;
-        bounds.upperBound = 1;
-        return bounds;
-
-    case ZSTD_c_format:
-        ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);
-        bounds.lowerBound = ZSTD_f_zstd1;
-        bounds.upperBound = ZSTD_f_zstd1_magicless;   /* note : how to ensure at compile time that this is the highest value enum ? */
-        return bounds;
-
-    case ZSTD_c_forceAttachDict:
+    case ZSTD_c_enableLongDistanceMatching: 
+        bounds.lowerBound = 0; 
+        bounds.upperBound = 1; 
+        return bounds; 
+ 
+    case ZSTD_c_ldmHashLog: 
+        bounds.lowerBound = ZSTD_LDM_HASHLOG_MIN; 
+        bounds.upperBound = ZSTD_LDM_HASHLOG_MAX; 
+        return bounds; 
+ 
+    case ZSTD_c_ldmMinMatch: 
+        bounds.lowerBound = ZSTD_LDM_MINMATCH_MIN; 
+        bounds.upperBound = ZSTD_LDM_MINMATCH_MAX; 
+        return bounds; 
+ 
+    case ZSTD_c_ldmBucketSizeLog: 
+        bounds.lowerBound = ZSTD_LDM_BUCKETSIZELOG_MIN; 
+        bounds.upperBound = ZSTD_LDM_BUCKETSIZELOG_MAX; 
+        return bounds; 
+ 
+    case ZSTD_c_ldmHashRateLog: 
+        bounds.lowerBound = ZSTD_LDM_HASHRATELOG_MIN; 
+        bounds.upperBound = ZSTD_LDM_HASHRATELOG_MAX; 
+        return bounds; 
+ 
+    /* experimental parameters */ 
+    case ZSTD_c_rsyncable: 
+        bounds.lowerBound = 0; 
+        bounds.upperBound = 1; 
+        return bounds; 
+ 
+    case ZSTD_c_forceMaxWindow : 
+        bounds.lowerBound = 0; 
+        bounds.upperBound = 1; 
+        return bounds; 
+ 
+    case ZSTD_c_format: 
+        ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless); 
+        bounds.lowerBound = ZSTD_f_zstd1; 
+        bounds.upperBound = ZSTD_f_zstd1_magicless;   /* note : how to ensure at compile time that this is the highest value enum ? */ 
+        return bounds; 
+ 
+    case ZSTD_c_forceAttachDict: 
         ZSTD_STATIC_ASSERT(ZSTD_dictDefaultAttach < ZSTD_dictForceLoad);
-        bounds.lowerBound = ZSTD_dictDefaultAttach;
+        bounds.lowerBound = ZSTD_dictDefaultAttach; 
         bounds.upperBound = ZSTD_dictForceLoad;       /* note : how to ensure at compile time that this is the highest value enum ? */
-        return bounds;
-
-    case ZSTD_c_literalCompressionMode:
+        return bounds; 
+ 
+    case ZSTD_c_literalCompressionMode: 
         ZSTD_STATIC_ASSERT(ZSTD_ps_auto < ZSTD_ps_enable && ZSTD_ps_enable < ZSTD_ps_disable);
         bounds.lowerBound = (int)ZSTD_ps_auto;
         bounds.upperBound = (int)ZSTD_ps_disable;
-        return bounds;
-
+        return bounds; 
+ 
     case ZSTD_c_targetCBlockSize:
         bounds.lowerBound = ZSTD_TARGETCBLOCKSIZE_MIN;
         bounds.upperBound = ZSTD_TARGETCBLOCKSIZE_MAX;
@@ -572,61 +572,61 @@ ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param)
         bounds.upperBound = 1;
         return bounds;
 
-    default:
+    default: 
         bounds.error = ERROR(parameter_unsupported);
         return bounds;
-    }
-}
-
-/* ZSTD_cParam_clampBounds:
- * Clamps the value into the bounded range.
- */
-static size_t ZSTD_cParam_clampBounds(ZSTD_cParameter cParam, int* value)
-{
-    ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);
-    if (ZSTD_isError(bounds.error)) return bounds.error;
-    if (*value < bounds.lowerBound) *value = bounds.lowerBound;
-    if (*value > bounds.upperBound) *value = bounds.upperBound;
-    return 0;
-}
-
-#define BOUNDCHECK(cParam, val) { \
-    RETURN_ERROR_IF(!ZSTD_cParam_withinBounds(cParam,val), \
+    } 
+} 
+ 
+/* ZSTD_cParam_clampBounds: 
+ * Clamps the value into the bounded range. 
+ */ 
+static size_t ZSTD_cParam_clampBounds(ZSTD_cParameter cParam, int* value) 
+{ 
+    ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam); 
+    if (ZSTD_isError(bounds.error)) return bounds.error; 
+    if (*value < bounds.lowerBound) *value = bounds.lowerBound; 
+    if (*value > bounds.upperBound) *value = bounds.upperBound; 
+    return 0; 
+} 
+ 
+#define BOUNDCHECK(cParam, val) { \ 
+    RETURN_ERROR_IF(!ZSTD_cParam_withinBounds(cParam,val), \ 
                     parameter_outOfBound, "Param out of bounds"); \
-}
-
-
+} 
+ 
+ 
 static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param)
 {
     switch(param)
     {
-    case ZSTD_c_compressionLevel:
-    case ZSTD_c_hashLog:
-    case ZSTD_c_chainLog:
-    case ZSTD_c_searchLog:
-    case ZSTD_c_minMatch:
-    case ZSTD_c_targetLength:
-    case ZSTD_c_strategy:
+    case ZSTD_c_compressionLevel: 
+    case ZSTD_c_hashLog: 
+    case ZSTD_c_chainLog: 
+    case ZSTD_c_searchLog: 
+    case ZSTD_c_minMatch: 
+    case ZSTD_c_targetLength: 
+    case ZSTD_c_strategy: 
         return 1;
 
-    case ZSTD_c_format:
-    case ZSTD_c_windowLog:
-    case ZSTD_c_contentSizeFlag:
-    case ZSTD_c_checksumFlag:
-    case ZSTD_c_dictIDFlag:
-    case ZSTD_c_forceMaxWindow :
-    case ZSTD_c_nbWorkers:
-    case ZSTD_c_jobSize:
-    case ZSTD_c_overlapLog:
-    case ZSTD_c_rsyncable:
+    case ZSTD_c_format: 
+    case ZSTD_c_windowLog: 
+    case ZSTD_c_contentSizeFlag: 
+    case ZSTD_c_checksumFlag: 
+    case ZSTD_c_dictIDFlag: 
+    case ZSTD_c_forceMaxWindow : 
+    case ZSTD_c_nbWorkers: 
+    case ZSTD_c_jobSize: 
+    case ZSTD_c_overlapLog: 
+    case ZSTD_c_rsyncable: 
     case ZSTD_c_enableDedicatedDictSearch:
-    case ZSTD_c_enableLongDistanceMatching:
-    case ZSTD_c_ldmHashLog:
-    case ZSTD_c_ldmMinMatch:
-    case ZSTD_c_ldmBucketSizeLog:
-    case ZSTD_c_ldmHashRateLog:
-    case ZSTD_c_forceAttachDict:
-    case ZSTD_c_literalCompressionMode:
+    case ZSTD_c_enableLongDistanceMatching: 
+    case ZSTD_c_ldmHashLog: 
+    case ZSTD_c_ldmMinMatch: 
+    case ZSTD_c_ldmBucketSizeLog: 
+    case ZSTD_c_ldmHashRateLog: 
+    case ZSTD_c_forceAttachDict: 
+    case ZSTD_c_literalCompressionMode: 
     case ZSTD_c_targetCBlockSize:
     case ZSTD_c_srcSizeHint:
     case ZSTD_c_stableInBuffer:
@@ -641,9 +641,9 @@ static int ZSTD_isUpdateAuthorized(ZSTD_cParameter param)
     }
 }
 
-size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value)
+size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value) 
 {
-    DEBUGLOG(4, "ZSTD_CCtx_setParameter (%i, %i)", (int)param, value);
+    DEBUGLOG(4, "ZSTD_CCtx_setParameter (%i, %i)", (int)param, value); 
     if (cctx->streamStage != zcss_init) {
         if (ZSTD_isUpdateAuthorized(param)) {
             cctx->cParamsChanged = 1;
@@ -653,35 +653,35 @@ size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value)
 
     switch(param)
     {
-    case ZSTD_c_nbWorkers:
-        RETURN_ERROR_IF((value!=0) && cctx->staticSize, parameter_unsupported,
-                        "MT not compatible with static alloc");
-        break;
-
-    case ZSTD_c_compressionLevel:
-    case ZSTD_c_windowLog:
-    case ZSTD_c_hashLog:
-    case ZSTD_c_chainLog:
-    case ZSTD_c_searchLog:
-    case ZSTD_c_minMatch:
-    case ZSTD_c_targetLength:
-    case ZSTD_c_strategy:
-    case ZSTD_c_ldmHashRateLog:
-    case ZSTD_c_format:
-    case ZSTD_c_contentSizeFlag:
-    case ZSTD_c_checksumFlag:
-    case ZSTD_c_dictIDFlag:
-    case ZSTD_c_forceMaxWindow:
-    case ZSTD_c_forceAttachDict:
-    case ZSTD_c_literalCompressionMode:
-    case ZSTD_c_jobSize:
-    case ZSTD_c_overlapLog:
-    case ZSTD_c_rsyncable:
+    case ZSTD_c_nbWorkers: 
+        RETURN_ERROR_IF((value!=0) && cctx->staticSize, parameter_unsupported, 
+                        "MT not compatible with static alloc"); 
+        break; 
+
+    case ZSTD_c_compressionLevel: 
+    case ZSTD_c_windowLog: 
+    case ZSTD_c_hashLog: 
+    case ZSTD_c_chainLog: 
+    case ZSTD_c_searchLog: 
+    case ZSTD_c_minMatch: 
+    case ZSTD_c_targetLength: 
+    case ZSTD_c_strategy: 
+    case ZSTD_c_ldmHashRateLog: 
+    case ZSTD_c_format: 
+    case ZSTD_c_contentSizeFlag: 
+    case ZSTD_c_checksumFlag: 
+    case ZSTD_c_dictIDFlag: 
+    case ZSTD_c_forceMaxWindow: 
+    case ZSTD_c_forceAttachDict: 
+    case ZSTD_c_literalCompressionMode: 
+    case ZSTD_c_jobSize: 
+    case ZSTD_c_overlapLog: 
+    case ZSTD_c_rsyncable: 
     case ZSTD_c_enableDedicatedDictSearch:
-    case ZSTD_c_enableLongDistanceMatching:
-    case ZSTD_c_ldmHashLog:
-    case ZSTD_c_ldmMinMatch:
-    case ZSTD_c_ldmBucketSizeLog:
+    case ZSTD_c_enableLongDistanceMatching: 
+    case ZSTD_c_ldmHashLog: 
+    case ZSTD_c_ldmMinMatch: 
+    case ZSTD_c_ldmBucketSizeLog: 
     case ZSTD_c_targetCBlockSize:
     case ZSTD_c_srcSizeHint:
     case ZSTD_c_stableInBuffer:
@@ -691,184 +691,184 @@ size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value)
     case ZSTD_c_useBlockSplitter:
     case ZSTD_c_useRowMatchFinder:
     case ZSTD_c_deterministicRefPrefix:
-        break;
+        break; 
 
     default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
     }
-    return ZSTD_CCtxParams_setParameter(&cctx->requestedParams, param, value);
+    return ZSTD_CCtxParams_setParameter(&cctx->requestedParams, param, value); 
 }
 
-size_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params* CCtxParams,
-                                    ZSTD_cParameter param, int value)
+size_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params* CCtxParams, 
+                                    ZSTD_cParameter param, int value) 
 {
-    DEBUGLOG(4, "ZSTD_CCtxParams_setParameter (%i, %i)", (int)param, value);
+    DEBUGLOG(4, "ZSTD_CCtxParams_setParameter (%i, %i)", (int)param, value); 
     switch(param)
     {
-    case ZSTD_c_format :
-        BOUNDCHECK(ZSTD_c_format, value);
+    case ZSTD_c_format : 
+        BOUNDCHECK(ZSTD_c_format, value); 
         CCtxParams->format = (ZSTD_format_e)value;
         return (size_t)CCtxParams->format;
 
-    case ZSTD_c_compressionLevel : {
+    case ZSTD_c_compressionLevel : { 
         FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value), "");
         if (value == 0)
             CCtxParams->compressionLevel = ZSTD_CLEVEL_DEFAULT; /* 0 == default */
         else
-            CCtxParams->compressionLevel = value;
+            CCtxParams->compressionLevel = value; 
         if (CCtxParams->compressionLevel >= 0) return (size_t)CCtxParams->compressionLevel;
         return 0;  /* return type (size_t) cannot represent negative values */
     }
 
-    case ZSTD_c_windowLog :
-        if (value!=0)   /* 0 => use default */
-            BOUNDCHECK(ZSTD_c_windowLog, value);
+    case ZSTD_c_windowLog : 
+        if (value!=0)   /* 0 => use default */ 
+            BOUNDCHECK(ZSTD_c_windowLog, value); 
         CCtxParams->cParams.windowLog = (U32)value;
         return CCtxParams->cParams.windowLog;
 
-    case ZSTD_c_hashLog :
-        if (value!=0)   /* 0 => use default */
-            BOUNDCHECK(ZSTD_c_hashLog, value);
+    case ZSTD_c_hashLog : 
+        if (value!=0)   /* 0 => use default */ 
+            BOUNDCHECK(ZSTD_c_hashLog, value); 
         CCtxParams->cParams.hashLog = (U32)value;
         return CCtxParams->cParams.hashLog;
 
-    case ZSTD_c_chainLog :
-        if (value!=0)   /* 0 => use default */
-            BOUNDCHECK(ZSTD_c_chainLog, value);
+    case ZSTD_c_chainLog : 
+        if (value!=0)   /* 0 => use default */ 
+            BOUNDCHECK(ZSTD_c_chainLog, value); 
         CCtxParams->cParams.chainLog = (U32)value;
         return CCtxParams->cParams.chainLog;
 
-    case ZSTD_c_searchLog :
-        if (value!=0)   /* 0 => use default */
-            BOUNDCHECK(ZSTD_c_searchLog, value);
+    case ZSTD_c_searchLog : 
+        if (value!=0)   /* 0 => use default */ 
+            BOUNDCHECK(ZSTD_c_searchLog, value); 
         CCtxParams->cParams.searchLog = (U32)value;
         return (size_t)value;
 
-    case ZSTD_c_minMatch :
-        if (value!=0)   /* 0 => use default */
-            BOUNDCHECK(ZSTD_c_minMatch, value);
-        CCtxParams->cParams.minMatch = value;
-        return CCtxParams->cParams.minMatch;
+    case ZSTD_c_minMatch : 
+        if (value!=0)   /* 0 => use default */ 
+            BOUNDCHECK(ZSTD_c_minMatch, value); 
+        CCtxParams->cParams.minMatch = value; 
+        return CCtxParams->cParams.minMatch; 
 
-    case ZSTD_c_targetLength :
-        BOUNDCHECK(ZSTD_c_targetLength, value);
+    case ZSTD_c_targetLength : 
+        BOUNDCHECK(ZSTD_c_targetLength, value); 
         CCtxParams->cParams.targetLength = value;
         return CCtxParams->cParams.targetLength;
 
-    case ZSTD_c_strategy :
-        if (value!=0)   /* 0 => use default */
-            BOUNDCHECK(ZSTD_c_strategy, value);
+    case ZSTD_c_strategy : 
+        if (value!=0)   /* 0 => use default */ 
+            BOUNDCHECK(ZSTD_c_strategy, value); 
         CCtxParams->cParams.strategy = (ZSTD_strategy)value;
         return (size_t)CCtxParams->cParams.strategy;
 
-    case ZSTD_c_contentSizeFlag :
+    case ZSTD_c_contentSizeFlag : 
         /* Content size written in frame header _when known_ (default:1) */
-        DEBUGLOG(4, "set content size flag = %u", (value!=0));
-        CCtxParams->fParams.contentSizeFlag = value != 0;
+        DEBUGLOG(4, "set content size flag = %u", (value!=0)); 
+        CCtxParams->fParams.contentSizeFlag = value != 0; 
         return CCtxParams->fParams.contentSizeFlag;
 
-    case ZSTD_c_checksumFlag :
+    case ZSTD_c_checksumFlag : 
         /* A 32-bits content checksum will be calculated and written at end of frame (default:0) */
-        CCtxParams->fParams.checksumFlag = value != 0;
+        CCtxParams->fParams.checksumFlag = value != 0; 
         return CCtxParams->fParams.checksumFlag;
 
-    case ZSTD_c_dictIDFlag : /* When applicable, dictionary's dictID is provided in frame header (default:1) */
-        DEBUGLOG(4, "set dictIDFlag = %u", (value!=0));
+    case ZSTD_c_dictIDFlag : /* When applicable, dictionary's dictID is provided in frame header (default:1) */ 
+        DEBUGLOG(4, "set dictIDFlag = %u", (value!=0)); 
         CCtxParams->fParams.noDictIDFlag = !value;
         return !CCtxParams->fParams.noDictIDFlag;
 
-    case ZSTD_c_forceMaxWindow :
-        CCtxParams->forceWindow = (value != 0);
+    case ZSTD_c_forceMaxWindow : 
+        CCtxParams->forceWindow = (value != 0); 
         return CCtxParams->forceWindow;
 
-    case ZSTD_c_forceAttachDict : {
-        const ZSTD_dictAttachPref_e pref = (ZSTD_dictAttachPref_e)value;
-        BOUNDCHECK(ZSTD_c_forceAttachDict, pref);
-        CCtxParams->attachDictPref = pref;
-        return CCtxParams->attachDictPref;
-    }
-
-    case ZSTD_c_literalCompressionMode : {
+    case ZSTD_c_forceAttachDict : { 
+        const ZSTD_dictAttachPref_e pref = (ZSTD_dictAttachPref_e)value; 
+        BOUNDCHECK(ZSTD_c_forceAttachDict, pref); 
+        CCtxParams->attachDictPref = pref; 
+        return CCtxParams->attachDictPref; 
+    } 
+ 
+    case ZSTD_c_literalCompressionMode : { 
         const ZSTD_paramSwitch_e lcm = (ZSTD_paramSwitch_e)value;
-        BOUNDCHECK(ZSTD_c_literalCompressionMode, lcm);
-        CCtxParams->literalCompressionMode = lcm;
-        return CCtxParams->literalCompressionMode;
-    }
-
-    case ZSTD_c_nbWorkers :
+        BOUNDCHECK(ZSTD_c_literalCompressionMode, lcm); 
+        CCtxParams->literalCompressionMode = lcm; 
+        return CCtxParams->literalCompressionMode; 
+    } 
+ 
+    case ZSTD_c_nbWorkers : 
 #ifndef ZSTD_MULTITHREAD
-        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
+        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading"); 
         return 0;
 #else
         FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value), "");
-        CCtxParams->nbWorkers = value;
-        return CCtxParams->nbWorkers;
+        CCtxParams->nbWorkers = value; 
+        return CCtxParams->nbWorkers; 
 #endif
 
-    case ZSTD_c_jobSize :
+    case ZSTD_c_jobSize : 
 #ifndef ZSTD_MULTITHREAD
-        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
-        return 0;
+        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading"); 
+        return 0; 
 #else
-        /* Adjust to the minimum non-default value. */
-        if (value != 0 && value < ZSTDMT_JOBSIZE_MIN)
-            value = ZSTDMT_JOBSIZE_MIN;
+        /* Adjust to the minimum non-default value. */ 
+        if (value != 0 && value < ZSTDMT_JOBSIZE_MIN) 
+            value = ZSTDMT_JOBSIZE_MIN; 
         FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value), "");
-        assert(value >= 0);
-        CCtxParams->jobSize = value;
-        return CCtxParams->jobSize;
+        assert(value >= 0); 
+        CCtxParams->jobSize = value; 
+        return CCtxParams->jobSize; 
 #endif
 
-    case ZSTD_c_overlapLog :
+    case ZSTD_c_overlapLog : 
 #ifndef ZSTD_MULTITHREAD
-        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
-        return 0;
+        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading"); 
+        return 0; 
 #else
         FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(ZSTD_c_overlapLog, &value), "");
-        CCtxParams->overlapLog = value;
-        return CCtxParams->overlapLog;
+        CCtxParams->overlapLog = value; 
+        return CCtxParams->overlapLog; 
 #endif
 
-    case ZSTD_c_rsyncable :
-#ifndef ZSTD_MULTITHREAD
-        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading");
-        return 0;
-#else
+    case ZSTD_c_rsyncable : 
+#ifndef ZSTD_MULTITHREAD 
+        RETURN_ERROR_IF(value!=0, parameter_unsupported, "not compiled with multithreading"); 
+        return 0; 
+#else 
         FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(ZSTD_c_overlapLog, &value), "");
-        CCtxParams->rsyncable = value;
-        return CCtxParams->rsyncable;
-#endif
-
+        CCtxParams->rsyncable = value; 
+        return CCtxParams->rsyncable; 
+#endif 
+ 
     case ZSTD_c_enableDedicatedDictSearch :
         CCtxParams->enableDedicatedDictSearch = (value!=0);
         return CCtxParams->enableDedicatedDictSearch;
 
-    case ZSTD_c_enableLongDistanceMatching :
+    case ZSTD_c_enableLongDistanceMatching : 
         CCtxParams->ldmParams.enableLdm = (ZSTD_paramSwitch_e)value;
         return CCtxParams->ldmParams.enableLdm;
 
-    case ZSTD_c_ldmHashLog :
-        if (value!=0)   /* 0 ==> auto */
-            BOUNDCHECK(ZSTD_c_ldmHashLog, value);
+    case ZSTD_c_ldmHashLog : 
+        if (value!=0)   /* 0 ==> auto */ 
+            BOUNDCHECK(ZSTD_c_ldmHashLog, value); 
         CCtxParams->ldmParams.hashLog = value;
         return CCtxParams->ldmParams.hashLog;
 
-    case ZSTD_c_ldmMinMatch :
-        if (value!=0)   /* 0 ==> default */
-            BOUNDCHECK(ZSTD_c_ldmMinMatch, value);
+    case ZSTD_c_ldmMinMatch : 
+        if (value!=0)   /* 0 ==> default */ 
+            BOUNDCHECK(ZSTD_c_ldmMinMatch, value); 
         CCtxParams->ldmParams.minMatchLength = value;
         return CCtxParams->ldmParams.minMatchLength;
 
-    case ZSTD_c_ldmBucketSizeLog :
-        if (value!=0)   /* 0 ==> default */
-            BOUNDCHECK(ZSTD_c_ldmBucketSizeLog, value);
+    case ZSTD_c_ldmBucketSizeLog : 
+        if (value!=0)   /* 0 ==> default */ 
+            BOUNDCHECK(ZSTD_c_ldmBucketSizeLog, value); 
         CCtxParams->ldmParams.bucketSizeLog = value;
         return CCtxParams->ldmParams.bucketSizeLog;
 
-    case ZSTD_c_ldmHashRateLog :
+    case ZSTD_c_ldmHashRateLog : 
         if (value!=0)   /* 0 ==> default */
             BOUNDCHECK(ZSTD_c_ldmHashRateLog, value);
-        CCtxParams->ldmParams.hashRateLog = value;
-        return CCtxParams->ldmParams.hashRateLog;
+        CCtxParams->ldmParams.hashRateLog = value; 
+        return CCtxParams->ldmParams.hashRateLog; 
 
     case ZSTD_c_targetCBlockSize :
         if (value!=0)   /* 0 ==> default */
@@ -917,111 +917,111 @@ size_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params* CCtxParams,
         CCtxParams->deterministicRefPrefix = !!value;
         return CCtxParams->deterministicRefPrefix;
 
-    default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
+    default: RETURN_ERROR(parameter_unsupported, "unknown parameter"); 
     }
 }
 
 size_t ZSTD_CCtx_getParameter(ZSTD_CCtx const* cctx, ZSTD_cParameter param, int* value)
-{
-    return ZSTD_CCtxParams_getParameter(&cctx->requestedParams, param, value);
-}
-
-size_t ZSTD_CCtxParams_getParameter(
+{ 
+    return ZSTD_CCtxParams_getParameter(&cctx->requestedParams, param, value); 
+} 
+ 
+size_t ZSTD_CCtxParams_getParameter( 
         ZSTD_CCtx_params const* CCtxParams, ZSTD_cParameter param, int* value)
-{
-    switch(param)
-    {
-    case ZSTD_c_format :
-        *value = CCtxParams->format;
-        break;
-    case ZSTD_c_compressionLevel :
-        *value = CCtxParams->compressionLevel;
-        break;
-    case ZSTD_c_windowLog :
+{ 
+    switch(param) 
+    { 
+    case ZSTD_c_format : 
+        *value = CCtxParams->format; 
+        break; 
+    case ZSTD_c_compressionLevel : 
+        *value = CCtxParams->compressionLevel; 
+        break; 
+    case ZSTD_c_windowLog : 
         *value = (int)CCtxParams->cParams.windowLog;
-        break;
-    case ZSTD_c_hashLog :
+        break; 
+    case ZSTD_c_hashLog : 
         *value = (int)CCtxParams->cParams.hashLog;
-        break;
-    case ZSTD_c_chainLog :
+        break; 
+    case ZSTD_c_chainLog : 
         *value = (int)CCtxParams->cParams.chainLog;
-        break;
-    case ZSTD_c_searchLog :
-        *value = CCtxParams->cParams.searchLog;
-        break;
-    case ZSTD_c_minMatch :
-        *value = CCtxParams->cParams.minMatch;
-        break;
-    case ZSTD_c_targetLength :
-        *value = CCtxParams->cParams.targetLength;
-        break;
-    case ZSTD_c_strategy :
-        *value = (unsigned)CCtxParams->cParams.strategy;
-        break;
-    case ZSTD_c_contentSizeFlag :
-        *value = CCtxParams->fParams.contentSizeFlag;
-        break;
-    case ZSTD_c_checksumFlag :
-        *value = CCtxParams->fParams.checksumFlag;
-        break;
-    case ZSTD_c_dictIDFlag :
-        *value = !CCtxParams->fParams.noDictIDFlag;
-        break;
-    case ZSTD_c_forceMaxWindow :
-        *value = CCtxParams->forceWindow;
-        break;
-    case ZSTD_c_forceAttachDict :
-        *value = CCtxParams->attachDictPref;
-        break;
-    case ZSTD_c_literalCompressionMode :
-        *value = CCtxParams->literalCompressionMode;
-        break;
-    case ZSTD_c_nbWorkers :
-#ifndef ZSTD_MULTITHREAD
-        assert(CCtxParams->nbWorkers == 0);
-#endif
-        *value = CCtxParams->nbWorkers;
-        break;
-    case ZSTD_c_jobSize :
-#ifndef ZSTD_MULTITHREAD
-        RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
-#else
-        assert(CCtxParams->jobSize <= INT_MAX);
-        *value = (int)CCtxParams->jobSize;
-        break;
-#endif
-    case ZSTD_c_overlapLog :
-#ifndef ZSTD_MULTITHREAD
-        RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
-#else
-        *value = CCtxParams->overlapLog;
-        break;
-#endif
-    case ZSTD_c_rsyncable :
-#ifndef ZSTD_MULTITHREAD
-        RETURN_ERROR(parameter_unsupported, "not compiled with multithreading");
-#else
-        *value = CCtxParams->rsyncable;
-        break;
-#endif
+        break; 
+    case ZSTD_c_searchLog : 
+        *value = CCtxParams->cParams.searchLog; 
+        break; 
+    case ZSTD_c_minMatch : 
+        *value = CCtxParams->cParams.minMatch; 
+        break; 
+    case ZSTD_c_targetLength : 
+        *value = CCtxParams->cParams.targetLength; 
+        break; 
+    case ZSTD_c_strategy : 
+        *value = (unsigned)CCtxParams->cParams.strategy; 
+        break; 
+    case ZSTD_c_contentSizeFlag : 
+        *value = CCtxParams->fParams.contentSizeFlag; 
+        break; 
+    case ZSTD_c_checksumFlag : 
+        *value = CCtxParams->fParams.checksumFlag; 
+        break; 
+    case ZSTD_c_dictIDFlag : 
+        *value = !CCtxParams->fParams.noDictIDFlag; 
+        break; 
+    case ZSTD_c_forceMaxWindow : 
+        *value = CCtxParams->forceWindow; 
+        break; 
+    case ZSTD_c_forceAttachDict : 
+        *value = CCtxParams->attachDictPref; 
+        break; 
+    case ZSTD_c_literalCompressionMode : 
+        *value = CCtxParams->literalCompressionMode; 
+        break; 
+    case ZSTD_c_nbWorkers : 
+#ifndef ZSTD_MULTITHREAD 
+        assert(CCtxParams->nbWorkers == 0); 
+#endif 
+        *value = CCtxParams->nbWorkers; 
+        break; 
+    case ZSTD_c_jobSize : 
+#ifndef ZSTD_MULTITHREAD 
+        RETURN_ERROR(parameter_unsupported, "not compiled with multithreading"); 
+#else 
+        assert(CCtxParams->jobSize <= INT_MAX); 
+        *value = (int)CCtxParams->jobSize; 
+        break; 
+#endif 
+    case ZSTD_c_overlapLog : 
+#ifndef ZSTD_MULTITHREAD 
+        RETURN_ERROR(parameter_unsupported, "not compiled with multithreading"); 
+#else 
+        *value = CCtxParams->overlapLog; 
+        break; 
+#endif 
+    case ZSTD_c_rsyncable : 
+#ifndef ZSTD_MULTITHREAD 
+        RETURN_ERROR(parameter_unsupported, "not compiled with multithreading"); 
+#else 
+        *value = CCtxParams->rsyncable; 
+        break; 
+#endif 
     case ZSTD_c_enableDedicatedDictSearch :
         *value = CCtxParams->enableDedicatedDictSearch;
         break;
-    case ZSTD_c_enableLongDistanceMatching :
-        *value = CCtxParams->ldmParams.enableLdm;
-        break;
-    case ZSTD_c_ldmHashLog :
-        *value = CCtxParams->ldmParams.hashLog;
-        break;
-    case ZSTD_c_ldmMinMatch :
-        *value = CCtxParams->ldmParams.minMatchLength;
-        break;
-    case ZSTD_c_ldmBucketSizeLog :
-        *value = CCtxParams->ldmParams.bucketSizeLog;
-        break;
-    case ZSTD_c_ldmHashRateLog :
-        *value = CCtxParams->ldmParams.hashRateLog;
-        break;
+    case ZSTD_c_enableLongDistanceMatching : 
+        *value = CCtxParams->ldmParams.enableLdm; 
+        break; 
+    case ZSTD_c_ldmHashLog : 
+        *value = CCtxParams->ldmParams.hashLog; 
+        break; 
+    case ZSTD_c_ldmMinMatch : 
+        *value = CCtxParams->ldmParams.minMatchLength; 
+        break; 
+    case ZSTD_c_ldmBucketSizeLog : 
+        *value = CCtxParams->ldmParams.bucketSizeLog; 
+        break; 
+    case ZSTD_c_ldmHashRateLog : 
+        *value = CCtxParams->ldmParams.hashRateLog; 
+        break; 
     case ZSTD_c_targetCBlockSize :
         *value = (int)CCtxParams->targetCBlockSize;
         break;
@@ -1049,11 +1049,11 @@ size_t ZSTD_CCtxParams_getParameter(
     case ZSTD_c_deterministicRefPrefix:
         *value = (int)CCtxParams->deterministicRefPrefix;
         break;
-    default: RETURN_ERROR(parameter_unsupported, "unknown parameter");
-    }
-    return 0;
-}
-
+    default: RETURN_ERROR(parameter_unsupported, "unknown parameter"); 
+    } 
+    return 0; 
+} 
+ 
 /** ZSTD_CCtx_setParametersUsingCCtxParams() :
  *  just applies `params` into `cctx`
  *  no action is performed, parameters are merely stored.
@@ -1064,7 +1064,7 @@ size_t ZSTD_CCtxParams_getParameter(
 size_t ZSTD_CCtx_setParametersUsingCCtxParams(
         ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params)
 {
-    DEBUGLOG(4, "ZSTD_CCtx_setParametersUsingCCtxParams");
+    DEBUGLOG(4, "ZSTD_CCtx_setParametersUsingCCtxParams"); 
     RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
                     "The context is in the wrong stage!");
     RETURN_ERROR_IF(cctx->cdict, stage_wrong,
@@ -1092,42 +1092,42 @@ static int ZSTD_dedicatedDictSearch_isSupported(
 static void ZSTD_dedicatedDictSearch_revertCParams(
         ZSTD_compressionParameters* cParams);
 
-/**
- * Initializes the local dict using the requested parameters.
- * NOTE: This does not use the pledged src size, because it may be used for more
- * than one compression.
- */
-static size_t ZSTD_initLocalDict(ZSTD_CCtx* cctx)
-{
-    ZSTD_localDict* const dl = &cctx->localDict;
-    if (dl->dict == NULL) {
-        /* No local dictionary. */
-        assert(dl->dictBuffer == NULL);
-        assert(dl->cdict == NULL);
-        assert(dl->dictSize == 0);
-        return 0;
-    }
-    if (dl->cdict != NULL) {
-        assert(cctx->cdict == dl->cdict);
-        /* Local dictionary already initialized. */
-        return 0;
-    }
-    assert(dl->dictSize > 0);
-    assert(cctx->cdict == NULL);
-    assert(cctx->prefixDict.dict == NULL);
-
+/** 
+ * Initializes the local dict using the requested parameters. 
+ * NOTE: This does not use the pledged src size, because it may be used for more 
+ * than one compression. 
+ */ 
+static size_t ZSTD_initLocalDict(ZSTD_CCtx* cctx) 
+{ 
+    ZSTD_localDict* const dl = &cctx->localDict; 
+    if (dl->dict == NULL) { 
+        /* No local dictionary. */ 
+        assert(dl->dictBuffer == NULL); 
+        assert(dl->cdict == NULL); 
+        assert(dl->dictSize == 0); 
+        return 0; 
+    } 
+    if (dl->cdict != NULL) { 
+        assert(cctx->cdict == dl->cdict); 
+        /* Local dictionary already initialized. */ 
+        return 0; 
+    } 
+    assert(dl->dictSize > 0); 
+    assert(cctx->cdict == NULL); 
+    assert(cctx->prefixDict.dict == NULL); 
+ 
     dl->cdict = ZSTD_createCDict_advanced2(
-            dl->dict,
-            dl->dictSize,
-            ZSTD_dlm_byRef,
-            dl->dictContentType,
+            dl->dict, 
+            dl->dictSize, 
+            ZSTD_dlm_byRef, 
+            dl->dictContentType, 
             &cctx->requestedParams,
-            cctx->customMem);
+            cctx->customMem); 
     RETURN_ERROR_IF(!dl->cdict, memory_allocation, "ZSTD_createCDict_advanced failed");
-    cctx->cdict = dl->cdict;
-    return 0;
-}
-
+    cctx->cdict = dl->cdict; 
+    return 0; 
+} 
+ 
 size_t ZSTD_CCtx_loadDictionary_advanced(
         ZSTD_CCtx* cctx, const void* dict, size_t dictSize,
         ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType)
@@ -1135,11 +1135,11 @@ size_t ZSTD_CCtx_loadDictionary_advanced(
     RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
                     "Can't load a dictionary when ctx is not in init stage.");
     DEBUGLOG(4, "ZSTD_CCtx_loadDictionary_advanced (size: %u)", (U32)dictSize);
-    ZSTD_clearAllDicts(cctx);  /* in case one already exists */
-    if (dict == NULL || dictSize == 0)  /* no dictionary mode */
-        return 0;
-    if (dictLoadMethod == ZSTD_dlm_byRef) {
-        cctx->localDict.dict = dict;
+    ZSTD_clearAllDicts(cctx);  /* in case one already exists */ 
+    if (dict == NULL || dictSize == 0)  /* no dictionary mode */ 
+        return 0; 
+    if (dictLoadMethod == ZSTD_dlm_byRef) { 
+        cctx->localDict.dict = dict; 
     } else {
         void* dictBuffer;
         RETURN_ERROR_IF(cctx->staticSize, memory_allocation,
@@ -1147,11 +1147,11 @@ size_t ZSTD_CCtx_loadDictionary_advanced(
         dictBuffer = ZSTD_customMalloc(dictSize, cctx->customMem);
         RETURN_ERROR_IF(!dictBuffer, memory_allocation, "NULL pointer!");
         ZSTD_memcpy(dictBuffer, dict, dictSize);
-        cctx->localDict.dictBuffer = dictBuffer;
-        cctx->localDict.dict = dictBuffer;
+        cctx->localDict.dictBuffer = dictBuffer; 
+        cctx->localDict.dict = dictBuffer; 
     }
-    cctx->localDict.dictSize = dictSize;
-    cctx->localDict.dictContentType = dictContentType;
+    cctx->localDict.dictSize = dictSize; 
+    cctx->localDict.dictContentType = dictContentType; 
     return 0;
 }
 
@@ -1173,8 +1173,8 @@ size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)
 {
     RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
                     "Can't ref a dict when ctx not in init stage.");
-    /* Free the existing local cdict (if any) to save memory. */
-    ZSTD_clearAllDicts(cctx);
+    /* Free the existing local cdict (if any) to save memory. */ 
+    ZSTD_clearAllDicts(cctx); 
     cctx->cdict = cdict;
     return 0;
 }
@@ -1197,7 +1197,7 @@ size_t ZSTD_CCtx_refPrefix_advanced(
 {
     RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
                     "Can't ref a prefix when ctx not in init stage.");
-    ZSTD_clearAllDicts(cctx);
+    ZSTD_clearAllDicts(cctx); 
     if (prefix != NULL && prefixSize > 0) {
         cctx->prefixDict.dict = prefix;
         cctx->prefixDict.dictSize = prefixSize;
@@ -1208,24 +1208,24 @@ size_t ZSTD_CCtx_refPrefix_advanced(
 
 /*! ZSTD_CCtx_reset() :
  *  Also dumps dictionary */
-size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset)
-{
-    if ( (reset == ZSTD_reset_session_only)
-      || (reset == ZSTD_reset_session_and_parameters) ) {
-        cctx->streamStage = zcss_init;
-        cctx->pledgedSrcSizePlusOne = 0;
-    }
-    if ( (reset == ZSTD_reset_parameters)
-      || (reset == ZSTD_reset_session_and_parameters) ) {
+size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset) 
+{
+    if ( (reset == ZSTD_reset_session_only) 
+      || (reset == ZSTD_reset_session_and_parameters) ) { 
+        cctx->streamStage = zcss_init; 
+        cctx->pledgedSrcSizePlusOne = 0; 
+    } 
+    if ( (reset == ZSTD_reset_parameters) 
+      || (reset == ZSTD_reset_session_and_parameters) ) { 
         RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,
                         "Can't reset parameters only when not in init stage.");
-        ZSTD_clearAllDicts(cctx);
-        return ZSTD_CCtxParams_reset(&cctx->requestedParams);
-    }
-    return 0;
+        ZSTD_clearAllDicts(cctx); 
+        return ZSTD_CCtxParams_reset(&cctx->requestedParams); 
+    } 
+    return 0; 
 }
 
-
+ 
 /** ZSTD_checkCParams() :
     control CParam values remain within authorized range.
     @return : 0, or an error code if one value is beyond authorized range */
@@ -1237,29 +1237,29 @@ size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
     BOUNDCHECK(ZSTD_c_searchLog, (int)cParams.searchLog);
     BOUNDCHECK(ZSTD_c_minMatch,  (int)cParams.minMatch);
     BOUNDCHECK(ZSTD_c_targetLength,(int)cParams.targetLength);
-    BOUNDCHECK(ZSTD_c_strategy,  cParams.strategy);
+    BOUNDCHECK(ZSTD_c_strategy,  cParams.strategy); 
     return 0;
 }
 
 /** ZSTD_clampCParams() :
  *  make CParam values within valid range.
  *  @return : valid CParams */
-static ZSTD_compressionParameters
-ZSTD_clampCParams(ZSTD_compressionParameters cParams)
+static ZSTD_compressionParameters 
+ZSTD_clampCParams(ZSTD_compressionParameters cParams) 
 {
-#   define CLAMP_TYPE(cParam, val, type) {                                \
-        ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);         \
-        if ((int)val<bounds.lowerBound) val=(type)bounds.lowerBound;      \
-        else if ((int)val>bounds.upperBound) val=(type)bounds.upperBound; \
+#   define CLAMP_TYPE(cParam, val, type) {                                \ 
+        ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);         \ 
+        if ((int)val<bounds.lowerBound) val=(type)bounds.lowerBound;      \ 
+        else if ((int)val>bounds.upperBound) val=(type)bounds.upperBound; \ 
     }
 #   define CLAMP(cParam, val) CLAMP_TYPE(cParam, val, unsigned)
-    CLAMP(ZSTD_c_windowLog, cParams.windowLog);
-    CLAMP(ZSTD_c_chainLog,  cParams.chainLog);
-    CLAMP(ZSTD_c_hashLog,   cParams.hashLog);
-    CLAMP(ZSTD_c_searchLog, cParams.searchLog);
-    CLAMP(ZSTD_c_minMatch,  cParams.minMatch);
-    CLAMP(ZSTD_c_targetLength,cParams.targetLength);
-    CLAMP_TYPE(ZSTD_c_strategy,cParams.strategy, ZSTD_strategy);
+    CLAMP(ZSTD_c_windowLog, cParams.windowLog); 
+    CLAMP(ZSTD_c_chainLog,  cParams.chainLog); 
+    CLAMP(ZSTD_c_hashLog,   cParams.hashLog); 
+    CLAMP(ZSTD_c_searchLog, cParams.searchLog); 
+    CLAMP(ZSTD_c_minMatch,  cParams.minMatch); 
+    CLAMP(ZSTD_c_targetLength,cParams.targetLength); 
+    CLAMP_TYPE(ZSTD_c_strategy,cParams.strategy, ZSTD_strategy); 
     return cParams;
 }
 
@@ -1306,15 +1306,15 @@ static U32 ZSTD_dictAndWindowLog(U32 windowLog, U64 srcSize, U64 dictSize)
 }
 
 /** ZSTD_adjustCParams_internal() :
- *  optimize `cPar` for a specified input (`srcSize` and `dictSize`).
- *  mostly downsize to reduce memory consumption and initialization latency.
- * `srcSize` can be ZSTD_CONTENTSIZE_UNKNOWN when not known.
+ *  optimize `cPar` for a specified input (`srcSize` and `dictSize`). 
+ *  mostly downsize to reduce memory consumption and initialization latency. 
+ * `srcSize` can be ZSTD_CONTENTSIZE_UNKNOWN when not known. 
  * `mode` is the mode for parameter adjustment. See docs for `ZSTD_cParamMode_e`.
  *  note : `srcSize==0` means 0!
- *  condition : cPar is presumed validated (can be checked using ZSTD_checkCParams()). */
-static ZSTD_compressionParameters
-ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,
-                            unsigned long long srcSize,
+ *  condition : cPar is presumed validated (can be checked using ZSTD_checkCParams()). */ 
+static ZSTD_compressionParameters 
+ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar, 
+                            unsigned long long srcSize, 
                             size_t dictSize,
                             ZSTD_cParamMode_e mode)
 {
@@ -1367,17 +1367,17 @@ ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,
     }
 
     if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN)
-        cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* minimum wlog required for valid frame header */
+        cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* minimum wlog required for valid frame header */ 
 
     return cPar;
 }
 
-ZSTD_compressionParameters
-ZSTD_adjustCParams(ZSTD_compressionParameters cPar,
-                   unsigned long long srcSize,
-                   size_t dictSize)
+ZSTD_compressionParameters 
+ZSTD_adjustCParams(ZSTD_compressionParameters cPar, 
+                   unsigned long long srcSize, 
+                   size_t dictSize) 
 {
-    cPar = ZSTD_clampCParams(cPar);   /* resulting cPar is necessarily valid (all parameters within range) */
+    cPar = ZSTD_clampCParams(cPar);   /* resulting cPar is necessarily valid (all parameters within range) */ 
     if (srcSize == 0) srcSize = ZSTD_CONTENTSIZE_UNKNOWN;
     return ZSTD_adjustCParams_internal(cPar, srcSize, dictSize, ZSTD_cpm_unknown);
 }
@@ -1398,7 +1398,7 @@ static void ZSTD_overrideCParams(
     if (overrides->strategy)     cParams->strategy     = overrides->strategy;
 }
 
-ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(
+ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams( 
         const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode)
 {
     ZSTD_compressionParameters cParams;
@@ -1408,23 +1408,23 @@ ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(
     cParams = ZSTD_getCParams_internal(CCtxParams->compressionLevel, srcSizeHint, dictSize, mode);
     if (CCtxParams->ldmParams.enableLdm == ZSTD_ps_enable) cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG;
     ZSTD_overrideCParams(&cParams, &CCtxParams->cParams);
-    assert(!ZSTD_checkCParams(cParams));
+    assert(!ZSTD_checkCParams(cParams)); 
     /* srcSizeHint == 0 means 0 */
     return ZSTD_adjustCParams_internal(cParams, srcSizeHint, dictSize, mode);
-}
-
-static size_t
-ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams,
+} 
+ 
+static size_t 
+ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams, 
                        const ZSTD_paramSwitch_e useRowMatchFinder,
                        const U32 enableDedicatedDictSearch,
-                       const U32 forCCtx)
-{
+                       const U32 forCCtx) 
+{ 
     /* chain table size should be 0 for fast or row-hash strategies */
     size_t const chainSize = ZSTD_allocateChainTable(cParams->strategy, useRowMatchFinder, enableDedicatedDictSearch && !forCCtx)
                                 ? ((size_t)1 << cParams->chainLog)
                                 : 0;
     size_t const hSize = ((size_t)1) << cParams->hashLog;
-    U32    const hashLog3 = (forCCtx && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
+    U32    const hashLog3 = (forCCtx && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0; 
     size_t const h3Size = hashLog3 ? ((size_t)1) << hashLog3 : 0;
     /* We don't use ZSTD_cwksp_alloc_size() here because the tables aren't
      * surrounded by redzones in ASAN. */
@@ -1441,7 +1441,7 @@ ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams,
     size_t const lazyAdditionalSpace = ZSTD_rowMatchFinderUsed(cParams->strategy, useRowMatchFinder)
                                             ? ZSTD_cwksp_aligned_alloc_size(hSize*sizeof(U16))
                                             : 0;
-    size_t const optSpace = (forCCtx && (cParams->strategy >= ZSTD_btopt))
+    size_t const optSpace = (forCCtx && (cParams->strategy >= ZSTD_btopt)) 
                                 ? optPotentialSpace
                                 : 0;
     size_t const slackSpace = ZSTD_cwksp_slack_space_required();
@@ -1549,7 +1549,7 @@ size_t ZSTD_estimateCCtxSize(int compressionLevel)
 {
     int level;
     size_t memBudget = 0;
-    for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) {
+    for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) { 
         /* Ensure monotonically increasing memory usage as compression level increases */
         size_t const newMB = ZSTD_estimateCCtxSize_internal(level);
         if (newMB > memBudget) memBudget = newMB;
@@ -1559,10 +1559,10 @@ size_t ZSTD_estimateCCtxSize(int compressionLevel)
 
 size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params)
 {
-    RETURN_ERROR_IF(params->nbWorkers > 0, GENERIC, "Estimate CCtx size is supported for single-threaded compression only.");
-    {   ZSTD_compressionParameters const cParams =
+    RETURN_ERROR_IF(params->nbWorkers > 0, GENERIC, "Estimate CCtx size is supported for single-threaded compression only."); 
+    {   ZSTD_compressionParameters const cParams = 
                 ZSTD_getCParamsFromCCtxParams(params, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_cpm_noAttachDict);
-        size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << cParams.windowLog);
+        size_t const blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << cParams.windowLog); 
         size_t const inBuffSize = (params->inBufferMode == ZSTD_bm_buffered)
                 ? ((size_t)1 << cParams.windowLog) + blockSize
                 : 0;
@@ -1594,17 +1594,17 @@ size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams)
     }
 }
 
-static size_t ZSTD_estimateCStreamSize_internal(int compressionLevel)
-{
+static size_t ZSTD_estimateCStreamSize_internal(int compressionLevel) 
+{ 
     ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_cpm_noAttachDict);
     return ZSTD_estimateCStreamSize_usingCParams(cParams);
 }
 
-size_t ZSTD_estimateCStreamSize(int compressionLevel)
-{
+size_t ZSTD_estimateCStreamSize(int compressionLevel) 
+{ 
     int level;
     size_t memBudget = 0;
-    for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) {
+    for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) { 
         size_t const newMB = ZSTD_estimateCStreamSize_internal(level);
         if (newMB > memBudget) memBudget = newMB;
     }
@@ -1630,49 +1630,49 @@ ZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx* cctx)
         fp.ingested = cctx->consumedSrcSize + buffered;
         fp.consumed = cctx->consumedSrcSize;
         fp.produced = cctx->producedCSize;
-        fp.flushed  = cctx->producedCSize;   /* simplified; some data might still be left within streaming output buffer */
-        fp.currentJobID = 0;
-        fp.nbActiveWorkers = 0;
+        fp.flushed  = cctx->producedCSize;   /* simplified; some data might still be left within streaming output buffer */ 
+        fp.currentJobID = 0; 
+        fp.nbActiveWorkers = 0; 
         return fp;
 }   }
 
-/*! ZSTD_toFlushNow()
- *  Only useful for multithreading scenarios currently (nbWorkers >= 1).
- */
-size_t ZSTD_toFlushNow(ZSTD_CCtx* cctx)
-{
-#ifdef ZSTD_MULTITHREAD
-    if (cctx->appliedParams.nbWorkers > 0) {
-        return ZSTDMT_toFlushNow(cctx->mtctx);
-    }
-#endif
-    (void)cctx;
-    return 0;   /* over-simplification; could also check if context is currently running in streaming mode, and in which case, report how many bytes are left to be flushed within output buffer */
-}
-
-static void ZSTD_assertEqualCParams(ZSTD_compressionParameters cParams1,
-                                    ZSTD_compressionParameters cParams2)
-{
-    (void)cParams1;
-    (void)cParams2;
-    assert(cParams1.windowLog    == cParams2.windowLog);
-    assert(cParams1.chainLog     == cParams2.chainLog);
-    assert(cParams1.hashLog      == cParams2.hashLog);
-    assert(cParams1.searchLog    == cParams2.searchLog);
-    assert(cParams1.minMatch     == cParams2.minMatch);
-    assert(cParams1.targetLength == cParams2.targetLength);
-    assert(cParams1.strategy     == cParams2.strategy);
-}
-
+/*! ZSTD_toFlushNow() 
+ *  Only useful for multithreading scenarios currently (nbWorkers >= 1). 
+ */ 
+size_t ZSTD_toFlushNow(ZSTD_CCtx* cctx) 
+{ 
+#ifdef ZSTD_MULTITHREAD 
+    if (cctx->appliedParams.nbWorkers > 0) { 
+        return ZSTDMT_toFlushNow(cctx->mtctx); 
+    } 
+#endif 
+    (void)cctx; 
+    return 0;   /* over-simplification; could also check if context is currently running in streaming mode, and in which case, report how many bytes are left to be flushed within output buffer */ 
+} 
+
+static void ZSTD_assertEqualCParams(ZSTD_compressionParameters cParams1, 
+                                    ZSTD_compressionParameters cParams2) 
+{ 
+    (void)cParams1; 
+    (void)cParams2; 
+    assert(cParams1.windowLog    == cParams2.windowLog); 
+    assert(cParams1.chainLog     == cParams2.chainLog); 
+    assert(cParams1.hashLog      == cParams2.hashLog); 
+    assert(cParams1.searchLog    == cParams2.searchLog); 
+    assert(cParams1.minMatch     == cParams2.minMatch); 
+    assert(cParams1.targetLength == cParams2.targetLength); 
+    assert(cParams1.strategy     == cParams2.strategy); 
+} 
+ 
 void ZSTD_reset_compressedBlockState(ZSTD_compressedBlockState_t* bs)
 {
     int i;
     for (i = 0; i < ZSTD_REP_NUM; ++i)
         bs->rep[i] = repStartValue[i];
-    bs->entropy.huf.repeatMode = HUF_repeat_none;
-    bs->entropy.fse.offcode_repeatMode = FSE_repeat_none;
-    bs->entropy.fse.matchlength_repeatMode = FSE_repeat_none;
-    bs->entropy.fse.litlength_repeatMode = FSE_repeat_none;
+    bs->entropy.huf.repeatMode = HUF_repeat_none; 
+    bs->entropy.fse.offcode_repeatMode = FSE_repeat_none; 
+    bs->entropy.fse.matchlength_repeatMode = FSE_repeat_none; 
+    bs->entropy.fse.litlength_repeatMode = FSE_repeat_none; 
 }
 
 /*! ZSTD_invalidateMatchState()
@@ -1683,10 +1683,10 @@ static void ZSTD_invalidateMatchState(ZSTD_matchState_t* ms)
 {
     ZSTD_window_clear(&ms->window);
 
-    ms->nextToUpdate = ms->window.dictLimit;
+    ms->nextToUpdate = ms->window.dictLimit; 
     ms->loadedDictEnd = 0;
     ms->opt.litLengthSum = 0;  /* force reset of btopt stats */
-    ms->dictMatchState = NULL;
+    ms->dictMatchState = NULL; 
 }
 
 /**
@@ -1718,9 +1718,9 @@ typedef enum {
 
 
 static size_t
-ZSTD_reset_matchState(ZSTD_matchState_t* ms,
+ZSTD_reset_matchState(ZSTD_matchState_t* ms, 
                       ZSTD_cwksp* ws,
-                const ZSTD_compressionParameters* cParams,
+                const ZSTD_compressionParameters* cParams, 
                 const ZSTD_paramSwitch_e useRowMatchFinder,
                 const ZSTD_compResetPolicy_e crp,
                 const ZSTD_indexResetPolicy_e forceResetIndex,
@@ -1788,8 +1788,8 @@ ZSTD_reset_matchState(ZSTD_matchState_t* ms,
         }
     }
 
-    ms->cParams = *cParams;
-
+    ms->cParams = *cParams; 
+ 
     RETURN_ERROR_IF(ZSTD_cwksp_reserve_failed(ws), memory_allocation,
                     "failed a workspace allocation in ZSTD_reset_matchState");
     return 0;
@@ -1886,24 +1886,24 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
             int const workspaceWasteful = ZSTD_cwksp_check_wasteful(ws, neededSpace);
             resizeWorkspace = workspaceTooSmall || workspaceWasteful;
             DEBUGLOG(4, "Need %zu B workspace", neededSpace);
-            DEBUGLOG(4, "windowSize: %zu - blockSize: %zu", windowSize, blockSize);
-
+            DEBUGLOG(4, "windowSize: %zu - blockSize: %zu", windowSize, blockSize); 
+ 
             if (resizeWorkspace) {
                 DEBUGLOG(4, "Resize workspaceSize from %zuKB to %zuKB",
                             ZSTD_cwksp_sizeof(ws) >> 10,
-                            neededSpace >> 10);
-
-                RETURN_ERROR_IF(zc->staticSize, memory_allocation, "static cctx : no resize");
-
+                            neededSpace >> 10); 
+ 
+                RETURN_ERROR_IF(zc->staticSize, memory_allocation, "static cctx : no resize"); 
+ 
                 needsIndexReset = ZSTDirp_reset;
 
                 ZSTD_cwksp_free(ws, zc->customMem);
                 FORWARD_IF_ERROR(ZSTD_cwksp_create(ws, neededSpace, zc->customMem), "");
 
                 DEBUGLOG(5, "reserving object space");
-                /* Statically sized space.
-                 * entropyWorkspace never moves,
-                 * though prev/next block swap places */
+                /* Statically sized space. 
+                 * entropyWorkspace never moves, 
+                 * though prev/next block swap places */ 
                 assert(ZSTD_cwksp_check_available(ws, 2 * sizeof(ZSTD_compressedBlockState_t)));
                 zc->blockState.prevCBlock = (ZSTD_compressedBlockState_t*) ZSTD_cwksp_reserve_object(ws, sizeof(ZSTD_compressedBlockState_t));
                 RETURN_ERROR_IF(zc->blockState.prevCBlock == NULL, memory_allocation, "couldn't allocate prevCBlock");
@@ -1923,7 +1923,7 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
         if (pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN)
             zc->appliedParams.fParams.contentSizeFlag = 0;
         DEBUGLOG(4, "pledged content size : %u ; flag : %u",
-            (unsigned)pledgedSrcSize, zc->appliedParams.fParams.contentSizeFlag);
+            (unsigned)pledgedSrcSize, zc->appliedParams.fParams.contentSizeFlag); 
         zc->blockSize = blockSize;
 
         XXH64_reset(&zc->xxhState, 0);
@@ -1933,11 +1933,11 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
 
         ZSTD_reset_compressedBlockState(zc->blockState.prevCBlock);
 
-        /* ZSTD_wildcopy() is used to copy into the literals buffer,
-         * so we have to oversize the buffer by WILDCOPY_OVERLENGTH bytes.
-         */
+        /* ZSTD_wildcopy() is used to copy into the literals buffer, 
+         * so we have to oversize the buffer by WILDCOPY_OVERLENGTH bytes. 
+         */ 
         zc->seqStore.litStart = ZSTD_cwksp_reserve_buffer(ws, blockSize + WILDCOPY_OVERLENGTH);
-        zc->seqStore.maxNbLit = blockSize;
+        zc->seqStore.maxNbLit = blockSize; 
 
         /* buffers */
         zc->bufferedPolicy = zbuff;
@@ -2005,28 +2005,28 @@ void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx) {
     assert(!ZSTD_window_hasExtDict(cctx->blockState.matchState.window));
 }
 
-/* These are the approximate sizes for each strategy past which copying the
- * dictionary tables into the working context is faster than using them
- * in-place.
- */
-static const size_t attachDictSizeCutoffs[ZSTD_STRATEGY_MAX+1] = {
-    8 KB,  /* unused */
-    8 KB,  /* ZSTD_fast */
-    16 KB, /* ZSTD_dfast */
-    32 KB, /* ZSTD_greedy */
-    32 KB, /* ZSTD_lazy */
-    32 KB, /* ZSTD_lazy2 */
-    32 KB, /* ZSTD_btlazy2 */
-    32 KB, /* ZSTD_btopt */
-    8 KB,  /* ZSTD_btultra */
-    8 KB   /* ZSTD_btultra2 */
-};
-
-static int ZSTD_shouldAttachDict(const ZSTD_CDict* cdict,
+/* These are the approximate sizes for each strategy past which copying the 
+ * dictionary tables into the working context is faster than using them 
+ * in-place. 
+ */ 
+static const size_t attachDictSizeCutoffs[ZSTD_STRATEGY_MAX+1] = { 
+    8 KB,  /* unused */ 
+    8 KB,  /* ZSTD_fast */ 
+    16 KB, /* ZSTD_dfast */ 
+    32 KB, /* ZSTD_greedy */ 
+    32 KB, /* ZSTD_lazy */ 
+    32 KB, /* ZSTD_lazy2 */ 
+    32 KB, /* ZSTD_btlazy2 */ 
+    32 KB, /* ZSTD_btopt */ 
+    8 KB,  /* ZSTD_btultra */ 
+    8 KB   /* ZSTD_btultra2 */ 
+}; 
+ 
+static int ZSTD_shouldAttachDict(const ZSTD_CDict* cdict, 
                                  const ZSTD_CCtx_params* params,
-                                 U64 pledgedSrcSize)
-{
-    size_t cutoff = attachDictSizeCutoffs[cdict->matchState.cParams.strategy];
+                                 U64 pledgedSrcSize) 
+{ 
+    size_t cutoff = attachDictSizeCutoffs[cdict->matchState.cParams.strategy]; 
     int const dedicatedDictSearch = cdict->matchState.dedicatedDictSearch;
     return dedicatedDictSearch
         || ( ( pledgedSrcSize <= cutoff
@@ -2035,23 +2035,23 @@ static int ZSTD_shouldAttachDict(const ZSTD_CDict* cdict,
           && params->attachDictPref != ZSTD_dictForceCopy
           && !params->forceWindow ); /* dictMatchState isn't correctly
                                       * handled in _enforceMaxDist */
-}
-
+} 
+ 
 static size_t
 ZSTD_resetCCtx_byAttachingCDict(ZSTD_CCtx* cctx,
                         const ZSTD_CDict* cdict,
                         ZSTD_CCtx_params params,
                         U64 pledgedSrcSize,
                         ZSTD_buffered_policy_e zbuff)
-{
+{ 
     DEBUGLOG(4, "ZSTD_resetCCtx_byAttachingCDict() pledgedSrcSize=%llu",
                 (unsigned long long)pledgedSrcSize);
     {
         ZSTD_compressionParameters adjusted_cdict_cParams = cdict->matchState.cParams;
-        unsigned const windowLog = params.cParams.windowLog;
-        assert(windowLog != 0);
-        /* Resize working context table params for input only, since the dict
-         * has its own tables. */
+        unsigned const windowLog = params.cParams.windowLog; 
+        assert(windowLog != 0); 
+        /* Resize working context table params for input only, since the dict 
+         * has its own tables. */ 
         /* pledgedSrcSize == 0 means 0! */
 
         if (cdict->matchState.dedicatedDictSearch) {
@@ -2060,68 +2060,68 @@ ZSTD_resetCCtx_byAttachingCDict(ZSTD_CCtx* cctx,
 
         params.cParams = ZSTD_adjustCParams_internal(adjusted_cdict_cParams, pledgedSrcSize,
                                                      cdict->dictContentSize, ZSTD_cpm_attachDict);
-        params.cParams.windowLog = windowLog;
+        params.cParams.windowLog = windowLog; 
         params.useRowMatchFinder = cdict->useRowMatchFinder;    /* cdict overrides */
         FORWARD_IF_ERROR(ZSTD_resetCCtx_internal(cctx, &params, pledgedSrcSize,
                                                  /* loadedDictSize */ 0,
                                                  ZSTDcrp_makeClean, zbuff), "");
         assert(cctx->appliedParams.cParams.strategy == adjusted_cdict_cParams.strategy);
-    }
-
+    } 
+ 
     {   const U32 cdictEnd = (U32)( cdict->matchState.window.nextSrc
-                                  - cdict->matchState.window.base);
-        const U32 cdictLen = cdictEnd - cdict->matchState.window.dictLimit;
-        if (cdictLen == 0) {
-            /* don't even attach dictionaries with no contents */
-            DEBUGLOG(4, "skipping attaching empty dictionary");
-        } else {
-            DEBUGLOG(4, "attaching dictionary into context");
-            cctx->blockState.matchState.dictMatchState = &cdict->matchState;
-
-            /* prep working match state so dict matches never have negative indices
-             * when they are translated to the working context's index space. */
-            if (cctx->blockState.matchState.window.dictLimit < cdictEnd) {
-                cctx->blockState.matchState.window.nextSrc =
-                    cctx->blockState.matchState.window.base + cdictEnd;
-                ZSTD_window_clear(&cctx->blockState.matchState.window);
-            }
+                                  - cdict->matchState.window.base); 
+        const U32 cdictLen = cdictEnd - cdict->matchState.window.dictLimit; 
+        if (cdictLen == 0) { 
+            /* don't even attach dictionaries with no contents */ 
+            DEBUGLOG(4, "skipping attaching empty dictionary"); 
+        } else { 
+            DEBUGLOG(4, "attaching dictionary into context"); 
+            cctx->blockState.matchState.dictMatchState = &cdict->matchState; 
+ 
+            /* prep working match state so dict matches never have negative indices 
+             * when they are translated to the working context's index space. */ 
+            if (cctx->blockState.matchState.window.dictLimit < cdictEnd) { 
+                cctx->blockState.matchState.window.nextSrc = 
+                    cctx->blockState.matchState.window.base + cdictEnd; 
+                ZSTD_window_clear(&cctx->blockState.matchState.window); 
+            } 
             /* loadedDictEnd is expressed within the referential of the active context */
-            cctx->blockState.matchState.loadedDictEnd = cctx->blockState.matchState.window.dictLimit;
+            cctx->blockState.matchState.loadedDictEnd = cctx->blockState.matchState.window.dictLimit; 
     }   }
-
-    cctx->dictID = cdict->dictID;
+ 
+    cctx->dictID = cdict->dictID; 
     cctx->dictContentSize = cdict->dictContentSize;
-
-    /* copy block state */
+ 
+    /* copy block state */ 
     ZSTD_memcpy(cctx->blockState.prevCBlock, &cdict->cBlockState, sizeof(cdict->cBlockState));
-
-    return 0;
-}
-
-static size_t ZSTD_resetCCtx_byCopyingCDict(ZSTD_CCtx* cctx,
+ 
+    return 0; 
+} 
+ 
+static size_t ZSTD_resetCCtx_byCopyingCDict(ZSTD_CCtx* cctx, 
                             const ZSTD_CDict* cdict,
-                            ZSTD_CCtx_params params,
+                            ZSTD_CCtx_params params, 
                             U64 pledgedSrcSize,
                             ZSTD_buffered_policy_e zbuff)
 {
-    const ZSTD_compressionParameters *cdict_cParams = &cdict->matchState.cParams;
-
+    const ZSTD_compressionParameters *cdict_cParams = &cdict->matchState.cParams; 
+ 
     assert(!cdict->matchState.dedicatedDictSearch);
     DEBUGLOG(4, "ZSTD_resetCCtx_byCopyingCDict() pledgedSrcSize=%llu",
                 (unsigned long long)pledgedSrcSize);
 
-    {   unsigned const windowLog = params.cParams.windowLog;
-        assert(windowLog != 0);
+    {   unsigned const windowLog = params.cParams.windowLog; 
+        assert(windowLog != 0); 
         /* Copy only compression parameters related to tables. */
-        params.cParams = *cdict_cParams;
-        params.cParams.windowLog = windowLog;
+        params.cParams = *cdict_cParams; 
+        params.cParams.windowLog = windowLog; 
         params.useRowMatchFinder = cdict->useRowMatchFinder;
         FORWARD_IF_ERROR(ZSTD_resetCCtx_internal(cctx, &params, pledgedSrcSize,
                                                  /* loadedDictSize */ 0,
                                                  ZSTDcrp_leaveDirty, zbuff), "");
-        assert(cctx->appliedParams.cParams.strategy == cdict_cParams->strategy);
-        assert(cctx->appliedParams.cParams.hashLog == cdict_cParams->hashLog);
-        assert(cctx->appliedParams.cParams.chainLog == cdict_cParams->chainLog);
+        assert(cctx->appliedParams.cParams.strategy == cdict_cParams->strategy); 
+        assert(cctx->appliedParams.cParams.hashLog == cdict_cParams->hashLog); 
+        assert(cctx->appliedParams.cParams.chainLog == cdict_cParams->chainLog); 
     }
 
     ZSTD_cwksp_mark_tables_dirty(&cctx->workspace);
@@ -2131,7 +2131,7 @@ static size_t ZSTD_resetCCtx_byCopyingCDict(ZSTD_CCtx* cctx,
     {   size_t const chainSize = ZSTD_allocateChainTable(cdict_cParams->strategy, cdict->useRowMatchFinder, 0 /* DDS guaranteed disabled */)
                                                             ? ((size_t)1 << cdict_cParams->chainLog)
                                                             : 0;
-        size_t const hSize =  (size_t)1 << cdict_cParams->hashLog;
+        size_t const hSize =  (size_t)1 << cdict_cParams->hashLog; 
 
         ZSTD_memcpy(cctx->blockState.matchState.hashTable,
                cdict->matchState.hashTable,
@@ -2150,7 +2150,7 @@ static size_t ZSTD_resetCCtx_byCopyingCDict(ZSTD_CCtx* cctx,
                 tagTableSize);
         }
     }
-
+ 
     /* Zero the hashTable3, since the cdict never fills it */
     {   int const h3log = cctx->blockState.matchState.hashLog3;
         size_t const h3Size = h3log ? ((size_t)1 << h3log) : 0;
@@ -2161,13 +2161,13 @@ static size_t ZSTD_resetCCtx_byCopyingCDict(ZSTD_CCtx* cctx,
     ZSTD_cwksp_mark_tables_clean(&cctx->workspace);
 
     /* copy dictionary offsets */
-    {   ZSTD_matchState_t const* srcMatchState = &cdict->matchState;
+    {   ZSTD_matchState_t const* srcMatchState = &cdict->matchState; 
         ZSTD_matchState_t* dstMatchState = &cctx->blockState.matchState;
         dstMatchState->window       = srcMatchState->window;
         dstMatchState->nextToUpdate = srcMatchState->nextToUpdate;
         dstMatchState->loadedDictEnd= srcMatchState->loadedDictEnd;
     }
-
+ 
     cctx->dictID = cdict->dictID;
     cctx->dictContentSize = cdict->dictContentSize;
 
@@ -2177,28 +2177,28 @@ static size_t ZSTD_resetCCtx_byCopyingCDict(ZSTD_CCtx* cctx,
     return 0;
 }
 
-/* We have a choice between copying the dictionary context into the working
- * context, or referencing the dictionary context from the working context
- * in-place. We decide here which strategy to use. */
-static size_t ZSTD_resetCCtx_usingCDict(ZSTD_CCtx* cctx,
-                            const ZSTD_CDict* cdict,
+/* We have a choice between copying the dictionary context into the working 
+ * context, or referencing the dictionary context from the working context 
+ * in-place. We decide here which strategy to use. */ 
+static size_t ZSTD_resetCCtx_usingCDict(ZSTD_CCtx* cctx, 
+                            const ZSTD_CDict* cdict, 
                             const ZSTD_CCtx_params* params,
-                            U64 pledgedSrcSize,
-                            ZSTD_buffered_policy_e zbuff)
-{
-
-    DEBUGLOG(4, "ZSTD_resetCCtx_usingCDict (pledgedSrcSize=%u)",
-                (unsigned)pledgedSrcSize);
-
-    if (ZSTD_shouldAttachDict(cdict, params, pledgedSrcSize)) {
-        return ZSTD_resetCCtx_byAttachingCDict(
+                            U64 pledgedSrcSize, 
+                            ZSTD_buffered_policy_e zbuff) 
+{ 
+ 
+    DEBUGLOG(4, "ZSTD_resetCCtx_usingCDict (pledgedSrcSize=%u)", 
+                (unsigned)pledgedSrcSize); 
+ 
+    if (ZSTD_shouldAttachDict(cdict, params, pledgedSrcSize)) { 
+        return ZSTD_resetCCtx_byAttachingCDict( 
             cctx, cdict, *params, pledgedSrcSize, zbuff);
-    } else {
-        return ZSTD_resetCCtx_byCopyingCDict(
+    } else { 
+        return ZSTD_resetCCtx_byCopyingCDict( 
             cctx, cdict, *params, pledgedSrcSize, zbuff);
-    }
-}
-
+    } 
+} 
+ 
 /*! ZSTD_copyCCtx_internal() :
  *  Duplicate an existing context `srcCCtx` into another one `dstCCtx`.
  *  Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()).
@@ -2263,7 +2263,7 @@ static size_t ZSTD_copyCCtx_internal(ZSTD_CCtx* dstCCtx,
 
     /* copy dictionary offsets */
     {
-        const ZSTD_matchState_t* srcMatchState = &srcCCtx->blockState.matchState;
+        const ZSTD_matchState_t* srcMatchState = &srcCCtx->blockState.matchState; 
         ZSTD_matchState_t* dstMatchState = &dstCCtx->blockState.matchState;
         dstMatchState->window       = srcMatchState->window;
         dstMatchState->nextToUpdate = srcMatchState->nextToUpdate;
@@ -2393,7 +2393,7 @@ void ZSTD_seqToCodes(const seqStore_t* seqStorePtr)
     BYTE* const mlCodeTable = seqStorePtr->mlCode;
     U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
     U32 u;
-    assert(nbSeq <= seqStorePtr->maxNbSeq);
+    assert(nbSeq <= seqStorePtr->maxNbSeq); 
     for (u=0; u<nbSeq; u++) {
         U32 const llv = sequences[u].litLength;
         U32 const mlv = sequences[u].mlBase;
@@ -2415,8 +2415,8 @@ static int ZSTD_useTargetCBlockSize(const ZSTD_CCtx_params* cctxParams)
 {
     DEBUGLOG(5, "ZSTD_useTargetCBlockSize (targetCBlockSize=%zu)", cctxParams->targetCBlockSize);
     return (cctxParams->targetCBlockSize != 0);
-}
-
+} 
+ 
 /* ZSTD_blockSplitterEnabled():
  * Returns if block splitting param is being used
  * If used, compression will do best effort to split a block in order to improve compression ratio.
@@ -2570,21 +2570,21 @@ ZSTD_buildSequencesStatistics(seqStore_t* seqStorePtr, size_t nbSeq,
  * Returns compressed size of block, or a zstd error.
  */
 #define SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO 20
-MEM_STATIC size_t
+MEM_STATIC size_t 
 ZSTD_entropyCompressSeqStore_internal(seqStore_t* seqStorePtr,
-                          const ZSTD_entropyCTables_t* prevEntropy,
-                                ZSTD_entropyCTables_t* nextEntropy,
-                          const ZSTD_CCtx_params* cctxParams,
-                                void* dst, size_t dstCapacity,
+                          const ZSTD_entropyCTables_t* prevEntropy, 
+                                ZSTD_entropyCTables_t* nextEntropy, 
+                          const ZSTD_CCtx_params* cctxParams, 
+                                void* dst, size_t dstCapacity, 
                                 void* entropyWorkspace, size_t entropyWkspSize,
-                          const int bmi2)
-{
+                          const int bmi2) 
+{ 
     const int longOffsets = cctxParams->cParams.windowLog > STREAM_ACCUMULATOR_MIN;
-    ZSTD_strategy const strategy = cctxParams->cParams.strategy;
+    ZSTD_strategy const strategy = cctxParams->cParams.strategy; 
     unsigned* count = (unsigned*)entropyWorkspace;
-    FSE_CTable* CTable_LitLength = nextEntropy->fse.litlengthCTable;
-    FSE_CTable* CTable_OffsetBits = nextEntropy->fse.offcodeCTable;
-    FSE_CTable* CTable_MatchLength = nextEntropy->fse.matchlengthCTable;
+    FSE_CTable* CTable_LitLength = nextEntropy->fse.litlengthCTable; 
+    FSE_CTable* CTable_OffsetBits = nextEntropy->fse.offcodeCTable; 
+    FSE_CTable* CTable_MatchLength = nextEntropy->fse.matchlengthCTable; 
     const seqDef* const sequences = seqStorePtr->sequencesStart;
     const size_t nbSeq = seqStorePtr->sequences - seqStorePtr->sequencesStart;
     const BYTE* const ofCodeTable = seqStorePtr->ofCode;
@@ -2610,8 +2610,8 @@ ZSTD_entropyCompressSeqStore_internal(seqStore_t* seqStorePtr,
         unsigned const suspectUncompressible = (numSequences == 0) || (numLiterals / numSequences >= SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO);
         size_t const litSize = (size_t)(seqStorePtr->lit - literals);
         size_t const cSize = ZSTD_compressLiterals(
-                                    &prevEntropy->huf, &nextEntropy->huf,
-                                    cctxParams->cParams.strategy,
+                                    &prevEntropy->huf, &nextEntropy->huf, 
+                                    cctxParams->cParams.strategy, 
                                     ZSTD_literalsCompressionIsDisabled(cctxParams),
                                     op, dstCapacity,
                                     literals, litSize,
@@ -2623,7 +2623,7 @@ ZSTD_entropyCompressSeqStore_internal(seqStore_t* seqStorePtr,
     }
 
     /* Sequences Header */
-    RETURN_ERROR_IF((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/,
+    RETURN_ERROR_IF((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/, 
                     dstSize_tooSmall, "Can't fit seq hdr in output buf!");
     if (nbSeq < 128) {
         *op++ = (BYTE)nbSeq;
@@ -2638,7 +2638,7 @@ ZSTD_entropyCompressSeqStore_internal(seqStore_t* seqStorePtr,
     }
     assert(op <= oend);
     if (nbSeq==0) {
-        /* Copy the old tables over as if we repeated them */
+        /* Copy the old tables over as if we repeated them */ 
         ZSTD_memcpy(&nextEntropy->fse, &prevEntropy->fse, sizeof(prevEntropy->fse));
         return (size_t)(op - ostart);
     }
@@ -2667,42 +2667,42 @@ ZSTD_entropyCompressSeqStore_internal(seqStore_t* seqStorePtr,
         FORWARD_IF_ERROR(bitstreamSize, "ZSTD_encodeSequences failed");
         op += bitstreamSize;
         assert(op <= oend);
-        /* zstd versions <= 1.3.4 mistakenly report corruption when
-         * FSE_readNCount() receives a buffer < 4 bytes.
-         * Fixed by https://github.com/facebook/zstd/pull/1146.
-         * This can happen when the last set_compressed table present is 2
-         * bytes and the bitstream is only one byte.
-         * In this exceedingly rare case, we will simply emit an uncompressed
-         * block, since it isn't worth optimizing.
-         */
+        /* zstd versions <= 1.3.4 mistakenly report corruption when 
+         * FSE_readNCount() receives a buffer < 4 bytes. 
+         * Fixed by https://github.com/facebook/zstd/pull/1146. 
+         * This can happen when the last set_compressed table present is 2 
+         * bytes and the bitstream is only one byte. 
+         * In this exceedingly rare case, we will simply emit an uncompressed 
+         * block, since it isn't worth optimizing. 
+         */ 
         if (lastCountSize && (lastCountSize + bitstreamSize) < 4) {
             /* lastCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */
             assert(lastCountSize + bitstreamSize == 3);
-            DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.3.4 by "
-                        "emitting an uncompressed block.");
-            return 0;
-        }
+            DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.3.4 by " 
+                        "emitting an uncompressed block."); 
+            return 0; 
+        } 
     }
 
-    DEBUGLOG(5, "compressed block size : %u", (unsigned)(op - ostart));
+    DEBUGLOG(5, "compressed block size : %u", (unsigned)(op - ostart)); 
     return (size_t)(op - ostart);
 }
 
-MEM_STATIC size_t
+MEM_STATIC size_t 
 ZSTD_entropyCompressSeqStore(seqStore_t* seqStorePtr,
-                       const ZSTD_entropyCTables_t* prevEntropy,
-                             ZSTD_entropyCTables_t* nextEntropy,
-                       const ZSTD_CCtx_params* cctxParams,
-                             void* dst, size_t dstCapacity,
-                             size_t srcSize,
+                       const ZSTD_entropyCTables_t* prevEntropy, 
+                             ZSTD_entropyCTables_t* nextEntropy, 
+                       const ZSTD_CCtx_params* cctxParams, 
+                             void* dst, size_t dstCapacity, 
+                             size_t srcSize, 
                              void* entropyWorkspace, size_t entropyWkspSize,
-                             int bmi2)
+                             int bmi2) 
 {
     size_t const cSize = ZSTD_entropyCompressSeqStore_internal(
-                            seqStorePtr, prevEntropy, nextEntropy, cctxParams,
-                            dst, dstCapacity,
+                            seqStorePtr, prevEntropy, nextEntropy, cctxParams, 
+                            dst, dstCapacity, 
                             entropyWorkspace, entropyWkspSize, bmi2);
-    if (cSize == 0) return 0;
+    if (cSize == 0) return 0; 
     /* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block.
      * Since we ran out of space, block must be not compressible, so fall back to raw uncompressed block.
      */
@@ -2711,7 +2711,7 @@ ZSTD_entropyCompressSeqStore(seqStore_t* seqStorePtr,
     FORWARD_IF_ERROR(cSize, "ZSTD_entropyCompressSeqStore_internal failed");
 
     /* Check compressibility */
-    {   size_t const maxCSize = srcSize - ZSTD_minGain(srcSize, cctxParams->cParams.strategy);
+    {   size_t const maxCSize = srcSize - ZSTD_minGain(srcSize, cctxParams->cParams.strategy); 
         if (cSize >= maxCSize) return 0;  /* block not compressed */
     }
     DEBUGLOG(4, "ZSTD_entropyCompressSeqStore() cSize: %zu", cSize);
@@ -2725,34 +2725,34 @@ ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_paramS
 {
     static const ZSTD_blockCompressor blockCompressor[4][ZSTD_STRATEGY_MAX+1] = {
         { ZSTD_compressBlock_fast  /* default for 0 */,
-          ZSTD_compressBlock_fast,
-          ZSTD_compressBlock_doubleFast,
-          ZSTD_compressBlock_greedy,
-          ZSTD_compressBlock_lazy,
-          ZSTD_compressBlock_lazy2,
-          ZSTD_compressBlock_btlazy2,
-          ZSTD_compressBlock_btopt,
-          ZSTD_compressBlock_btultra,
-          ZSTD_compressBlock_btultra2 },
+          ZSTD_compressBlock_fast, 
+          ZSTD_compressBlock_doubleFast, 
+          ZSTD_compressBlock_greedy, 
+          ZSTD_compressBlock_lazy, 
+          ZSTD_compressBlock_lazy2, 
+          ZSTD_compressBlock_btlazy2, 
+          ZSTD_compressBlock_btopt, 
+          ZSTD_compressBlock_btultra, 
+          ZSTD_compressBlock_btultra2 }, 
         { ZSTD_compressBlock_fast_extDict  /* default for 0 */,
-          ZSTD_compressBlock_fast_extDict,
-          ZSTD_compressBlock_doubleFast_extDict,
-          ZSTD_compressBlock_greedy_extDict,
-          ZSTD_compressBlock_lazy_extDict,
-          ZSTD_compressBlock_lazy2_extDict,
-          ZSTD_compressBlock_btlazy2_extDict,
-          ZSTD_compressBlock_btopt_extDict,
-          ZSTD_compressBlock_btultra_extDict,
-          ZSTD_compressBlock_btultra_extDict },
-        { ZSTD_compressBlock_fast_dictMatchState  /* default for 0 */,
-          ZSTD_compressBlock_fast_dictMatchState,
-          ZSTD_compressBlock_doubleFast_dictMatchState,
-          ZSTD_compressBlock_greedy_dictMatchState,
-          ZSTD_compressBlock_lazy_dictMatchState,
-          ZSTD_compressBlock_lazy2_dictMatchState,
-          ZSTD_compressBlock_btlazy2_dictMatchState,
-          ZSTD_compressBlock_btopt_dictMatchState,
-          ZSTD_compressBlock_btultra_dictMatchState,
+          ZSTD_compressBlock_fast_extDict, 
+          ZSTD_compressBlock_doubleFast_extDict, 
+          ZSTD_compressBlock_greedy_extDict, 
+          ZSTD_compressBlock_lazy_extDict, 
+          ZSTD_compressBlock_lazy2_extDict, 
+          ZSTD_compressBlock_btlazy2_extDict, 
+          ZSTD_compressBlock_btopt_extDict, 
+          ZSTD_compressBlock_btultra_extDict, 
+          ZSTD_compressBlock_btultra_extDict }, 
+        { ZSTD_compressBlock_fast_dictMatchState  /* default for 0 */, 
+          ZSTD_compressBlock_fast_dictMatchState, 
+          ZSTD_compressBlock_doubleFast_dictMatchState, 
+          ZSTD_compressBlock_greedy_dictMatchState, 
+          ZSTD_compressBlock_lazy_dictMatchState, 
+          ZSTD_compressBlock_lazy2_dictMatchState, 
+          ZSTD_compressBlock_btlazy2_dictMatchState, 
+          ZSTD_compressBlock_btopt_dictMatchState, 
+          ZSTD_compressBlock_btultra_dictMatchState, 
           ZSTD_compressBlock_btultra_dictMatchState },
         { NULL  /* default for 0 */,
           NULL,
@@ -2765,10 +2765,10 @@ ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_paramS
           NULL,
           NULL }
     };
-    ZSTD_blockCompressor selectedCompressor;
+    ZSTD_blockCompressor selectedCompressor; 
     ZSTD_STATIC_ASSERT((unsigned)ZSTD_fast == 1);
 
-    assert(ZSTD_cParam_withinBounds(ZSTD_c_strategy, strat));
+    assert(ZSTD_cParam_withinBounds(ZSTD_c_strategy, strat)); 
     DEBUGLOG(4, "Selected block compressor: dictMode=%d strat=%d rowMatchfinder=%d", (int)dictMode, (int)strat, (int)useRowMatchFinder);
     if (ZSTD_rowMatchFinderUsed(strat, useRowMatchFinder)) {
         static const ZSTD_blockCompressor rowBasedBlockCompressors[4][3] = {
@@ -2791,8 +2791,8 @@ ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_paramS
     } else {
         selectedCompressor = blockCompressor[(int)dictMode][(int)strat];
     }
-    assert(selectedCompressor != NULL);
-    return selectedCompressor;
+    assert(selectedCompressor != NULL); 
+    return selectedCompressor; 
 }
 
 static void ZSTD_storeLastLiterals(seqStore_t* seqStorePtr,
@@ -2802,7 +2802,7 @@ static void ZSTD_storeLastLiterals(seqStore_t* seqStorePtr,
     seqStorePtr->lit += lastLLSize;
 }
 
-void ZSTD_resetSeqStore(seqStore_t* ssPtr)
+void ZSTD_resetSeqStore(seqStore_t* ssPtr) 
 {
     ssPtr->lit = ssPtr->litStart;
     ssPtr->sequences = ssPtr->sequencesStart;
@@ -2815,9 +2815,9 @@ static size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)
 {
     ZSTD_matchState_t* const ms = &zc->blockState.matchState;
     DEBUGLOG(5, "ZSTD_buildSeqStore (srcSize=%zu)", srcSize);
-    assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
-    /* Assert that we have correctly flushed the ctx params into the ms's copy */
-    ZSTD_assertEqualCParams(zc->appliedParams.cParams, ms->cParams);
+    assert(srcSize <= ZSTD_BLOCKSIZE_MAX); 
+    /* Assert that we have correctly flushed the ctx params into the ms's copy */ 
+    ZSTD_assertEqualCParams(zc->appliedParams.cParams, ms->cParams); 
     if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1) {
         if (zc->appliedParams.cParams.strategy >= ZSTD_btopt) {
             ZSTD_ldm_skipRawSeqStoreBytes(&zc->externSeqStore, srcSize);
@@ -2827,26 +2827,26 @@ static size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)
         return ZSTDbss_noCompress; /* don't even attempt compression below a certain srcSize */
     }
     ZSTD_resetSeqStore(&(zc->seqStore));
-    /* required for optimal parser to read stats from dictionary */
-    ms->opt.symbolCosts = &zc->blockState.prevCBlock->entropy;
-    /* tell the optimal parser how we expect to compress literals */
-    ms->opt.literalCompressionMode = zc->appliedParams.literalCompressionMode;
-    /* a gap between an attached dict and the current window is not safe,
-     * they must remain adjacent,
-     * and when that stops being the case, the dict must be unset */
-    assert(ms->dictMatchState == NULL || ms->loadedDictEnd == ms->window.dictLimit);
-
+    /* required for optimal parser to read stats from dictionary */ 
+    ms->opt.symbolCosts = &zc->blockState.prevCBlock->entropy; 
+    /* tell the optimal parser how we expect to compress literals */ 
+    ms->opt.literalCompressionMode = zc->appliedParams.literalCompressionMode; 
+    /* a gap between an attached dict and the current window is not safe, 
+     * they must remain adjacent, 
+     * and when that stops being the case, the dict must be unset */ 
+    assert(ms->dictMatchState == NULL || ms->loadedDictEnd == ms->window.dictLimit); 
+ 
     /* limited update after a very long match */
     {   const BYTE* const base = ms->window.base;
         const BYTE* const istart = (const BYTE*)src;
         const U32 curr = (U32)(istart-base);
-        if (sizeof(ptrdiff_t)==8) assert(istart - base < (ptrdiff_t)(U32)(-1));   /* ensure no overflow */
+        if (sizeof(ptrdiff_t)==8) assert(istart - base < (ptrdiff_t)(U32)(-1));   /* ensure no overflow */ 
         if (curr > ms->nextToUpdate + 384)
             ms->nextToUpdate = curr - MIN(192, (U32)(curr - ms->nextToUpdate - 384));
     }
 
     /* select and store sequences */
-    {   ZSTD_dictMode_e const dictMode = ZSTD_matchState_dictMode(ms);
+    {   ZSTD_dictMode_e const dictMode = ZSTD_matchState_dictMode(ms); 
         size_t lastLLSize;
         {   int i;
             for (i = 0; i < ZSTD_REP_NUM; ++i)
@@ -2860,7 +2860,7 @@ static size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)
                                        ms, &zc->seqStore,
                                        zc->blockState.nextCBlock->rep,
                                        zc->appliedParams.useRowMatchFinder,
-                                       src, srcSize);
+                                       src, srcSize); 
             assert(zc->externSeqStore.pos <= zc->externSeqStore.size);
         } else if (zc->appliedParams.ldmParams.enableLdm == ZSTD_ps_enable) {
             rawSeqStore_t ldmSeqStore = kNullRawSeqStore;
@@ -2868,7 +2868,7 @@ static size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)
             ldmSeqStore.seq = zc->ldmSequences;
             ldmSeqStore.capacity = zc->maxNbLdmSequences;
             /* Updates ldmSeqStore.size */
-            FORWARD_IF_ERROR(ZSTD_ldm_generateSequences(&zc->ldmState, &ldmSeqStore,
+            FORWARD_IF_ERROR(ZSTD_ldm_generateSequences(&zc->ldmState, &ldmSeqStore, 
                                                &zc->appliedParams.ldmParams,
                                                src, srcSize), "");
             /* Updates ldmSeqStore.pos */
@@ -2877,14 +2877,14 @@ static size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)
                                        ms, &zc->seqStore,
                                        zc->blockState.nextCBlock->rep,
                                        zc->appliedParams.useRowMatchFinder,
-                                       src, srcSize);
+                                       src, srcSize); 
             assert(ldmSeqStore.pos == ldmSeqStore.size);
         } else {   /* not long range mode */
             ZSTD_blockCompressor const blockCompressor = ZSTD_selectBlockCompressor(zc->appliedParams.cParams.strategy,
                                                                                     zc->appliedParams.useRowMatchFinder,
                                                                                     dictMode);
             ms->ldmSeqStore = NULL;
-            lastLLSize = blockCompressor(ms, &zc->seqStore, zc->blockState.nextCBlock->rep, src, srcSize);
+            lastLLSize = blockCompressor(ms, &zc->seqStore, zc->blockState.nextCBlock->rep, src, srcSize); 
         }
         {   const BYTE* const lastLiterals = (const BYTE*)src + srcSize - lastLLSize;
             ZSTD_storeLastLiterals(&zc->seqStore, lastLiterals, lastLLSize);
@@ -3789,13 +3789,13 @@ ZSTD_compressBlock_internal(ZSTD_CCtx* zc,
 
     /* encode sequences and literals */
     cSize = ZSTD_entropyCompressSeqStore(&zc->seqStore,
-            &zc->blockState.prevCBlock->entropy, &zc->blockState.nextCBlock->entropy,
-            &zc->appliedParams,
-            dst, dstCapacity,
-            srcSize,
+            &zc->blockState.prevCBlock->entropy, &zc->blockState.nextCBlock->entropy, 
+            &zc->appliedParams, 
+            dst, dstCapacity, 
+            srcSize, 
             zc->entropyWorkspace, ENTROPY_WORKSPACE_SIZE /* statically allocated in resetCCtx */,
-            zc->bmi2);
-
+            zc->bmi2); 
+ 
     if (frame &&
         /* We don't want to emit our first block as a RLE even if it qualifies because
          * doing so will cause the decoder (cli only) to throw a "should consume all input error."
@@ -3809,18 +3809,18 @@ ZSTD_compressBlock_internal(ZSTD_CCtx* zc,
         op[0] = ip[0];
     }
 
-out:
+out: 
     if (!ZSTD_isError(cSize) && cSize > 1) {
         ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState);
     }
-    /* We check that dictionaries have offset codes available for the first
-     * block. After the first block, the offcode table might not have large
-     * enough codes to represent the offsets in the data.
-     */
-    if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)
-        zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;
-
-    return cSize;
+    /* We check that dictionaries have offset codes available for the first 
+     * block. After the first block, the offcode table might not have large 
+     * enough codes to represent the offsets in the data. 
+     */ 
+    if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid) 
+        zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check; 
+ 
+    return cSize; 
 }
 
 static size_t ZSTD_compressBlock_targetCBlockSize_body(ZSTD_CCtx* zc,
@@ -3951,9 +3951,9 @@ static size_t ZSTD_compress_frameChunk(ZSTD_CCtx* cctx,
         ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
         U32 const lastBlock = lastFrameChunk & (blockSize >= remaining);
 
-        RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE,
-                        dstSize_tooSmall,
-                        "not enough space to store compressed block");
+        RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE, 
+                        dstSize_tooSmall, 
+                        "not enough space to store compressed block"); 
         if (remaining < blockSize) blockSize = remaining;
 
         ZSTD_overflowCorrectIfNeeded(
@@ -4001,7 +4001,7 @@ static size_t ZSTD_compress_frameChunk(ZSTD_CCtx* cctx,
             dstCapacity -= cSize;
             cctx->isFirstBlock = 0;
             DEBUGLOG(5, "ZSTD_compress_frameChunk: adding a block of size %u",
-                        (unsigned)cSize);
+                        (unsigned)cSize); 
     }   }
 
     if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending;
@@ -4020,7 +4020,7 @@ static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,
     BYTE  const windowLogByte = (BYTE)((params->cParams.windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN) << 3);
     U32   const fcsCode = params->fParams.contentSizeFlag ?
                      (pledgedSrcSize>=256) + (pledgedSrcSize>=65536+256) + (pledgedSrcSize>=0xFFFFFFFFU) : 0;  /* 0-3 */
-    BYTE  const frameHeaderDescriptionByte = (BYTE)(dictIDSizeCode + (checksumFlag<<2) + (singleSegment<<5) + (fcsCode<<6) );
+    BYTE  const frameHeaderDescriptionByte = (BYTE)(dictIDSizeCode + (checksumFlag<<2) + (singleSegment<<5) + (fcsCode<<6) ); 
     size_t pos=0;
 
     assert(!(params->fParams.contentSizeFlag && pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN));
@@ -4032,7 +4032,7 @@ static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,
         MEM_writeLE32(dst, ZSTD_MAGICNUMBER);
         pos = 4;
     }
-    op[pos++] = frameHeaderDescriptionByte;
+    op[pos++] = frameHeaderDescriptionByte; 
     if (!singleSegment) op[pos++] = windowLogByte;
     switch(dictIDSizeCode)
     {
@@ -4080,7 +4080,7 @@ size_t ZSTD_writeSkippableFrame(void* dst, size_t dstCapacity,
 /* ZSTD_writeLastEmptyBlock() :
  * output an empty Block with end-of-frame mark to complete a frame
  * @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h))
- *           or an error code if `dstCapacity` is too small (<ZSTD_blockHeaderSize)
+ *           or an error code if `dstCapacity` is too small (<ZSTD_blockHeaderSize) 
  */
 size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity)
 {
@@ -4113,13 +4113,13 @@ static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
                         const void* src, size_t srcSize,
                                U32 frame, U32 lastFrameChunk)
 {
-    ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
+    ZSTD_matchState_t* const ms = &cctx->blockState.matchState; 
     size_t fhSize = 0;
 
     DEBUGLOG(5, "ZSTD_compressContinue_internal, stage: %u, srcSize: %u",
-                cctx->stage, (unsigned)srcSize);
-    RETURN_ERROR_IF(cctx->stage==ZSTDcs_created, stage_wrong,
-                    "missing init (ZSTD_compressBegin)");
+                cctx->stage, (unsigned)srcSize); 
+    RETURN_ERROR_IF(cctx->stage==ZSTDcs_created, stage_wrong, 
+                    "missing init (ZSTD_compressBegin)"); 
 
     if (frame && (cctx->stage==ZSTDcs_init)) {
         fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams,
@@ -4139,31 +4139,31 @@ static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
     }
     if (cctx->appliedParams.ldmParams.enableLdm == ZSTD_ps_enable) {
         ZSTD_window_update(&cctx->ldmState.window, src, srcSize, /* forceNonContiguous */ 0);
-    }
+    } 
 
-    if (!frame) {
-        /* overflow check and correction for block mode */
+    if (!frame) { 
+        /* overflow check and correction for block mode */ 
         ZSTD_overflowCorrectIfNeeded(
             ms, &cctx->workspace, &cctx->appliedParams,
             src, (BYTE const*)src + srcSize);
-    }
-
-    DEBUGLOG(5, "ZSTD_compressContinue_internal (blockSize=%u)", (unsigned)cctx->blockSize);
+    } 
+ 
+    DEBUGLOG(5, "ZSTD_compressContinue_internal (blockSize=%u)", (unsigned)cctx->blockSize); 
     {   size_t const cSize = frame ?
                              ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) :
                              ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize, 0 /* frame */);
         FORWARD_IF_ERROR(cSize, "%s", frame ? "ZSTD_compress_frameChunk failed" : "ZSTD_compressBlock_internal failed");
         cctx->consumedSrcSize += srcSize;
         cctx->producedCSize += (cSize + fhSize);
-        assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
-        if (cctx->pledgedSrcSizePlusOne != 0) {  /* control src size */
-            ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);
-            RETURN_ERROR_IF(
-                cctx->consumedSrcSize+1 > cctx->pledgedSrcSizePlusOne,
-                srcSize_wrong,
-                "error : pledgedSrcSize = %u, while realSrcSize >= %u",
-                (unsigned)cctx->pledgedSrcSizePlusOne-1,
-                (unsigned)cctx->consumedSrcSize);
+        assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0)); 
+        if (cctx->pledgedSrcSizePlusOne != 0) {  /* control src size */ 
+            ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1); 
+            RETURN_ERROR_IF( 
+                cctx->consumedSrcSize+1 > cctx->pledgedSrcSizePlusOne, 
+                srcSize_wrong, 
+                "error : pledgedSrcSize = %u, while realSrcSize >= %u", 
+                (unsigned)cctx->pledgedSrcSizePlusOne-1, 
+                (unsigned)cctx->consumedSrcSize); 
         }
         return cSize + fhSize;
     }
@@ -4173,7 +4173,7 @@ size_t ZSTD_compressContinue (ZSTD_CCtx* cctx,
                               void* dst, size_t dstCapacity,
                         const void* src, size_t srcSize)
 {
-    DEBUGLOG(5, "ZSTD_compressContinue (srcSize=%u)", (unsigned)srcSize);
+    DEBUGLOG(5, "ZSTD_compressContinue (srcSize=%u)", (unsigned)srcSize); 
     return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1 /* frame mode */, 0 /* last chunk */);
 }
 
@@ -4190,19 +4190,19 @@ size_t ZSTD_compressBlock(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const
     DEBUGLOG(5, "ZSTD_compressBlock: srcSize = %u", (unsigned)srcSize);
     { size_t const blockSizeMax = ZSTD_getBlockSize(cctx);
       RETURN_ERROR_IF(srcSize > blockSizeMax, srcSize_wrong, "input is larger than a block"); }
-
+ 
     return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0 /* frame mode */, 0 /* last chunk */);
 }
 
 /*! ZSTD_loadDictionaryContent() :
  *  @return : 0, or an error code
  */
-static size_t ZSTD_loadDictionaryContent(ZSTD_matchState_t* ms,
+static size_t ZSTD_loadDictionaryContent(ZSTD_matchState_t* ms, 
                                          ldmState_t* ls,
                                          ZSTD_cwksp* ws,
-                                         ZSTD_CCtx_params const* params,
-                                         const void* src, size_t srcSize,
-                                         ZSTD_dictTableLoadMethod_e dtlm)
+                                         ZSTD_CCtx_params const* params, 
+                                         const void* src, size_t srcSize, 
+                                         ZSTD_dictTableLoadMethod_e dtlm) 
 {
     const BYTE* ip = (const BYTE*) src;
     const BYTE* const iend = ip + srcSize;
@@ -4340,11 +4340,11 @@ size_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,
         size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr);
         RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted, "");
         RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted, "");
-        /* fill all offset symbols to avoid garbage at end of table */
-        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
-                bs->entropy.fse.offcodeCTable,
-                offcodeNCount, MaxOff, offcodeLog,
-                workspace, HUF_WORKSPACE_SIZE)),
+        /* fill all offset symbols to avoid garbage at end of table */ 
+        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp( 
+                bs->entropy.fse.offcodeCTable, 
+                offcodeNCount, MaxOff, offcodeLog, 
+                workspace, HUF_WORKSPACE_SIZE)), 
             dictionary_corrupted, "");
         /* Defer checking offcodeMaxValue because we need to know the size of the dictionary content */
         dictPtr += offcodeHeaderSize;
@@ -4355,10 +4355,10 @@ size_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,
         size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr);
         RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted, "");
         RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted, "");
-        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
-                bs->entropy.fse.matchlengthCTable,
-                matchlengthNCount, matchlengthMaxValue, matchlengthLog,
-                workspace, HUF_WORKSPACE_SIZE)),
+        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp( 
+                bs->entropy.fse.matchlengthCTable, 
+                matchlengthNCount, matchlengthMaxValue, matchlengthLog, 
+                workspace, HUF_WORKSPACE_SIZE)), 
             dictionary_corrupted, "");
         bs->entropy.fse.matchlength_repeatMode = ZSTD_dictNCountRepeat(matchlengthNCount, matchlengthMaxValue, MaxML);
         dictPtr += matchlengthHeaderSize;
@@ -4369,10 +4369,10 @@ size_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,
         size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr);
         RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted, "");
         RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted, "");
-        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
-                bs->entropy.fse.litlengthCTable,
-                litlengthNCount, litlengthMaxValue, litlengthLog,
-                workspace, HUF_WORKSPACE_SIZE)),
+        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp( 
+                bs->entropy.fse.litlengthCTable, 
+                litlengthNCount, litlengthMaxValue, litlengthLog, 
+                workspace, HUF_WORKSPACE_SIZE)), 
             dictionary_corrupted, "");
         bs->entropy.fse.litlength_repeatMode = ZSTD_dictNCountRepeat(litlengthNCount, litlengthMaxValue, MaxLL);
         dictPtr += litlengthHeaderSize;
@@ -4443,16 +4443,16 @@ static size_t ZSTD_loadZstdDictionary(ZSTD_compressedBlockState_t* bs,
 
 /** ZSTD_compress_insertDictionary() :
 *   @return : dictID, or an error code */
-static size_t
-ZSTD_compress_insertDictionary(ZSTD_compressedBlockState_t* bs,
-                               ZSTD_matchState_t* ms,
+static size_t 
+ZSTD_compress_insertDictionary(ZSTD_compressedBlockState_t* bs, 
+                               ZSTD_matchState_t* ms, 
                                ldmState_t* ls,
                                ZSTD_cwksp* ws,
-                         const ZSTD_CCtx_params* params,
-                         const void* dict, size_t dictSize,
-                               ZSTD_dictContentType_e dictContentType,
-                               ZSTD_dictTableLoadMethod_e dtlm,
-                               void* workspace)
+                         const ZSTD_CCtx_params* params, 
+                         const void* dict, size_t dictSize, 
+                               ZSTD_dictContentType_e dictContentType, 
+                               ZSTD_dictTableLoadMethod_e dtlm, 
+                               void* workspace) 
 {
     DEBUGLOG(4, "ZSTD_compress_insertDictionary (dictSize=%u)", (U32)dictSize);
     if ((dict==NULL) || (dictSize<8)) {
@@ -4486,13 +4486,13 @@ ZSTD_compress_insertDictionary(ZSTD_compressedBlockState_t* bs,
 
 /*! ZSTD_compressBegin_internal() :
  * @return : 0, or an error code */
-static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
-                                    const void* dict, size_t dictSize,
-                                    ZSTD_dictContentType_e dictContentType,
-                                    ZSTD_dictTableLoadMethod_e dtlm,
-                                    const ZSTD_CDict* cdict,
+static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx, 
+                                    const void* dict, size_t dictSize, 
+                                    ZSTD_dictContentType_e dictContentType, 
+                                    ZSTD_dictTableLoadMethod_e dtlm, 
+                                    const ZSTD_CDict* cdict, 
                                     const ZSTD_CCtx_params* params, U64 pledgedSrcSize,
-                                    ZSTD_buffered_policy_e zbuff)
+                                    ZSTD_buffered_policy_e zbuff) 
 {
     size_t const dictContentSize = cdict ? cdict->dictContentSize : dictSize;
 #if ZSTD_TRACE
@@ -4509,7 +4509,7 @@ static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
         || pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN
         || cdict->compressionLevel == 0)
       && (params->attachDictPref != ZSTD_dictForceLoad) ) {
-        return ZSTD_resetCCtx_usingCDict(cctx, cdict, params, pledgedSrcSize, zbuff);
+        return ZSTD_resetCCtx_usingCDict(cctx, cdict, params, pledgedSrcSize, zbuff); 
     }
 
     FORWARD_IF_ERROR( ZSTD_resetCCtx_internal(cctx, params, pledgedSrcSize,
@@ -4536,7 +4536,7 @@ static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
 size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
                                     const void* dict, size_t dictSize,
                                     ZSTD_dictContentType_e dictContentType,
-                                    ZSTD_dictTableLoadMethod_e dtlm,
+                                    ZSTD_dictTableLoadMethod_e dtlm, 
                                     const ZSTD_CDict* cdict,
                                     const ZSTD_CCtx_params* params,
                                     unsigned long long pledgedSrcSize)
@@ -4545,7 +4545,7 @@ size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
     /* compression parameters verification and optimization */
     FORWARD_IF_ERROR( ZSTD_checkCParams(params->cParams) , "");
     return ZSTD_compressBegin_internal(cctx,
-                                       dict, dictSize, dictContentType, dtlm,
+                                       dict, dictSize, dictContentType, dtlm, 
                                        cdict,
                                        params, pledgedSrcSize,
                                        ZSTDb_not_buffered);
@@ -4560,7 +4560,7 @@ size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx,
     ZSTD_CCtx_params cctxParams;
     ZSTD_CCtxParams_init_internal(&cctxParams, &params, ZSTD_NO_CLEVEL);
     return ZSTD_compressBegin_advanced_internal(cctx,
-                                            dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast,
+                                            dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, 
                                             NULL /*cdict*/,
                                             &cctxParams, pledgedSrcSize);
 }
@@ -4572,8 +4572,8 @@ size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t di
         ZSTD_parameters const params = ZSTD_getParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_noAttachDict);
         ZSTD_CCtxParams_init_internal(&cctxParams, &params, (compressionLevel == 0) ? ZSTD_CLEVEL_DEFAULT : compressionLevel);
     }
-    DEBUGLOG(4, "ZSTD_compressBegin_usingDict (dictSize=%u)", (unsigned)dictSize);
-    return ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
+    DEBUGLOG(4, "ZSTD_compressBegin_usingDict (dictSize=%u)", (unsigned)dictSize); 
+    return ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL, 
                                        &cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, ZSTDb_not_buffered);
 }
 
@@ -4593,7 +4593,7 @@ static size_t ZSTD_writeEpilogue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity)
     size_t fhSize = 0;
 
     DEBUGLOG(4, "ZSTD_writeEpilogue");
-    RETURN_ERROR_IF(cctx->stage == ZSTDcs_created, stage_wrong, "init missing");
+    RETURN_ERROR_IF(cctx->stage == ZSTDcs_created, stage_wrong, "init missing"); 
 
     /* special case : empty frame */
     if (cctx->stage == ZSTDcs_init) {
@@ -4616,7 +4616,7 @@ static size_t ZSTD_writeEpilogue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity)
     if (cctx->appliedParams.fParams.checksumFlag) {
         U32 const checksum = (U32) XXH64_digest(&cctx->xxhState);
         RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, "no room for checksum");
-        DEBUGLOG(4, "ZSTD_writeEpilogue: write checksum : %08X", (unsigned)checksum);
+        DEBUGLOG(4, "ZSTD_writeEpilogue: write checksum : %08X", (unsigned)checksum); 
         MEM_writeLE32(op, checksum);
         op += 4;
     }
@@ -4660,22 +4660,22 @@ size_t ZSTD_compressEnd (ZSTD_CCtx* cctx,
     FORWARD_IF_ERROR(cSize, "ZSTD_compressContinue_internal failed");
     endResult = ZSTD_writeEpilogue(cctx, (char*)dst + cSize, dstCapacity-cSize);
     FORWARD_IF_ERROR(endResult, "ZSTD_writeEpilogue failed");
-    assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
-    if (cctx->pledgedSrcSizePlusOne != 0) {  /* control src size */
-        ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);
+    assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0)); 
+    if (cctx->pledgedSrcSizePlusOne != 0) {  /* control src size */ 
+        ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1); 
         DEBUGLOG(4, "end of frame : controlling src size");
-        RETURN_ERROR_IF(
-            cctx->pledgedSrcSizePlusOne != cctx->consumedSrcSize+1,
-            srcSize_wrong,
-             "error : pledgedSrcSize = %u, while realSrcSize = %u",
-            (unsigned)cctx->pledgedSrcSizePlusOne-1,
-            (unsigned)cctx->consumedSrcSize);
-    }
+        RETURN_ERROR_IF( 
+            cctx->pledgedSrcSizePlusOne != cctx->consumedSrcSize+1, 
+            srcSize_wrong, 
+             "error : pledgedSrcSize = %u, while realSrcSize = %u", 
+            (unsigned)cctx->pledgedSrcSizePlusOne-1, 
+            (unsigned)cctx->consumedSrcSize); 
+    } 
     ZSTD_CCtx_trace(cctx, endResult);
     return cSize + endResult;
 }
 
-size_t ZSTD_compress_advanced (ZSTD_CCtx* cctx,
+size_t ZSTD_compress_advanced (ZSTD_CCtx* cctx, 
                                void* dst, size_t dstCapacity,
                          const void* src, size_t srcSize,
                          const void* dict,size_t dictSize,
@@ -4699,18 +4699,18 @@ size_t ZSTD_compress_advanced_internal(
         const void* dict,size_t dictSize,
         const ZSTD_CCtx_params* params)
 {
-    DEBUGLOG(4, "ZSTD_compress_advanced_internal (srcSize:%u)", (unsigned)srcSize);
-    FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx,
-                         dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
+    DEBUGLOG(4, "ZSTD_compress_advanced_internal (srcSize:%u)", (unsigned)srcSize); 
+    FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx, 
+                         dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL, 
                          params, srcSize, ZSTDb_not_buffered) , "");
     return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
 }
 
-size_t ZSTD_compress_usingDict(ZSTD_CCtx* cctx,
-                               void* dst, size_t dstCapacity,
-                         const void* src, size_t srcSize,
-                         const void* dict, size_t dictSize,
-                               int compressionLevel)
+size_t ZSTD_compress_usingDict(ZSTD_CCtx* cctx, 
+                               void* dst, size_t dstCapacity, 
+                         const void* src, size_t srcSize, 
+                         const void* dict, size_t dictSize, 
+                               int compressionLevel) 
 {
     {
         ZSTD_parameters const params = ZSTD_getParams_internal(compressionLevel, srcSize, dict ? dictSize : 0, ZSTD_cpm_noAttachDict);
@@ -4721,19 +4721,19 @@ size_t ZSTD_compress_usingDict(ZSTD_CCtx* cctx,
     return ZSTD_compress_advanced_internal(cctx, dst, dstCapacity, src, srcSize, dict, dictSize, &cctx->simpleApiParams);
 }
 
-size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,
-                         void* dst, size_t dstCapacity,
-                   const void* src, size_t srcSize,
-                         int compressionLevel)
+size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx, 
+                         void* dst, size_t dstCapacity, 
+                   const void* src, size_t srcSize, 
+                         int compressionLevel) 
 {
-    DEBUGLOG(4, "ZSTD_compressCCtx (srcSize=%u)", (unsigned)srcSize);
-    assert(cctx != NULL);
+    DEBUGLOG(4, "ZSTD_compressCCtx (srcSize=%u)", (unsigned)srcSize); 
+    assert(cctx != NULL); 
     return ZSTD_compress_usingDict(cctx, dst, dstCapacity, src, srcSize, NULL, 0, compressionLevel);
 }
 
-size_t ZSTD_compress(void* dst, size_t dstCapacity,
-               const void* src, size_t srcSize,
-                     int compressionLevel)
+size_t ZSTD_compress(void* dst, size_t dstCapacity, 
+               const void* src, size_t srcSize, 
+                     int compressionLevel) 
 {
     size_t result;
 #if ZSTD_COMPRESS_HEAPMODE
@@ -4743,9 +4743,9 @@ size_t ZSTD_compress(void* dst, size_t dstCapacity,
     ZSTD_freeCCtx(cctx);
 #else
     ZSTD_CCtx ctxBody;
-    ZSTD_initCCtx(&ctxBody, ZSTD_defaultCMem);
+    ZSTD_initCCtx(&ctxBody, ZSTD_defaultCMem); 
     result = ZSTD_compressCCtx(&ctxBody, dst, dstCapacity, src, srcSize, compressionLevel);
-    ZSTD_freeCCtxContent(&ctxBody);   /* can't free ctxBody itself, as it's on stack; free only heap content */
+    ZSTD_freeCCtxContent(&ctxBody);   /* can't free ctxBody itself, as it's on stack; free only heap content */ 
 #endif
     return result;
 }
@@ -4759,7 +4759,7 @@ size_t ZSTD_estimateCDictSize_advanced(
         size_t dictSize, ZSTD_compressionParameters cParams,
         ZSTD_dictLoadMethod_e dictLoadMethod)
 {
-    DEBUGLOG(5, "sizeof(ZSTD_CDict) : %u", (unsigned)sizeof(ZSTD_CDict));
+    DEBUGLOG(5, "sizeof(ZSTD_CDict) : %u", (unsigned)sizeof(ZSTD_CDict)); 
     return ZSTD_cwksp_alloc_size(sizeof(ZSTD_CDict))
          + ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE)
          /* enableDedicatedDictSearch == 1 ensures that CDict estimation will not be too small
@@ -4779,7 +4779,7 @@ size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel)
 size_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict)
 {
     if (cdict==NULL) return 0;   /* support sizeof on NULL */
-    DEBUGLOG(5, "sizeof(*cdict) : %u", (unsigned)sizeof(*cdict));
+    DEBUGLOG(5, "sizeof(*cdict) : %u", (unsigned)sizeof(*cdict)); 
     /* cdict may be in the workspace */
     return (cdict->workspace.workspace == cdict ? 0 : sizeof(*cdict))
         + ZSTD_cwksp_sizeof(&cdict->workspace);
@@ -4792,7 +4792,7 @@ static size_t ZSTD_initCDict_internal(
                     ZSTD_dictContentType_e dictContentType,
                     ZSTD_CCtx_params params)
 {
-    DEBUGLOG(3, "ZSTD_initCDict_internal (dictContentType:%u)", (unsigned)dictContentType);
+    DEBUGLOG(3, "ZSTD_initCDict_internal (dictContentType:%u)", (unsigned)dictContentType); 
     assert(!ZSTD_checkCParams(params.cParams));
     cdict->matchState.cParams = params.cParams;
     cdict->matchState.dedicatedDictSearch = params.enableDedicatedDictSearch;
@@ -5018,7 +5018,7 @@ const ZSTD_CDict* ZSTD_initStaticCDict(
     }
 
     DEBUGLOG(4, "(workspaceSize < neededSize) : (%u < %u) => %u",
-        (unsigned)workspaceSize, (unsigned)neededSize, (unsigned)(workspaceSize < neededSize));
+        (unsigned)workspaceSize, (unsigned)neededSize, (unsigned)(workspaceSize < neededSize)); 
     if (workspaceSize < neededSize) return NULL;
 
     ZSTD_CCtxParams_init(&params, 0);
@@ -5038,7 +5038,7 @@ const ZSTD_CDict* ZSTD_initStaticCDict(
 ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict)
 {
     assert(cdict != NULL);
-    return cdict->matchState.cParams;
+    return cdict->matchState.cParams; 
 }
 
 /*! ZSTD_getDictID_fromCDict() :
@@ -5195,17 +5195,17 @@ static ZSTD_cParamMode_e ZSTD_getCParamMode(ZSTD_CDict const* cdict, ZSTD_CCtx_p
 
 /* ZSTD_resetCStream():
  * pledgedSrcSize == 0 means "unknown" */
-size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pss)
-{
-    /* temporary : 0 interpreted as "unknown" during transition period.
-     * Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN.
-     * 0 will be interpreted as "empty" in the future.
-     */
-    U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
-    DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (unsigned)pledgedSrcSize);
+size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pss) 
+{
+    /* temporary : 0 interpreted as "unknown" during transition period. 
+     * Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN. 
+     * 0 will be interpreted as "empty" in the future. 
+     */ 
+    U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss; 
+    DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (unsigned)pledgedSrcSize); 
     FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
     FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , "");
-    return 0;
+    return 0; 
 }
 
 /*! ZSTD_initCStream_internal() :
@@ -5223,13 +5223,13 @@ size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
     assert(!ZSTD_isError(ZSTD_checkCParams(params->cParams)));
     zcs->requestedParams = *params;
     assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
-    if (dict) {
+    if (dict) { 
         FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) , "");
     } else {
-        /* Dictionary is cleared if !cdict */
+        /* Dictionary is cleared if !cdict */ 
         FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) , "");
     }
-    return 0;
+    return 0; 
 }
 
 /* ZSTD_initCStream_usingCDict_advanced() :
@@ -5242,9 +5242,9 @@ size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
     DEBUGLOG(4, "ZSTD_initCStream_usingCDict_advanced");
     FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
     FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , "");
-    zcs->requestedParams.fParams = fParams;
+    zcs->requestedParams.fParams = fParams; 
     FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) , "");
-    return 0;
+    return 0; 
 }
 
 /* note : cdict must outlive compression session */
@@ -5253,7 +5253,7 @@ size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)
     DEBUGLOG(4, "ZSTD_initCStream_usingCDict");
     FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
     FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) , "");
-    return 0;
+    return 0; 
 }
 
 
@@ -5263,44 +5263,44 @@ size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)
  * dict is loaded with default parameters ZSTD_dct_auto and ZSTD_dlm_byCopy. */
 size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
                                  const void* dict, size_t dictSize,
-                                 ZSTD_parameters params, unsigned long long pss)
-{
-    /* for compatibility with older programs relying on this behavior.
-     * Users should now specify ZSTD_CONTENTSIZE_UNKNOWN.
-     * This line will be removed in the future.
-     */
-    U64 const pledgedSrcSize = (pss==0 && params.fParams.contentSizeFlag==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
-    DEBUGLOG(4, "ZSTD_initCStream_advanced");
+                                 ZSTD_parameters params, unsigned long long pss) 
+{
+    /* for compatibility with older programs relying on this behavior. 
+     * Users should now specify ZSTD_CONTENTSIZE_UNKNOWN. 
+     * This line will be removed in the future. 
+     */ 
+    U64 const pledgedSrcSize = (pss==0 && params.fParams.contentSizeFlag==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss; 
+    DEBUGLOG(4, "ZSTD_initCStream_advanced"); 
     FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
     FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , "");
     FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) , "");
     ZSTD_CCtxParams_setZstdParams(&zcs->requestedParams, &params);
     FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) , "");
-    return 0;
+    return 0; 
 }
 
 size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel)
 {
-    DEBUGLOG(4, "ZSTD_initCStream_usingDict");
+    DEBUGLOG(4, "ZSTD_initCStream_usingDict"); 
     FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
     FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) , "");
     FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) , "");
-    return 0;
+    return 0; 
 }
 
 size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pss)
 {
-    /* temporary : 0 interpreted as "unknown" during transition period.
-     * Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN.
-     * 0 will be interpreted as "empty" in the future.
-     */
-    U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;
-    DEBUGLOG(4, "ZSTD_initCStream_srcSize");
+    /* temporary : 0 interpreted as "unknown" during transition period. 
+     * Users willing to specify "unknown" **must** use ZSTD_CONTENTSIZE_UNKNOWN. 
+     * 0 will be interpreted as "empty" in the future. 
+     */ 
+    U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss; 
+    DEBUGLOG(4, "ZSTD_initCStream_srcSize"); 
     FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
     FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, NULL) , "");
     FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) , "");
     FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , "");
-    return 0;
+    return 0; 
 }
 
 size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel)
@@ -5309,26 +5309,26 @@ size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel)
     FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , "");
     FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, NULL) , "");
     FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) , "");
-    return 0;
+    return 0; 
 }
 
 /*======   Compression   ======*/
 
-static size_t ZSTD_nextInputSizeHint(const ZSTD_CCtx* cctx)
+static size_t ZSTD_nextInputSizeHint(const ZSTD_CCtx* cctx) 
 {
-    size_t hintInSize = cctx->inBuffTarget - cctx->inBuffPos;
-    if (hintInSize==0) hintInSize = cctx->blockSize;
-    return hintInSize;
-}
-
+    size_t hintInSize = cctx->inBuffTarget - cctx->inBuffPos; 
+    if (hintInSize==0) hintInSize = cctx->blockSize; 
+    return hintInSize; 
+} 
+ 
 /** ZSTD_compressStream_generic():
- *  internal function for all *compressStream*() variants
+ *  internal function for all *compressStream*() variants 
  *  non-static, because can be called from zstdmt_compress.c
  * @return : hint size for next input */
-static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
-                                          ZSTD_outBuffer* output,
-                                          ZSTD_inBuffer* input,
-                                          ZSTD_EndDirective const flushMode)
+static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs, 
+                                          ZSTD_outBuffer* output, 
+                                          ZSTD_inBuffer* input, 
+                                          ZSTD_EndDirective const flushMode) 
 {
     const char* const istart = (const char*)input->src;
     const char* const iend = input->size != 0 ? istart + input->size : istart;
@@ -5339,7 +5339,7 @@ static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
     U32 someMoreWork = 1;
 
     /* check expectations */
-    DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%u", (unsigned)flushMode);
+    DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%u", (unsigned)flushMode); 
     if (zcs->appliedParams.inBufferMode == ZSTD_bm_buffered) {
         assert(zcs->inBuff != NULL);
         assert(zcs->inBuffSize > 0);
@@ -5356,7 +5356,7 @@ static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
         switch(zcs->streamStage)
         {
         case zcss_init:
-            RETURN_ERROR(init_missing, "call ZSTD_initCStream() first!");
+            RETURN_ERROR(init_missing, "call ZSTD_initCStream() first!"); 
 
         case zcss_load:
             if ( (flushMode == ZSTD_e_end)
@@ -5366,12 +5366,12 @@ static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
                 /* shortcut to compression pass directly into output buffer */
                 size_t const cSize = ZSTD_compressEnd(zcs,
                                                 op, oend-op, ip, iend-ip);
-                DEBUGLOG(4, "ZSTD_compressEnd : cSize=%u", (unsigned)cSize);
+                DEBUGLOG(4, "ZSTD_compressEnd : cSize=%u", (unsigned)cSize); 
                 FORWARD_IF_ERROR(cSize, "ZSTD_compressEnd failed");
                 ip = iend;
                 op += cSize;
                 zcs->frameEnded = 1;
-                ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
+                ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only); 
                 someMoreWork = 0; break;
             }
             /* complete loading into inBuffer in buffered mode */
@@ -5444,7 +5444,7 @@ static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
                     if (zcs->frameEnded) {
                         DEBUGLOG(5, "Frame completed directly in outBuffer");
                         someMoreWork = 0;
-                        ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
+                        ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only); 
                     }
                     break;
                 }
@@ -5460,7 +5460,7 @@ static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
                 size_t const flushed = ZSTD_limitCopy(op, (size_t)(oend-op),
                             zcs->outBuff + zcs->outBuffFlushedSize, toFlush);
                 DEBUGLOG(5, "toFlush: %u into %u ==> flushed: %u",
-                            (unsigned)toFlush, (unsigned)(oend-op), (unsigned)flushed);
+                            (unsigned)toFlush, (unsigned)(oend-op), (unsigned)flushed); 
                 if (flushed)
                     op += flushed;
                 zcs->outBuffFlushedSize += flushed;
@@ -5474,7 +5474,7 @@ static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
                 if (zcs->frameEnded) {
                     DEBUGLOG(5, "Frame completed on flush");
                     someMoreWork = 0;
-                    ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
+                    ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only); 
                     break;
                 }
                 zcs->streamStage = zcss_load;
@@ -5489,25 +5489,25 @@ static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
     input->pos = ip - istart;
     output->pos = op - ostart;
     if (zcs->frameEnded) return 0;
-    return ZSTD_nextInputSizeHint(zcs);
-}
-
-static size_t ZSTD_nextInputSizeHint_MTorST(const ZSTD_CCtx* cctx)
-{
-#ifdef ZSTD_MULTITHREAD
-    if (cctx->appliedParams.nbWorkers >= 1) {
-        assert(cctx->mtctx != NULL);
-        return ZSTDMT_nextInputSizeHint(cctx->mtctx);
+    return ZSTD_nextInputSizeHint(zcs); 
+} 
+ 
+static size_t ZSTD_nextInputSizeHint_MTorST(const ZSTD_CCtx* cctx) 
+{ 
+#ifdef ZSTD_MULTITHREAD 
+    if (cctx->appliedParams.nbWorkers >= 1) { 
+        assert(cctx->mtctx != NULL); 
+        return ZSTDMT_nextInputSizeHint(cctx->mtctx); 
     }
-#endif
-    return ZSTD_nextInputSizeHint(cctx);
-
+#endif 
+    return ZSTD_nextInputSizeHint(cctx); 
+ 
 }
 
 size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
 {
     FORWARD_IF_ERROR( ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue) , "");
-    return ZSTD_nextInputSizeHint_MTorST(zcs);
+    return ZSTD_nextInputSizeHint_MTorST(zcs); 
 }
 
 /* After a compression call set the expected input/output buffer.
@@ -5631,12 +5631,12 @@ static size_t ZSTD_CCtx_init_compressStream2(ZSTD_CCtx* cctx,
     return 0;
 }
 
-size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
-                             ZSTD_outBuffer* output,
-                             ZSTD_inBuffer* input,
-                             ZSTD_EndDirective endOp)
+size_t ZSTD_compressStream2( ZSTD_CCtx* cctx, 
+                             ZSTD_outBuffer* output, 
+                             ZSTD_inBuffer* input, 
+                             ZSTD_EndDirective endOp) 
 {
-    DEBUGLOG(5, "ZSTD_compressStream2, endOp=%u ", (unsigned)endOp);
+    DEBUGLOG(5, "ZSTD_compressStream2, endOp=%u ", (unsigned)endOp); 
     /* check conditions */
     RETURN_ERROR_IF(output->pos > output->size, dstSize_tooSmall, "invalid output buffer");
     RETURN_ERROR_IF(input->pos  > input->size, srcSize_wrong, "invalid input buffer");
@@ -5648,13 +5648,13 @@ size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
         FORWARD_IF_ERROR(ZSTD_CCtx_init_compressStream2(cctx, endOp, input->size), "CompressStream2 initialization failed");
         ZSTD_setBufferExpectations(cctx, output, input);    /* Set initial buffer expectations now that we've initialized */
     }
-    /* end of transparent initialization stage */
+    /* end of transparent initialization stage */ 
 
     FORWARD_IF_ERROR(ZSTD_checkBufferStability(cctx, output, input, endOp), "invalid buffers");
     /* compression stage */
 #ifdef ZSTD_MULTITHREAD
     if (cctx->appliedParams.nbWorkers > 0) {
-        size_t flushMin;
+        size_t flushMin; 
         if (cctx->cParamsChanged) {
             ZSTDMT_updateCParams_whileCompressing(cctx->mtctx, &cctx->requestedParams);
             cctx->cParamsChanged = 0;
@@ -5662,14 +5662,14 @@ size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
         for (;;) {
             size_t const ipos = input->pos;
             size_t const opos = output->pos;
-            flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
+            flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp); 
             cctx->consumedSrcSize += (U64)(input->pos - ipos);
             cctx->producedCSize += (U64)(output->pos - opos);
             if ( ZSTD_isError(flushMin)
               || (endOp == ZSTD_e_end && flushMin == 0) ) { /* compression completed */
                 if (flushMin == 0)
                     ZSTD_CCtx_trace(cctx, 0);
-                ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);
+                ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only); 
             }
             FORWARD_IF_ERROR(flushMin, "ZSTDMT_compressStream_generic failed");
 
@@ -5689,22 +5689,22 @@ size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
                     break;
             }
         }
-        DEBUGLOG(5, "completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic");
-        /* Either we don't require maximum forward progress, we've finished the
-         * flush, or we are out of output space.
-         */
+        DEBUGLOG(5, "completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic"); 
+        /* Either we don't require maximum forward progress, we've finished the 
+         * flush, or we are out of output space. 
+         */ 
         assert(endOp == ZSTD_e_continue || flushMin == 0 || output->pos == output->size);
         ZSTD_setBufferExpectations(cctx, output, input);
-        return flushMin;
-    }
+        return flushMin; 
+    } 
 #endif
     FORWARD_IF_ERROR( ZSTD_compressStream_generic(cctx, output, input, endOp) , "");
-    DEBUGLOG(5, "completed ZSTD_compressStream2");
+    DEBUGLOG(5, "completed ZSTD_compressStream2"); 
     ZSTD_setBufferExpectations(cctx, output, input);
     return cctx->outBuffContentSize - cctx->outBuffFlushedSize; /* remaining to flush */
 }
 
-size_t ZSTD_compressStream2_simpleArgs (
+size_t ZSTD_compressStream2_simpleArgs ( 
                             ZSTD_CCtx* cctx,
                             void* dst, size_t dstCapacity, size_t* dstPos,
                       const void* src, size_t srcSize, size_t* srcPos,
@@ -5712,42 +5712,42 @@ size_t ZSTD_compressStream2_simpleArgs (
 {
     ZSTD_outBuffer output = { dst, dstCapacity, *dstPos };
     ZSTD_inBuffer  input  = { src, srcSize, *srcPos };
-    /* ZSTD_compressStream2() will check validity of dstPos and srcPos */
-    size_t const cErr = ZSTD_compressStream2(cctx, &output, &input, endOp);
+    /* ZSTD_compressStream2() will check validity of dstPos and srcPos */ 
+    size_t const cErr = ZSTD_compressStream2(cctx, &output, &input, endOp); 
     *dstPos = output.pos;
     *srcPos = input.pos;
     return cErr;
 }
 
-size_t ZSTD_compress2(ZSTD_CCtx* cctx,
-                      void* dst, size_t dstCapacity,
-                      const void* src, size_t srcSize)
-{
+size_t ZSTD_compress2(ZSTD_CCtx* cctx, 
+                      void* dst, size_t dstCapacity, 
+                      const void* src, size_t srcSize) 
+{ 
     ZSTD_bufferMode_e const originalInBufferMode = cctx->requestedParams.inBufferMode;
     ZSTD_bufferMode_e const originalOutBufferMode = cctx->requestedParams.outBufferMode;
     DEBUGLOG(4, "ZSTD_compress2 (srcSize=%u)", (unsigned)srcSize);
-    ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);
+    ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only); 
     /* Enable stable input/output buffers. */
     cctx->requestedParams.inBufferMode = ZSTD_bm_stable;
     cctx->requestedParams.outBufferMode = ZSTD_bm_stable;
-    {   size_t oPos = 0;
-        size_t iPos = 0;
-        size_t const result = ZSTD_compressStream2_simpleArgs(cctx,
-                                        dst, dstCapacity, &oPos,
-                                        src, srcSize, &iPos,
-                                        ZSTD_e_end);
+    {   size_t oPos = 0; 
+        size_t iPos = 0; 
+        size_t const result = ZSTD_compressStream2_simpleArgs(cctx, 
+                                        dst, dstCapacity, &oPos, 
+                                        src, srcSize, &iPos, 
+                                        ZSTD_e_end); 
         /* Reset to the original values. */
         cctx->requestedParams.inBufferMode = originalInBufferMode;
         cctx->requestedParams.outBufferMode = originalOutBufferMode;
         FORWARD_IF_ERROR(result, "ZSTD_compressStream2_simpleArgs failed");
-        if (result != 0) {  /* compression not completed, due to lack of output space */
-            assert(oPos == dstCapacity);
+        if (result != 0) {  /* compression not completed, due to lack of output space */ 
+            assert(oPos == dstCapacity); 
             RETURN_ERROR(dstSize_tooSmall, "");
-        }
-        assert(iPos == srcSize);   /* all input is expected consumed */
-        return oPos;
-    }
-}
+        } 
+        assert(iPos == srcSize);   /* all input is expected consumed */ 
+        return oPos; 
+    } 
+} 
 
 typedef struct {
     U32 idx;             /* Index in array of ZSTD_Sequence */
@@ -6160,21 +6160,21 @@ size_t ZSTD_compressSequences(ZSTD_CCtx* const cctx, void* dst, size_t dstCapaci
 size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
 {
     ZSTD_inBuffer input = { NULL, 0, 0 };
-    return ZSTD_compressStream2(zcs, output, &input, ZSTD_e_flush);
+    return ZSTD_compressStream2(zcs, output, &input, ZSTD_e_flush); 
 }
 
 
 size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
 {
     ZSTD_inBuffer input = { NULL, 0, 0 };
-    size_t const remainingToFlush = ZSTD_compressStream2(zcs, output, &input, ZSTD_e_end);
+    size_t const remainingToFlush = ZSTD_compressStream2(zcs, output, &input, ZSTD_e_end); 
     FORWARD_IF_ERROR( remainingToFlush , "ZSTD_compressStream2 failed");
-    if (zcs->appliedParams.nbWorkers > 0) return remainingToFlush;   /* minimal estimation */
-    /* single thread mode : attempt to calculate remaining to flush more precisely */
+    if (zcs->appliedParams.nbWorkers > 0) return remainingToFlush;   /* minimal estimation */ 
+    /* single thread mode : attempt to calculate remaining to flush more precisely */ 
     {   size_t const lastBlockSize = zcs->frameEnded ? 0 : ZSTD_BLOCKHEADERSIZE;
         size_t const checksumSize = (size_t)(zcs->frameEnded ? 0 : zcs->appliedParams.fParams.checksumFlag * 4);
-        size_t const toFlush = remainingToFlush + lastBlockSize + checksumSize;
-        DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (unsigned)toFlush);
+        size_t const toFlush = remainingToFlush + lastBlockSize + checksumSize; 
+        DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (unsigned)toFlush); 
         return toFlush;
     }
 }
@@ -6184,7 +6184,7 @@ size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
 #include "clevels.h"
 
 int ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
-int ZSTD_minCLevel(void) { return (int)-ZSTD_TARGETLENGTH_MAX; }
+int ZSTD_minCLevel(void) { return (int)-ZSTD_TARGETLENGTH_MAX; } 
 int ZSTD_defaultCLevel(void) { return ZSTD_CLEVEL_DEFAULT; }
 
 static ZSTD_compressionParameters ZSTD_dedicatedDictSearch_getCParams(int const compressionLevel, size_t const dictSize)
@@ -6265,14 +6265,14 @@ static U64 ZSTD_getCParamRowSize(U64 srcSizeHint, size_t dictSize, ZSTD_cParamMo
 }
 
 /*! ZSTD_getCParams_internal() :
- * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.
+ * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize. 
  *  Note: srcSizeHint 0 means 0, use ZSTD_CONTENTSIZE_UNKNOWN for unknown.
  *        Use dictSize == 0 for unknown or unused.
  *  Note: `mode` controls how we treat the `dictSize`. See docs for `ZSTD_cParamMode_e`. */
 static ZSTD_compressionParameters ZSTD_getCParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode)
 {
     U64 const rSize = ZSTD_getCParamRowSize(srcSizeHint, dictSize, mode);
-    U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);
+    U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB); 
     int row;
     DEBUGLOG(5, "ZSTD_getCParams_internal (cLevel=%i)", compressionLevel);
 
@@ -6291,7 +6291,7 @@ static ZSTD_compressionParameters ZSTD_getCParams_internal(int compressionLevel,
         }
         /* refine parameters based on srcSize & dictSize */
         return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize, mode);
-    }
+    } 
 }
 
 /*! ZSTD_getCParams() :
@@ -6304,9 +6304,9 @@ ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long l
 }
 
 /*! ZSTD_getParams() :
- *  same idea as ZSTD_getCParams()
- * @return a `ZSTD_parameters` structure (instead of `ZSTD_compressionParameters`).
- *  Fields of `ZSTD_frameParameters` are set to default values */
+ *  same idea as ZSTD_getCParams() 
+ * @return a `ZSTD_parameters` structure (instead of `ZSTD_compressionParameters`). 
+ *  Fields of `ZSTD_frameParameters` are set to default values */ 
 static ZSTD_parameters ZSTD_getParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode) {
     ZSTD_parameters params;
     ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize, mode);
diff --git a/contrib/libs/zstd/lib/compress/zstd_compress_internal.h b/contrib/libs/zstd/lib/compress/zstd_compress_internal.h
index c406e794bdb..ba416c942c8 100644
--- a/contrib/libs/zstd/lib/compress/zstd_compress_internal.h
+++ b/contrib/libs/zstd/lib/compress/zstd_compress_internal.h
@@ -36,7 +36,7 @@ extern "C" {
 #define ZSTD_DUBT_UNSORTED_MARK 1   /* For btlazy2 strategy, index ZSTD_DUBT_UNSORTED_MARK==1 means "unsorted".
                                        It could be confused for a real successor at index "1", if sorted as larger than its predecessor.
                                        It's not a big deal though : candidate will just be sorted again.
-                                       Additionally, candidate position 1 will be lost.
+                                       Additionally, candidate position 1 will be lost. 
                                        But candidate 1 cannot hide a large tree of candidates, so it's a minimal loss.
                                        The benefit is that ZSTD_DUBT_UNSORTED_MARK cannot be mishandled after table re-use with a different strategy.
                                        This constant is required by ZSTD_compressBlock_btlazy2() and ZSTD_reduceTable_internal() */
@@ -55,30 +55,30 @@ typedef struct ZSTD_prefixDict_s {
 } ZSTD_prefixDict;
 
 typedef struct {
-    void* dictBuffer;
-    void const* dict;
-    size_t dictSize;
-    ZSTD_dictContentType_e dictContentType;
-    ZSTD_CDict* cdict;
-} ZSTD_localDict;
-
-typedef struct {
+    void* dictBuffer; 
+    void const* dict; 
+    size_t dictSize; 
+    ZSTD_dictContentType_e dictContentType; 
+    ZSTD_CDict* cdict; 
+} ZSTD_localDict; 
+ 
+typedef struct { 
     HUF_CElt CTable[HUF_CTABLE_SIZE_ST(255)];
-    HUF_repeat repeatMode;
-} ZSTD_hufCTables_t;
-
-typedef struct {
+    HUF_repeat repeatMode; 
+} ZSTD_hufCTables_t; 
+ 
+typedef struct { 
     FSE_CTable offcodeCTable[FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)];
     FSE_CTable matchlengthCTable[FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)];
     FSE_CTable litlengthCTable[FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)];
     FSE_repeat offcode_repeatMode;
     FSE_repeat matchlength_repeatMode;
     FSE_repeat litlength_repeatMode;
-} ZSTD_fseCTables_t;
-
-typedef struct {
-    ZSTD_hufCTables_t huf;
-    ZSTD_fseCTables_t fse;
+} ZSTD_fseCTables_t; 
+ 
+typedef struct { 
+    ZSTD_hufCTables_t huf; 
+    ZSTD_fseCTables_t fse; 
 } ZSTD_entropyCTables_t;
 
 /***********************************************
@@ -158,27 +158,27 @@ typedef struct {
     U32 rep[ZSTD_REP_NUM];
 } ZSTD_optimal_t;
 
-typedef enum { zop_dynamic=0, zop_predef } ZSTD_OptPrice_e;
-
+typedef enum { zop_dynamic=0, zop_predef } ZSTD_OptPrice_e; 
+ 
 typedef struct {
     /* All tables are allocated inside cctx->workspace by ZSTD_resetCCtx_internal() */
-    unsigned* litFreq;           /* table of literals statistics, of size 256 */
-    unsigned* litLengthFreq;     /* table of litLength statistics, of size (MaxLL+1) */
-    unsigned* matchLengthFreq;   /* table of matchLength statistics, of size (MaxML+1) */
-    unsigned* offCodeFreq;       /* table of offCode statistics, of size (MaxOff+1) */
-    ZSTD_match_t* matchTable;    /* list of found matches, of size ZSTD_OPT_NUM+1 */
-    ZSTD_optimal_t* priceTable;  /* All positions tracked by optimal parser, of size ZSTD_OPT_NUM+1 */
+    unsigned* litFreq;           /* table of literals statistics, of size 256 */ 
+    unsigned* litLengthFreq;     /* table of litLength statistics, of size (MaxLL+1) */ 
+    unsigned* matchLengthFreq;   /* table of matchLength statistics, of size (MaxML+1) */ 
+    unsigned* offCodeFreq;       /* table of offCode statistics, of size (MaxOff+1) */ 
+    ZSTD_match_t* matchTable;    /* list of found matches, of size ZSTD_OPT_NUM+1 */ 
+    ZSTD_optimal_t* priceTable;  /* All positions tracked by optimal parser, of size ZSTD_OPT_NUM+1 */ 
 
     U32  litSum;                 /* nb of literals */
     U32  litLengthSum;           /* nb of litLength codes */
     U32  matchLengthSum;         /* nb of matchLength codes */
     U32  offCodeSum;             /* nb of offset codes */
-    U32  litSumBasePrice;        /* to compare to log2(litfreq) */
-    U32  litLengthSumBasePrice;  /* to compare to log2(llfreq)  */
-    U32  matchLengthSumBasePrice;/* to compare to log2(mlfreq)  */
-    U32  offCodeSumBasePrice;    /* to compare to log2(offreq)  */
-    ZSTD_OptPrice_e priceType;   /* prices can be determined dynamically, or follow a pre-defined cost structure */
-    const ZSTD_entropyCTables_t* symbolCosts;  /* pre-calculated dictionary statistics */
+    U32  litSumBasePrice;        /* to compare to log2(litfreq) */ 
+    U32  litLengthSumBasePrice;  /* to compare to log2(llfreq)  */ 
+    U32  matchLengthSumBasePrice;/* to compare to log2(mlfreq)  */ 
+    U32  offCodeSumBasePrice;    /* to compare to log2(offreq)  */ 
+    ZSTD_OptPrice_e priceType;   /* prices can be determined dynamically, or follow a pre-defined cost structure */ 
+    const ZSTD_entropyCTables_t* symbolCosts;  /* pre-calculated dictionary statistics */ 
     ZSTD_paramSwitch_e literalCompressionMode;
 } optState_t;
 
@@ -201,12 +201,12 @@ typedef struct {
 
 #define ZSTD_WINDOW_START_INDEX 2
 
-typedef struct ZSTD_matchState_t ZSTD_matchState_t;
+typedef struct ZSTD_matchState_t ZSTD_matchState_t; 
 
 #define ZSTD_ROW_HASH_CACHE_SIZE 8       /* Size of prefetching hash cache for row-based matchfinder */
 
-struct ZSTD_matchState_t {
-    ZSTD_window_t window;   /* State for window round buffer management */
+struct ZSTD_matchState_t { 
+    ZSTD_window_t window;   /* State for window round buffer management */ 
     U32 loadedDictEnd;      /* index of end of dictionary, within context's referential.
                              * When loadedDictEnd != 0, a dictionary is in use, and still valid.
                              * This relies on a mechanism to set loadedDictEnd=0 when dictionary is no longer within distance.
@@ -214,7 +214,7 @@ struct ZSTD_matchState_t {
                              * When dict referential is copied into active context (i.e. not attached),
                              * loadedDictEnd == dictSize, since referential starts from zero.
                              */
-    U32 nextToUpdate;       /* index from which to continue table update */
+    U32 nextToUpdate;       /* index from which to continue table update */ 
     U32 hashLog3;           /* dispatch table for matches of len==3 : larger == faster, more memory */
 
     U32 rowHashLog;                          /* For row-based matchfinder: Hashlog based on nb of rows in the hashTable.*/
@@ -232,9 +232,9 @@ struct ZSTD_matchState_t {
                                */
     optState_t opt;         /* optimal parser state */
     const ZSTD_matchState_t* dictMatchState;
-    ZSTD_compressionParameters cParams;
+    ZSTD_compressionParameters cParams; 
     const rawSeqStore_t* ldmSeqStore;
-};
+}; 
 
 typedef struct {
     ZSTD_compressedBlockState_t* prevCBlock;
@@ -270,7 +270,7 @@ typedef struct {
     U32 hashLog;            /* Log size of hashTable */
     U32 bucketSizeLog;      /* Log bucket size for collision resolution, at most 8 */
     U32 minMatchLength;     /* Minimum match length */
-    U32 hashRateLog;       /* Log number of entries to skip */
+    U32 hashRateLog;       /* Log number of entries to skip */ 
     U32 windowLog;          /* Window log for the LDM */
 } ldmParams_t;
 
@@ -296,14 +296,14 @@ struct ZSTD_CCtx_params_s {
                                 * Hint is not valid when srcSizeHint == 0.
                                 * There is no guarantee that hint is close to actual source size */
 
-    ZSTD_dictAttachPref_e attachDictPref;
+    ZSTD_dictAttachPref_e attachDictPref; 
     ZSTD_paramSwitch_e literalCompressionMode;
-
+ 
     /* Multithreading: used to pass parameters to mtctx */
-    int nbWorkers;
-    size_t jobSize;
-    int overlapLog;
-    int rsyncable;
+    int nbWorkers; 
+    size_t jobSize; 
+    int overlapLog; 
+    int rsyncable; 
 
     /* Long distance matching parameters */
     ldmParams_t ldmParams;
@@ -370,7 +370,7 @@ struct ZSTD_CCtx_s {
     ZSTD_CCtx_params simpleApiParams;    /* Param storage used by the simple API - not sticky. Must only be used in top-level simple API functions for storage. */
     U32   dictID;
     size_t dictContentSize;
-
+ 
     ZSTD_cwksp workspace; /* manages buffer for dynamic allocations */
     size_t blockSize;
     unsigned long long pledgedSrcSizePlusOne;  /* this way, 0 (default) == unknown */
@@ -413,7 +413,7 @@ struct ZSTD_CCtx_s {
     size_t expectedOutBufferSize;
 
     /* Dictionary */
-    ZSTD_localDict localDict;
+    ZSTD_localDict localDict; 
     const ZSTD_CDict* cdict;
     ZSTD_prefixDict prefixDict;   /* single-usage dictionary */
 
@@ -431,7 +431,7 @@ struct ZSTD_CCtx_s {
     ZSTD_blockSplitCtx blockSplitCtx;
 };
 
-typedef enum { ZSTD_dtlm_fast, ZSTD_dtlm_full } ZSTD_dictTableLoadMethod_e;
+typedef enum { ZSTD_dtlm_fast, ZSTD_dtlm_full } ZSTD_dictTableLoadMethod_e; 
 
 typedef enum {
     ZSTD_noDict = 0,
@@ -439,7 +439,7 @@ typedef enum {
     ZSTD_dictMatchState = 2,
     ZSTD_dedicatedDictSearch = 3
 } ZSTD_dictMode_e;
-
+ 
 typedef enum {
     ZSTD_cpm_noAttachDict = 0,  /* Compression with ZSTD_noDict or ZSTD_extDict.
                                  * In this mode we use both the srcSize and the dictSize
@@ -459,10 +459,10 @@ typedef enum {
                                  * when selecting and adjusting parameters.
                                  */
 } ZSTD_cParamMode_e;
-
+ 
 typedef size_t (*ZSTD_blockCompressor) (
         ZSTD_matchState_t* bs, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
+        void const* src, size_t srcSize); 
 ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_paramSwitch_e rowMatchfinderMode, ZSTD_dictMode_e dictMode);
 
 
@@ -604,18 +604,18 @@ ZSTD_storeSeq(seqStore_t* seqStorePtr,
 {
     BYTE const* const litLimit_w = litLimit - WILDCOPY_OVERLENGTH;
     BYTE const* const litEnd = literals + litLength;
-#if defined(DEBUGLEVEL) && (DEBUGLEVEL >= 6)
+#if defined(DEBUGLEVEL) && (DEBUGLEVEL >= 6) 
     static const BYTE* g_start = NULL;
     if (g_start==NULL) g_start = (const BYTE*)literals;  /* note : index only works for compression within a single segment */
     {   U32 const pos = (U32)((const BYTE*)literals - g_start);
-        DEBUGLOG(6, "Cpos%7u :%3u literals, match%4u bytes at offCode%7u",
+        DEBUGLOG(6, "Cpos%7u :%3u literals, match%4u bytes at offCode%7u", 
                pos, (U32)litLength, (U32)matchLength, (U32)offBase_minus1);
     }
 #endif
-    assert((size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart) < seqStorePtr->maxNbSeq);
+    assert((size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart) < seqStorePtr->maxNbSeq); 
     /* copy Literals */
-    assert(seqStorePtr->maxNbLit <= 128 KB);
-    assert(seqStorePtr->lit + litLength <= seqStorePtr->litStart + seqStorePtr->maxNbLit);
+    assert(seqStorePtr->maxNbLit <= 128 KB); 
+    assert(seqStorePtr->lit + litLength <= seqStorePtr->litStart + seqStorePtr->maxNbLit); 
     assert(literals + litLength <= litLimit);
     if (litEnd <= litLimit_w) {
         /* Common case we can use wildcopy.
@@ -826,11 +826,11 @@ ZSTD_count_2segments(const BYTE* ip, const BYTE* match,
     const BYTE* const vEnd = MIN( ip + (mEnd - match), iEnd);
     size_t const matchLength = ZSTD_count(ip, match, vEnd);
     if (match + matchLength != mEnd) return matchLength;
-    DEBUGLOG(7, "ZSTD_count_2segments: found a 2-parts match (current length==%zu)", matchLength);
-    DEBUGLOG(7, "distance from match beginning to end dictionary = %zi", mEnd - match);
-    DEBUGLOG(7, "distance from current pos to end buffer = %zi", iEnd - ip);
-    DEBUGLOG(7, "next byte : ip==%02X, istart==%02X", ip[matchLength], *iStart);
-    DEBUGLOG(7, "final match length = %zu", matchLength + ZSTD_count(ip+matchLength, iStart, iEnd));
+    DEBUGLOG(7, "ZSTD_count_2segments: found a 2-parts match (current length==%zu)", matchLength); 
+    DEBUGLOG(7, "distance from match beginning to end dictionary = %zi", mEnd - match); 
+    DEBUGLOG(7, "distance from current pos to end buffer = %zi", iEnd - ip); 
+    DEBUGLOG(7, "next byte : ip==%02X, istart==%02X", ip[matchLength], *iStart); 
+    DEBUGLOG(7, "final match length = %zu", matchLength + ZSTD_count(ip+matchLength, iStart, iEnd)); 
     return matchLength + ZSTD_count(ip+matchLength, iStart, iEnd);
 }
 
@@ -876,64 +876,64 @@ size_t ZSTD_hashPtr(const void* p, U32 hBits, U32 mls)
     }
 }
 
-/** ZSTD_ipow() :
- * Return base^exponent.
- */
-static U64 ZSTD_ipow(U64 base, U64 exponent)
-{
-    U64 power = 1;
-    while (exponent) {
-      if (exponent & 1) power *= base;
-      exponent >>= 1;
-      base *= base;
-    }
-    return power;
-}
-
-#define ZSTD_ROLL_HASH_CHAR_OFFSET 10
-
-/** ZSTD_rollingHash_append() :
- * Add the buffer to the hash value.
- */
-static U64 ZSTD_rollingHash_append(U64 hash, void const* buf, size_t size)
-{
-    BYTE const* istart = (BYTE const*)buf;
-    size_t pos;
-    for (pos = 0; pos < size; ++pos) {
-        hash *= prime8bytes;
-        hash += istart[pos] + ZSTD_ROLL_HASH_CHAR_OFFSET;
-    }
-    return hash;
-}
-
-/** ZSTD_rollingHash_compute() :
- * Compute the rolling hash value of the buffer.
- */
-MEM_STATIC U64 ZSTD_rollingHash_compute(void const* buf, size_t size)
-{
-    return ZSTD_rollingHash_append(0, buf, size);
-}
-
-/** ZSTD_rollingHash_primePower() :
- * Compute the primePower to be passed to ZSTD_rollingHash_rotate() for a hash
- * over a window of length bytes.
- */
-MEM_STATIC U64 ZSTD_rollingHash_primePower(U32 length)
-{
-    return ZSTD_ipow(prime8bytes, length - 1);
-}
-
-/** ZSTD_rollingHash_rotate() :
- * Rotate the rolling hash by one byte.
- */
-MEM_STATIC U64 ZSTD_rollingHash_rotate(U64 hash, BYTE toRemove, BYTE toAdd, U64 primePower)
-{
-    hash -= (toRemove + ZSTD_ROLL_HASH_CHAR_OFFSET) * primePower;
-    hash *= prime8bytes;
-    hash += toAdd + ZSTD_ROLL_HASH_CHAR_OFFSET;
-    return hash;
-}
-
+/** ZSTD_ipow() : 
+ * Return base^exponent. 
+ */ 
+static U64 ZSTD_ipow(U64 base, U64 exponent) 
+{ 
+    U64 power = 1; 
+    while (exponent) { 
+      if (exponent & 1) power *= base; 
+      exponent >>= 1; 
+      base *= base; 
+    } 
+    return power; 
+} 
+ 
+#define ZSTD_ROLL_HASH_CHAR_OFFSET 10 
+ 
+/** ZSTD_rollingHash_append() : 
+ * Add the buffer to the hash value. 
+ */ 
+static U64 ZSTD_rollingHash_append(U64 hash, void const* buf, size_t size) 
+{ 
+    BYTE const* istart = (BYTE const*)buf; 
+    size_t pos; 
+    for (pos = 0; pos < size; ++pos) { 
+        hash *= prime8bytes; 
+        hash += istart[pos] + ZSTD_ROLL_HASH_CHAR_OFFSET; 
+    } 
+    return hash; 
+} 
+ 
+/** ZSTD_rollingHash_compute() : 
+ * Compute the rolling hash value of the buffer. 
+ */ 
+MEM_STATIC U64 ZSTD_rollingHash_compute(void const* buf, size_t size) 
+{ 
+    return ZSTD_rollingHash_append(0, buf, size); 
+} 
+ 
+/** ZSTD_rollingHash_primePower() : 
+ * Compute the primePower to be passed to ZSTD_rollingHash_rotate() for a hash 
+ * over a window of length bytes. 
+ */ 
+MEM_STATIC U64 ZSTD_rollingHash_primePower(U32 length) 
+{ 
+    return ZSTD_ipow(prime8bytes, length - 1); 
+} 
+ 
+/** ZSTD_rollingHash_rotate() : 
+ * Rotate the rolling hash by one byte. 
+ */ 
+MEM_STATIC U64 ZSTD_rollingHash_rotate(U64 hash, BYTE toRemove, BYTE toAdd, U64 primePower) 
+{ 
+    hash -= (toRemove + ZSTD_ROLL_HASH_CHAR_OFFSET) * primePower; 
+    hash *= prime8bytes; 
+    hash += toAdd + ZSTD_ROLL_HASH_CHAR_OFFSET; 
+    return hash; 
+} 
+ 
 /*-*************************************
 *  Round buffer management
 ***************************************/
@@ -977,19 +977,19 @@ MEM_STATIC U32 ZSTD_window_hasExtDict(ZSTD_window_t const window)
 }
 
 /**
- * ZSTD_matchState_dictMode():
- * Inspects the provided matchState and figures out what dictMode should be
- * passed to the compressor.
- */
-MEM_STATIC ZSTD_dictMode_e ZSTD_matchState_dictMode(const ZSTD_matchState_t *ms)
-{
-    return ZSTD_window_hasExtDict(ms->window) ?
-        ZSTD_extDict :
-        ms->dictMatchState != NULL ?
+ * ZSTD_matchState_dictMode(): 
+ * Inspects the provided matchState and figures out what dictMode should be 
+ * passed to the compressor. 
+ */ 
+MEM_STATIC ZSTD_dictMode_e ZSTD_matchState_dictMode(const ZSTD_matchState_t *ms) 
+{ 
+    return ZSTD_window_hasExtDict(ms->window) ? 
+        ZSTD_extDict : 
+        ms->dictMatchState != NULL ? 
             (ms->dictMatchState->dedicatedDictSearch ? ZSTD_dedicatedDictSearch : ZSTD_dictMatchState) :
-            ZSTD_noDict;
-}
-
+            ZSTD_noDict; 
+} 
+ 
 /* Defining this macro to non-zero tells zstd to run the overflow correction
  * code much more frequently. This is very inefficient, and should only be
  * used for tests and fuzzers.
@@ -1002,7 +1002,7 @@ MEM_STATIC ZSTD_dictMode_e ZSTD_matchState_dictMode(const ZSTD_matchState_t *ms)
 #  endif
 #endif
 
-/**
+/** 
  * ZSTD_window_canOverflowCorrect():
  * Returns non-zero if the indices are large enough for overflow correction
  * to work correctly without impacting compression ratio.
@@ -1144,14 +1144,14 @@ MEM_STATIC U32 ZSTD_window_correctOverflow(ZSTD_window_t* window, U32 cycleLog,
  * ZSTD_window_enforceMaxDist():
  * Updates lowLimit so that:
  *    (srcEnd - base) - lowLimit == maxDist + loadedDictEnd
- *
+ * 
  * It ensures index is valid as long as index >= lowLimit.
  * This must be called before a block compression call.
- *
+ * 
  * loadedDictEnd is only defined if a dictionary is in use for current compression.
  * As the name implies, loadedDictEnd represents the index at end of dictionary.
  * The value lies within context's referential, it can be directly compared to blockEndIdx.
- *
+ * 
  * If loadedDictEndPtr is NULL, no dictionary is in use, and we use loadedDictEnd == 0.
  * If loadedDictEndPtr is not NULL, we set it to zero after updating lowLimit.
  * This is because dictionaries are allowed to be referenced fully
@@ -1163,12 +1163,12 @@ MEM_STATIC U32 ZSTD_window_correctOverflow(ZSTD_window_t* window, U32 cycleLog,
  * and the dictionary is below them.
  * forceWindow and dictMatchState are therefore incompatible.
  */
-MEM_STATIC void
-ZSTD_window_enforceMaxDist(ZSTD_window_t* window,
+MEM_STATIC void 
+ZSTD_window_enforceMaxDist(ZSTD_window_t* window, 
                      const void* blockEnd,
                            U32   maxDist,
                            U32*  loadedDictEndPtr,
-                     const ZSTD_matchState_t** dictMatchStatePtr)
+                     const ZSTD_matchState_t** dictMatchStatePtr) 
 {
     U32 const blockEndIdx = (U32)((BYTE const*)blockEnd - window->base);
     U32 const loadedDictEnd = (loadedDictEndPtr != NULL) ? *loadedDictEndPtr : 0;
@@ -1188,12 +1188,12 @@ ZSTD_window_enforceMaxDist(ZSTD_window_t* window,
          loadedDictEnd is expressed within the referential of the context,
          so it can be directly compared against blockEndIdx.
     */
-    if (blockEndIdx > maxDist + loadedDictEnd) {
-        U32 const newLowLimit = blockEndIdx - maxDist;
+    if (blockEndIdx > maxDist + loadedDictEnd) { 
+        U32 const newLowLimit = blockEndIdx - maxDist; 
         if (window->lowLimit < newLowLimit) window->lowLimit = newLowLimit;
         if (window->dictLimit < window->lowLimit) {
-            DEBUGLOG(5, "Update dictLimit to match lowLimit, from %u to %u",
-                        (unsigned)window->dictLimit, (unsigned)window->lowLimit);
+            DEBUGLOG(5, "Update dictLimit to match lowLimit, from %u to %u", 
+                        (unsigned)window->dictLimit, (unsigned)window->lowLimit); 
             window->dictLimit = window->lowLimit;
         }
         /* On reaching window size, dictionaries are invalidated */
@@ -1261,7 +1261,7 @@ MEM_STATIC U32 ZSTD_window_update(ZSTD_window_t* window,
 {
     BYTE const* const ip = (BYTE const*)src;
     U32 contiguous = 1;
-    DEBUGLOG(5, "ZSTD_window_update");
+    DEBUGLOG(5, "ZSTD_window_update"); 
     if (srcSize == 0)
         return contiguous;
     assert(window->base != NULL);
@@ -1270,7 +1270,7 @@ MEM_STATIC U32 ZSTD_window_update(ZSTD_window_t* window,
     if (src != window->nextSrc || forceNonContiguous) {
         /* not contiguous */
         size_t const distanceFromBase = (size_t)(window->nextSrc - window->base);
-        DEBUGLOG(5, "Non contiguous blocks, new segment starts at %u", window->dictLimit);
+        DEBUGLOG(5, "Non contiguous blocks, new segment starts at %u", window->dictLimit); 
         window->lowLimit = window->dictLimit;
         assert(distanceFromBase == (size_t)(U32)distanceFromBase);  /* should never overflow */
         window->dictLimit = (U32)distanceFromBase;
@@ -1287,7 +1287,7 @@ MEM_STATIC U32 ZSTD_window_update(ZSTD_window_t* window,
         ptrdiff_t const highInputIdx = (ip + srcSize) - window->dictBase;
         U32 const lowLimitMax = (highInputIdx > (ptrdiff_t)window->dictLimit) ? window->dictLimit : (U32)highInputIdx;
         window->lowLimit = lowLimitMax;
-        DEBUGLOG(5, "Overlapping extDict and input : new lowLimit = %u", window->lowLimit);
+        DEBUGLOG(5, "Overlapping extDict and input : new lowLimit = %u", window->lowLimit); 
     }
     return contiguous;
 }
@@ -1308,7 +1308,7 @@ MEM_STATIC U32 ZSTD_getLowestMatchIndex(const ZSTD_matchState_t* ms, U32 curr, u
     U32 const matchLowest = isDictionary ? lowestValid : withinWindow;
     return matchLowest;
 }
-
+ 
 /**
  * Returns the lowest allowed match index in the prefix.
  */
@@ -1327,38 +1327,38 @@ MEM_STATIC U32 ZSTD_getLowestPrefixIndex(const ZSTD_matchState_t* ms, U32 curr,
 
 
 
-/* debug functions */
-#if (DEBUGLEVEL>=2)
-
-MEM_STATIC double ZSTD_fWeight(U32 rawStat)
-{
-    U32 const fp_accuracy = 8;
-    U32 const fp_multiplier = (1 << fp_accuracy);
-    U32 const newStat = rawStat + 1;
-    U32 const hb = ZSTD_highbit32(newStat);
-    U32 const BWeight = hb * fp_multiplier;
-    U32 const FWeight = (newStat << fp_accuracy) >> hb;
-    U32 const weight = BWeight + FWeight;
-    assert(hb + fp_accuracy < 31);
-    return (double)weight / fp_multiplier;
-}
-
-/* display a table content,
- * listing each element, its frequency, and its predicted bit cost */
-MEM_STATIC void ZSTD_debugTable(const U32* table, U32 max)
-{
-    unsigned u, sum;
-    for (u=0, sum=0; u<=max; u++) sum += table[u];
-    DEBUGLOG(2, "total nb elts: %u", sum);
-    for (u=0; u<=max; u++) {
-        DEBUGLOG(2, "%2u: %5u  (%.2f)",
-                u, table[u], ZSTD_fWeight(sum) - ZSTD_fWeight(table[u]) );
-    }
-}
-
-#endif
-
-
+/* debug functions */ 
+#if (DEBUGLEVEL>=2) 
+ 
+MEM_STATIC double ZSTD_fWeight(U32 rawStat) 
+{ 
+    U32 const fp_accuracy = 8; 
+    U32 const fp_multiplier = (1 << fp_accuracy); 
+    U32 const newStat = rawStat + 1; 
+    U32 const hb = ZSTD_highbit32(newStat); 
+    U32 const BWeight = hb * fp_multiplier; 
+    U32 const FWeight = (newStat << fp_accuracy) >> hb; 
+    U32 const weight = BWeight + FWeight; 
+    assert(hb + fp_accuracy < 31); 
+    return (double)weight / fp_multiplier; 
+} 
+ 
+/* display a table content, 
+ * listing each element, its frequency, and its predicted bit cost */ 
+MEM_STATIC void ZSTD_debugTable(const U32* table, U32 max) 
+{ 
+    unsigned u, sum; 
+    for (u=0, sum=0; u<=max; u++) sum += table[u]; 
+    DEBUGLOG(2, "total nb elts: %u", sum); 
+    for (u=0; u<=max; u++) { 
+        DEBUGLOG(2, "%2u: %5u  (%.2f)", 
+                u, table[u], ZSTD_fWeight(sum) - ZSTD_fWeight(table[u]) ); 
+    } 
+} 
+ 
+#endif 
+ 
+ 
 #if defined (__cplusplus)
 }
 #endif
@@ -1384,7 +1384,7 @@ void ZSTD_reset_compressedBlockState(ZSTD_compressedBlockState_t* bs);
  * ============================================================== */
 
 /* ZSTD_getCParamsFromCCtxParams() :
- * cParams are built depending on compressionLevel, src size hints,
+ * cParams are built depending on compressionLevel, src size hints, 
  * LDM and manually set compression parameters.
  * Note: srcSizeHint == 0 means 0!
  */
@@ -1401,7 +1401,7 @@ size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
                      const ZSTD_CDict* cdict,
                      const ZSTD_CCtx_params* params, unsigned long long pledgedSrcSize);
 
-void ZSTD_resetSeqStore(seqStore_t* ssPtr);
+void ZSTD_resetSeqStore(seqStore_t* ssPtr); 
 
 /*! ZSTD_getCParamsFromCDict() :
  *  as the name implies */
@@ -1412,7 +1412,7 @@ ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict);
 size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
                                     const void* dict, size_t dictSize,
                                     ZSTD_dictContentType_e dictContentType,
-                                    ZSTD_dictTableLoadMethod_e dtlm,
+                                    ZSTD_dictTableLoadMethod_e dtlm, 
                                     const ZSTD_CDict* cdict,
                                     const ZSTD_CCtx_params* params,
                                     unsigned long long pledgedSrcSize);
@@ -1429,7 +1429,7 @@ size_t ZSTD_compress_advanced_internal(ZSTD_CCtx* cctx,
 /* ZSTD_writeLastEmptyBlock() :
  * output an empty Block with end-of-frame mark to complete a frame
  * @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h))
- *           or an error code if `dstCapacity` is too small (<ZSTD_blockHeaderSize)
+ *           or an error code if `dstCapacity` is too small (<ZSTD_blockHeaderSize) 
  */
 size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity);
 
diff --git a/contrib/libs/zstd/lib/compress/zstd_double_fast.c b/contrib/libs/zstd/lib/compress/zstd_double_fast.c
index 76933dea262..27dcc0aa952 100644
--- a/contrib/libs/zstd/lib/compress/zstd_double_fast.c
+++ b/contrib/libs/zstd/lib/compress/zstd_double_fast.c
@@ -13,12 +13,12 @@
 
 
 void ZSTD_fillDoubleHashTable(ZSTD_matchState_t* ms,
-                              void const* end, ZSTD_dictTableLoadMethod_e dtlm)
+                              void const* end, ZSTD_dictTableLoadMethod_e dtlm) 
 {
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    const ZSTD_compressionParameters* const cParams = &ms->cParams; 
     U32* const hashLarge = ms->hashTable;
     U32  const hBitsL = cParams->hashLog;
-    U32  const mls = cParams->minMatch;
+    U32  const mls = cParams->minMatch; 
     U32* const hashSmall = ms->chainTable;
     U32  const hBitsS = cParams->chainLog;
     const BYTE* const base = ms->window.base;
@@ -40,9 +40,9 @@ void ZSTD_fillDoubleHashTable(ZSTD_matchState_t* ms,
                 hashSmall[smHash] = curr + i;
             if (i == 0 || hashLarge[lgHash] == 0)
                 hashLarge[lgHash] = curr + i;
-            /* Only load extra positions for ZSTD_dtlm_full */
-            if (dtlm == ZSTD_dtlm_fast)
-                break;
+            /* Only load extra positions for ZSTD_dtlm_full */ 
+            if (dtlm == ZSTD_dtlm_fast) 
+                break; 
     }   }
 }
 
@@ -256,10 +256,10 @@ _match_stored:
 FORCE_INLINE_TEMPLATE
 size_t ZSTD_compressBlock_doubleFast_dictMatchState_generic(
         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 /* template */)
 {
-    ZSTD_compressionParameters const* cParams = &ms->cParams;
+    ZSTD_compressionParameters const* cParams = &ms->cParams; 
     U32* const hashLong = ms->hashTable;
     const U32 hBitsL = cParams->hashLog;
     U32* const hashSmall = ms->chainTable;
@@ -271,13 +271,13 @@ size_t ZSTD_compressBlock_doubleFast_dictMatchState_generic(
     const U32 endIndex = (U32)((size_t)(istart - base) + srcSize);
     /* presumes that, if there is a dictionary, it must be using Attach mode */
     const U32 prefixLowestIndex = ZSTD_getLowestPrefixIndex(ms, endIndex, cParams->windowLog);
-    const BYTE* const prefixLowest = base + prefixLowestIndex;
+    const BYTE* const prefixLowest = base + prefixLowestIndex; 
     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_matchState_t* const dms = ms->dictMatchState; 
     const ZSTD_compressionParameters* const dictCParams = &dms->cParams;
     const U32* const dictHashLong  = dms->hashTable;
     const U32* const dictHashSmall = dms->chainTable;
@@ -289,14 +289,14 @@ size_t ZSTD_compressBlock_doubleFast_dictMatchState_generic(
     const U32 dictHBitsL           = dictCParams->hashLog;
     const U32 dictHBitsS           = dictCParams->chainLog;
     const U32 dictAndPrefixLength  = (U32)((ip - prefixLowest) + (dictEnd - dictStart));
-
+ 
     DEBUGLOG(5, "ZSTD_compressBlock_doubleFast_dictMatchState_generic");
 
     /* if a dictionary is attached, it must be within window range */
     assert(ms->window.dictLimit + (1U << cParams->windowLog) >= endIndex);
 
     /* init */
-    ip += (dictAndPrefixLength == 0);
+    ip += (dictAndPrefixLength == 0); 
 
     /* dictMatchState repCode checks don't currently handle repCode == 0
      * disabling. */
@@ -306,122 +306,122 @@ size_t ZSTD_compressBlock_doubleFast_dictMatchState_generic(
     /* Main Search Loop */
     while (ip < ilimit) {   /* < instead of <=, because repcode check at (ip+1) */
         size_t mLength;
-        U32 offset;
+        U32 offset; 
         size_t const h2 = ZSTD_hashPtr(ip, hBitsL, 8);
         size_t const h = ZSTD_hashPtr(ip, hBitsS, mls);
-        size_t const dictHL = ZSTD_hashPtr(ip, dictHBitsL, 8);
-        size_t const dictHS = ZSTD_hashPtr(ip, dictHBitsS, mls);
+        size_t const dictHL = ZSTD_hashPtr(ip, dictHBitsL, 8); 
+        size_t const dictHS = ZSTD_hashPtr(ip, dictHBitsS, mls); 
         U32 const curr = (U32)(ip-base);
         U32 const matchIndexL = hashLong[h2];
-        U32 matchIndexS = hashSmall[h];
+        U32 matchIndexS = hashSmall[h]; 
         const BYTE* matchLong = base + matchIndexL;
         const BYTE* match = base + matchIndexS;
         const U32 repIndex = curr + 1 - offset_1;
         const BYTE* repMatch = (repIndex < prefixLowestIndex) ?
-                               dictBase + (repIndex - dictIndexDelta) :
-                               base + repIndex;
+                               dictBase + (repIndex - dictIndexDelta) : 
+                               base + repIndex; 
         hashLong[h2] = hashSmall[h] = curr;   /* update hash tables */
 
         /* check repcode */
         if (((U32)((prefixLowestIndex-1) - repIndex) >= 3 /* intentional underflow */)
-            && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
-            const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;
-            mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;
-            ip++;
+            && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) { 
+            const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend; 
+            mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4; 
+            ip++; 
             ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, STORE_REPCODE_1, mLength);
-            goto _match_stored;
-        }
-
-        if (matchIndexL > prefixLowestIndex) {
-            /* check prefix long match */
-            if (MEM_read64(matchLong) == MEM_read64(ip)) {
+            goto _match_stored; 
+        } 
+ 
+        if (matchIndexL > prefixLowestIndex) { 
+            /* check prefix long match */ 
+            if (MEM_read64(matchLong) == MEM_read64(ip)) { 
                 mLength = ZSTD_count(ip+8, matchLong+8, iend) + 8;
                 offset = (U32)(ip-matchLong);
-                while (((ip>anchor) & (matchLong>prefixLowest)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; mLength++; } /* catch up */
-                goto _match_found;
-            }
+                while (((ip>anchor) & (matchLong>prefixLowest)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; mLength++; } /* catch up */ 
+                goto _match_found; 
+            } 
         } else {
-            /* check dictMatchState long match */
-            U32 const dictMatchIndexL = dictHashLong[dictHL];
-            const BYTE* dictMatchL = dictBase + dictMatchIndexL;
-            assert(dictMatchL < dictEnd);
-
-            if (dictMatchL > dictStart && MEM_read64(dictMatchL) == MEM_read64(ip)) {
-                mLength = ZSTD_count_2segments(ip+8, dictMatchL+8, iend, dictEnd, prefixLowest) + 8;
+            /* check dictMatchState long match */ 
+            U32 const dictMatchIndexL = dictHashLong[dictHL]; 
+            const BYTE* dictMatchL = dictBase + dictMatchIndexL; 
+            assert(dictMatchL < dictEnd); 
+ 
+            if (dictMatchL > dictStart && MEM_read64(dictMatchL) == MEM_read64(ip)) { 
+                mLength = ZSTD_count_2segments(ip+8, dictMatchL+8, iend, dictEnd, prefixLowest) + 8; 
                 offset = (U32)(curr - dictMatchIndexL - dictIndexDelta);
-                while (((ip>anchor) & (dictMatchL>dictStart)) && (ip[-1] == dictMatchL[-1])) { ip--; dictMatchL--; mLength++; } /* catch up */
-                goto _match_found;
+                while (((ip>anchor) & (dictMatchL>dictStart)) && (ip[-1] == dictMatchL[-1])) { ip--; dictMatchL--; mLength++; } /* catch up */ 
+                goto _match_found; 
         }   }
-
-        if (matchIndexS > prefixLowestIndex) {
-            /* check prefix short match */
-            if (MEM_read32(match) == MEM_read32(ip)) {
-                goto _search_next_long;
-            }
+ 
+        if (matchIndexS > prefixLowestIndex) { 
+            /* check prefix short match */ 
+            if (MEM_read32(match) == MEM_read32(ip)) { 
+                goto _search_next_long; 
+            } 
         } else {
-            /* check dictMatchState short match */
-            U32 const dictMatchIndexS = dictHashSmall[dictHS];
-            match = dictBase + dictMatchIndexS;
-            matchIndexS = dictMatchIndexS + dictIndexDelta;
-
-            if (match > dictStart && MEM_read32(match) == MEM_read32(ip)) {
-                goto _search_next_long;
+            /* check dictMatchState short match */ 
+            U32 const dictMatchIndexS = dictHashSmall[dictHS]; 
+            match = dictBase + dictMatchIndexS; 
+            matchIndexS = dictMatchIndexS + dictIndexDelta; 
+ 
+            if (match > dictStart && MEM_read32(match) == MEM_read32(ip)) { 
+                goto _search_next_long; 
         }   }
-
-        ip += ((ip-anchor) >> kSearchStrength) + 1;
+ 
+        ip += ((ip-anchor) >> kSearchStrength) + 1; 
 #if defined(__aarch64__)
         PREFETCH_L1(ip+256);
 #endif
-        continue;
-
-_search_next_long:
-
+        continue; 
+ 
+_search_next_long: 
+ 
         {   size_t const hl3 = ZSTD_hashPtr(ip+1, hBitsL, 8);
-            size_t const dictHLNext = ZSTD_hashPtr(ip+1, dictHBitsL, 8);
-            U32 const matchIndexL3 = hashLong[hl3];
-            const BYTE* matchL3 = base + matchIndexL3;
+            size_t const dictHLNext = ZSTD_hashPtr(ip+1, dictHBitsL, 8); 
+            U32 const matchIndexL3 = hashLong[hl3]; 
+            const BYTE* matchL3 = base + matchIndexL3; 
             hashLong[hl3] = curr + 1;
-
-            /* check prefix long +1 match */
-            if (matchIndexL3 > prefixLowestIndex) {
-                if (MEM_read64(matchL3) == MEM_read64(ip+1)) {
+ 
+            /* check prefix long +1 match */ 
+            if (matchIndexL3 > prefixLowestIndex) { 
+                if (MEM_read64(matchL3) == MEM_read64(ip+1)) { 
                     mLength = ZSTD_count(ip+9, matchL3+8, iend) + 8;
                     ip++;
                     offset = (U32)(ip-matchL3);
-                    while (((ip>anchor) & (matchL3>prefixLowest)) && (ip[-1] == matchL3[-1])) { ip--; matchL3--; mLength++; } /* catch up */
-                    goto _match_found;
+                    while (((ip>anchor) & (matchL3>prefixLowest)) && (ip[-1] == matchL3[-1])) { ip--; matchL3--; mLength++; } /* catch up */ 
+                    goto _match_found; 
                 }
             } else {
-                /* check dict long +1 match */
-                U32 const dictMatchIndexL3 = dictHashLong[dictHLNext];
-                const BYTE* dictMatchL3 = dictBase + dictMatchIndexL3;
-                assert(dictMatchL3 < dictEnd);
-                if (dictMatchL3 > dictStart && MEM_read64(dictMatchL3) == MEM_read64(ip+1)) {
-                    mLength = ZSTD_count_2segments(ip+1+8, dictMatchL3+8, iend, dictEnd, prefixLowest) + 8;
-                    ip++;
+                /* check dict long +1 match */ 
+                U32 const dictMatchIndexL3 = dictHashLong[dictHLNext]; 
+                const BYTE* dictMatchL3 = dictBase + dictMatchIndexL3; 
+                assert(dictMatchL3 < dictEnd); 
+                if (dictMatchL3 > dictStart && MEM_read64(dictMatchL3) == MEM_read64(ip+1)) { 
+                    mLength = ZSTD_count_2segments(ip+1+8, dictMatchL3+8, iend, dictEnd, prefixLowest) + 8; 
+                    ip++; 
                     offset = (U32)(curr + 1 - dictMatchIndexL3 - dictIndexDelta);
-                    while (((ip>anchor) & (dictMatchL3>dictStart)) && (ip[-1] == dictMatchL3[-1])) { ip--; dictMatchL3--; mLength++; } /* catch up */
-                    goto _match_found;
+                    while (((ip>anchor) & (dictMatchL3>dictStart)) && (ip[-1] == dictMatchL3[-1])) { ip--; dictMatchL3--; mLength++; } /* catch up */ 
+                    goto _match_found; 
         }   }   }
 
-        /* if no long +1 match, explore the short match we found */
+        /* if no long +1 match, explore the short match we found */ 
         if (matchIndexS < prefixLowestIndex) {
-            mLength = ZSTD_count_2segments(ip+4, match+4, iend, dictEnd, prefixLowest) + 4;
+            mLength = ZSTD_count_2segments(ip+4, match+4, iend, dictEnd, prefixLowest) + 4; 
             offset = (U32)(curr - matchIndexS);
-            while (((ip>anchor) & (match>dictStart)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
-        } else {
-            mLength = ZSTD_count(ip+4, match+4, iend) + 4;
-            offset = (U32)(ip - match);
-            while (((ip>anchor) & (match>prefixLowest)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */
+            while (((ip>anchor) & (match>dictStart)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */ 
+        } else { 
+            mLength = ZSTD_count(ip+4, match+4, iend) + 4; 
+            offset = (U32)(ip - match); 
+            while (((ip>anchor) & (match>prefixLowest)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */ 
         }
 
-_match_found:
-        offset_2 = offset_1;
-        offset_1 = offset;
-
+_match_found: 
+        offset_2 = offset_1; 
+        offset_1 = offset; 
+ 
         ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, STORE_OFFSET(offset), mLength);
-
-_match_stored:
+ 
+_match_stored: 
         /* match found */
         ip += mLength;
         anchor = ip;
@@ -452,14 +452,14 @@ _match_stored:
                     hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = current2;
                     hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = current2;
                     ip += repLength2;
-                    anchor = ip;
+                    anchor = ip; 
                     continue;
                 }
                 break;
             }
         }
     }   /* while (ip < ilimit) */
-
+ 
     /* save reps for next block */
     rep[0] = offset_1 ? offset_1 : offsetSaved;
     rep[1] = offset_2 ? offset_2 : offsetSaved;
@@ -489,9 +489,9 @@ ZSTD_GEN_DFAST_FN(dictMatchState, 7)
 
 size_t ZSTD_compressBlock_doubleFast(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
+        void const* src, size_t srcSize) 
 {
-    const U32 mls = ms->cParams.minMatch;
+    const U32 mls = ms->cParams.minMatch; 
     switch(mls)
     {
     default: /* includes case 3 */
@@ -507,32 +507,32 @@ size_t ZSTD_compressBlock_doubleFast(
 }
 
 
-size_t ZSTD_compressBlock_doubleFast_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize)
-{
-    const U32 mls = ms->cParams.minMatch;
-    switch(mls)
-    {
-    default: /* includes case 3 */
-    case 4 :
+size_t ZSTD_compressBlock_doubleFast_dictMatchState( 
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+        void const* src, size_t srcSize) 
+{ 
+    const U32 mls = ms->cParams.minMatch; 
+    switch(mls) 
+    { 
+    default: /* includes case 3 */ 
+    case 4 : 
         return ZSTD_compressBlock_doubleFast_dictMatchState_4(ms, seqStore, rep, src, srcSize);
-    case 5 :
+    case 5 : 
         return ZSTD_compressBlock_doubleFast_dictMatchState_5(ms, seqStore, rep, src, srcSize);
-    case 6 :
+    case 6 : 
         return ZSTD_compressBlock_doubleFast_dictMatchState_6(ms, seqStore, rep, src, srcSize);
-    case 7 :
+    case 7 : 
         return ZSTD_compressBlock_doubleFast_dictMatchState_7(ms, seqStore, rep, src, srcSize);
-    }
-}
-
-
+    } 
+} 
+ 
+ 
 static size_t ZSTD_compressBlock_doubleFast_extDict_generic(
         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 /* template */)
 {
-    ZSTD_compressionParameters const* cParams = &ms->cParams;
+    ZSTD_compressionParameters const* cParams = &ms->cParams; 
     U32* const hashLong = ms->hashTable;
     U32  const hBitsL = cParams->hashLog;
     U32* const hashSmall = ms->chainTable;
@@ -542,20 +542,20 @@ static size_t ZSTD_compressBlock_doubleFast_extDict_generic(
     const BYTE* anchor = istart;
     const BYTE* const iend = istart + srcSize;
     const BYTE* const ilimit = iend - 8;
-    const BYTE* const base = ms->window.base;
+    const BYTE* const base = ms->window.base; 
     const U32   endIndex = (U32)((size_t)(istart - base) + srcSize);
     const U32   lowLimit = ZSTD_getLowestMatchIndex(ms, endIndex, cParams->windowLog);
     const U32   dictStartIndex = lowLimit;
     const U32   dictLimit = ms->window.dictLimit;
     const U32   prefixStartIndex = (dictLimit > lowLimit) ? dictLimit : lowLimit;
-    const BYTE* const prefixStart = base + prefixStartIndex;
-    const BYTE* const dictBase = ms->window.dictBase;
-    const BYTE* const dictStart = dictBase + dictStartIndex;
-    const BYTE* const dictEnd = dictBase + prefixStartIndex;
+    const BYTE* const prefixStart = base + prefixStartIndex; 
+    const BYTE* const dictBase = ms->window.dictBase; 
+    const BYTE* const dictStart = dictBase + dictStartIndex; 
+    const BYTE* const dictEnd = dictBase + prefixStartIndex; 
     U32 offset_1=rep[0], offset_2=rep[1];
 
-    DEBUGLOG(5, "ZSTD_compressBlock_doubleFast_extDict_generic (srcSize=%zu)", srcSize);
-
+    DEBUGLOG(5, "ZSTD_compressBlock_doubleFast_extDict_generic (srcSize=%zu)", srcSize); 
+ 
     /* if extDict is invalidated due to maxDistance, switch to "regular" variant */
     if (prefixStartIndex == dictStartIndex)
         return ZSTD_compressBlock_doubleFast(ms, seqStore, rep, src, srcSize);
@@ -564,58 +564,58 @@ static size_t ZSTD_compressBlock_doubleFast_extDict_generic(
     while (ip < ilimit) {  /* < instead of <=, because (ip+1) */
         const size_t hSmall = ZSTD_hashPtr(ip, hBitsS, mls);
         const U32 matchIndex = hashSmall[hSmall];
-        const BYTE* const matchBase = matchIndex < prefixStartIndex ? dictBase : base;
+        const BYTE* const matchBase = matchIndex < prefixStartIndex ? dictBase : base; 
         const BYTE* match = matchBase + matchIndex;
 
         const size_t hLong = ZSTD_hashPtr(ip, hBitsL, 8);
         const U32 matchLongIndex = hashLong[hLong];
-        const BYTE* const matchLongBase = matchLongIndex < prefixStartIndex ? dictBase : base;
+        const BYTE* const matchLongBase = matchLongIndex < prefixStartIndex ? dictBase : base; 
         const BYTE* matchLong = matchLongBase + matchLongIndex;
 
         const U32 curr = (U32)(ip-base);
         const U32 repIndex = curr + 1 - offset_1;   /* offset_1 expected <= curr +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; 
         size_t mLength;
         hashSmall[hSmall] = hashLong[hLong] = curr;   /* update hash table */
 
-        if ((((U32)((prefixStartIndex-1) - repIndex) >= 3) /* intentional underflow : ensure repIndex doesn't overlap dict + prefix */
+        if ((((U32)((prefixStartIndex-1) - repIndex) >= 3) /* intentional underflow : ensure repIndex doesn't overlap dict + prefix */ 
             & (offset_1 <= curr+1 - dictStartIndex)) /* note: we are searching at curr+1 */
-          && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
-            const BYTE* repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend;
-            mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixStart) + 4;
+          && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) { 
+            const BYTE* 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 ((matchLongIndex > dictStartIndex) && (MEM_read64(matchLong) == MEM_read64(ip))) {
-                const BYTE* const matchEnd = matchLongIndex < prefixStartIndex ? dictEnd : iend;
-                const BYTE* const lowMatchPtr = matchLongIndex < prefixStartIndex ? dictStart : prefixStart;
+            if ((matchLongIndex > dictStartIndex) && (MEM_read64(matchLong) == MEM_read64(ip))) { 
+                const BYTE* const matchEnd = matchLongIndex < prefixStartIndex ? dictEnd : iend; 
+                const BYTE* const lowMatchPtr = matchLongIndex < prefixStartIndex ? dictStart : prefixStart; 
                 U32 offset;
-                mLength = ZSTD_count_2segments(ip+8, matchLong+8, iend, matchEnd, prefixStart) + 8;
+                mLength = ZSTD_count_2segments(ip+8, matchLong+8, iend, matchEnd, prefixStart) + 8; 
                 offset = curr - matchLongIndex;
                 while (((ip>anchor) & (matchLong>lowMatchPtr)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; 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 ((matchIndex > dictStartIndex) && (MEM_read32(match) == MEM_read32(ip))) {
+            } else if ((matchIndex > dictStartIndex) && (MEM_read32(match) == MEM_read32(ip))) { 
                 size_t const h3 = ZSTD_hashPtr(ip+1, hBitsL, 8);
                 U32 const matchIndex3 = hashLong[h3];
-                const BYTE* const match3Base = matchIndex3 < prefixStartIndex ? dictBase : base;
+                const BYTE* const match3Base = matchIndex3 < prefixStartIndex ? dictBase : base; 
                 const BYTE* match3 = match3Base + matchIndex3;
                 U32 offset;
                 hashLong[h3] = curr + 1;
-                if ( (matchIndex3 > dictStartIndex) && (MEM_read64(match3) == MEM_read64(ip+1)) ) {
-                    const BYTE* const matchEnd = matchIndex3 < prefixStartIndex ? dictEnd : iend;
-                    const BYTE* const lowMatchPtr = matchIndex3 < prefixStartIndex ? dictStart : prefixStart;
-                    mLength = ZSTD_count_2segments(ip+9, match3+8, iend, matchEnd, prefixStart) + 8;
+                if ( (matchIndex3 > dictStartIndex) && (MEM_read64(match3) == MEM_read64(ip+1)) ) { 
+                    const BYTE* const matchEnd = matchIndex3 < prefixStartIndex ? dictEnd : iend; 
+                    const BYTE* const lowMatchPtr = matchIndex3 < prefixStartIndex ? dictStart : prefixStart; 
+                    mLength = ZSTD_count_2segments(ip+9, match3+8, iend, matchEnd, prefixStart) + 8; 
                     ip++;
                     offset = curr+1 - matchIndex3;
                     while (((ip>anchor) & (match3>lowMatchPtr)) && (ip[-1] == match3[-1])) { ip--; match3--; mLength++; } /* catch up */
                 } else {
-                    const BYTE* const matchEnd = matchIndex < prefixStartIndex ? dictEnd : iend;
-                    const BYTE* const lowMatchPtr = matchIndex < prefixStartIndex ? dictStart : prefixStart;
-                    mLength = ZSTD_count_2segments(ip+4, match+4, iend, matchEnd, prefixStart) + 4;
+                    const BYTE* const matchEnd = matchIndex < prefixStartIndex ? dictEnd : iend; 
+                    const BYTE* const lowMatchPtr = matchIndex < prefixStartIndex ? dictStart : prefixStart; 
+                    mLength = ZSTD_count_2segments(ip+4, match+4, iend, matchEnd, prefixStart) + 4; 
                     offset = curr - matchIndex;
                     while (((ip>anchor) & (match>lowMatchPtr)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; }   /* catch up */
                 }
@@ -646,13 +646,13 @@ static size_t ZSTD_compressBlock_doubleFast_extDict_generic(
             while (ip <= ilimit) {
                 U32 const current2 = (U32)(ip-base);
                 U32 const repIndex2 = current2 - offset_2;
-                const BYTE* repMatch2 = repIndex2 < prefixStartIndex ? dictBase + repIndex2 : base + repIndex2;
-                if ( (((U32)((prefixStartIndex-1) - repIndex2) >= 3)   /* intentional overflow : ensure repIndex2 doesn't overlap dict + prefix */
+                const BYTE* repMatch2 = repIndex2 < prefixStartIndex ? dictBase + repIndex2 : base + repIndex2; 
+                if ( (((U32)((prefixStartIndex-1) - repIndex2) >= 3)   /* intentional overflow : ensure repIndex2 doesn't overlap dict + prefix */ 
                     & (offset_2 <= current2 - dictStartIndex))
-                  && (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 const tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */
+                  && (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 const 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);
                     hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = current2;
                     hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = current2;
@@ -678,9 +678,9 @@ ZSTD_GEN_DFAST_FN(extDict, 7)
 
 size_t ZSTD_compressBlock_doubleFast_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;
+    U32 const mls = ms->cParams.minMatch; 
     switch(mls)
     {
     default: /* includes case 3 */
diff --git a/contrib/libs/zstd/lib/compress/zstd_double_fast.h b/contrib/libs/zstd/lib/compress/zstd_double_fast.h
index e16b7b03a32..78c30ad6fa6 100644
--- a/contrib/libs/zstd/lib/compress/zstd_double_fast.h
+++ b/contrib/libs/zstd/lib/compress/zstd_double_fast.h
@@ -19,16 +19,16 @@ extern "C" {
 #include "zstd_compress_internal.h"     /* ZSTD_CCtx, size_t */
 
 void ZSTD_fillDoubleHashTable(ZSTD_matchState_t* ms,
-                              void const* end, ZSTD_dictTableLoadMethod_e dtlm);
+                              void const* end, ZSTD_dictTableLoadMethod_e dtlm); 
 size_t ZSTD_compressBlock_doubleFast(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_doubleFast_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); 
+size_t ZSTD_compressBlock_doubleFast_dictMatchState( 
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+        void const* src, size_t srcSize); 
 size_t ZSTD_compressBlock_doubleFast_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); 
 
 
 #if defined (__cplusplus)
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)
diff --git a/contrib/libs/zstd/lib/compress/zstd_fast.h b/contrib/libs/zstd/lib/compress/zstd_fast.h
index 0d4a0c1090f..7fde45bdcd8 100644
--- a/contrib/libs/zstd/lib/compress/zstd_fast.h
+++ b/contrib/libs/zstd/lib/compress/zstd_fast.h
@@ -19,16 +19,16 @@ extern "C" {
 #include "zstd_compress_internal.h"
 
 void ZSTD_fillHashTable(ZSTD_matchState_t* ms,
-                        void const* end, ZSTD_dictTableLoadMethod_e dtlm);
+                        void const* end, ZSTD_dictTableLoadMethod_e dtlm); 
 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_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); 
+size_t ZSTD_compressBlock_fast_dictMatchState( 
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+        void const* src, size_t srcSize); 
 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); 
 
 #if defined (__cplusplus)
 }
diff --git a/contrib/libs/zstd/lib/compress/zstd_lazy.c b/contrib/libs/zstd/lib/compress/zstd_lazy.c
index 2e38dcb46d2..cc614c3a26e 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);
diff --git a/contrib/libs/zstd/lib/compress/zstd_lazy.h b/contrib/libs/zstd/lib/compress/zstd_lazy.h
index 150f7b390b8..6c7ee3262ac 100644
--- a/contrib/libs/zstd/lib/compress/zstd_lazy.h
+++ b/contrib/libs/zstd/lib/compress/zstd_lazy.h
@@ -25,25 +25,25 @@ extern "C" {
  */
 #define ZSTD_LAZY_DDSS_BUCKET_LOG 2
 
-U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip);
+U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip); 
 void ZSTD_row_update(ZSTD_matchState_t* const ms, const BYTE* ip);
 
 void ZSTD_dedicatedDictSearch_lazy_loadDictionary(ZSTD_matchState_t* ms, const BYTE* const ip);
 
-void ZSTD_preserveUnsortedMark (U32* const table, U32 const size, U32 const reducerValue);  /*! used in ZSTD_reduceIndex(). preemptively increase value of ZSTD_DUBT_UNSORTED_MARK */
+void ZSTD_preserveUnsortedMark (U32* const table, U32 const size, U32 const reducerValue);  /*! used in ZSTD_reduceIndex(). preemptively increase value of ZSTD_DUBT_UNSORTED_MARK */ 
 
 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); 
 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); 
 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); 
 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); 
 size_t ZSTD_compressBlock_lazy2_row(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         void const* src, size_t srcSize);
@@ -54,18 +54,18 @@ size_t ZSTD_compressBlock_greedy_row(
         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);
-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_lazy_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);
+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_lazy2_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); 
+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_lazy2_dictMatchState_row(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         void const* src, size_t srcSize);
@@ -75,7 +75,7 @@ size_t ZSTD_compressBlock_lazy_dictMatchState_row(
 size_t ZSTD_compressBlock_greedy_dictMatchState_row(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         void const* src, size_t srcSize);
-
+ 
 size_t ZSTD_compressBlock_lazy2_dedicatedDictSearch(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         void const* src, size_t srcSize);
@@ -97,13 +97,13 @@ size_t ZSTD_compressBlock_greedy_dedicatedDictSearch_row(
 
 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); 
 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); 
 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); 
 size_t ZSTD_compressBlock_greedy_extDict_row(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         void const* src, size_t srcSize);
@@ -115,7 +115,7 @@ size_t ZSTD_compressBlock_lazy2_extDict_row(
         void const* src, size_t srcSize);
 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); 
         
 
 #if defined (__cplusplus)
diff --git a/contrib/libs/zstd/lib/compress/zstd_ldm.c b/contrib/libs/zstd/lib/compress/zstd_ldm.c
index 476b45746e0..d2084fc5d52 100644
--- a/contrib/libs/zstd/lib/compress/zstd_ldm.c
+++ b/contrib/libs/zstd/lib/compress/zstd_ldm.c
@@ -135,19 +135,19 @@ done:
 void ZSTD_ldm_adjustParameters(ldmParams_t* params,
                                ZSTD_compressionParameters const* cParams)
 {
-    params->windowLog = cParams->windowLog;
+    params->windowLog = cParams->windowLog; 
     ZSTD_STATIC_ASSERT(LDM_BUCKET_SIZE_LOG <= ZSTD_LDM_BUCKETSIZELOG_MAX);
     DEBUGLOG(4, "ZSTD_ldm_adjustParameters");
     if (!params->bucketSizeLog) params->bucketSizeLog = LDM_BUCKET_SIZE_LOG;
     if (!params->minMatchLength) params->minMatchLength = LDM_MIN_MATCH_LENGTH;
     if (params->hashLog == 0) {
-        params->hashLog = MAX(ZSTD_HASHLOG_MIN, params->windowLog - LDM_HASH_RLOG);
+        params->hashLog = MAX(ZSTD_HASHLOG_MIN, params->windowLog - LDM_HASH_RLOG); 
         assert(params->hashLog <= ZSTD_HASHLOG_MAX);
     }
-    if (params->hashRateLog == 0) {
-        params->hashRateLog = params->windowLog < params->hashLog
-                                   ? 0
-                                   : params->windowLog - params->hashLog;
+    if (params->hashRateLog == 0) { 
+        params->hashRateLog = params->windowLog < params->hashLog 
+                                   ? 0 
+                                   : params->windowLog - params->hashLog; 
     }
     params->bucketSizeLog = MIN(params->bucketSizeLog, params->hashLog);
 }
@@ -239,14 +239,14 @@ static size_t ZSTD_ldm_fillFastTables(ZSTD_matchState_t* ms,
 {
     const BYTE* const iend = (const BYTE*)end;
 
-    switch(ms->cParams.strategy)
+    switch(ms->cParams.strategy) 
     {
     case ZSTD_fast:
-        ZSTD_fillHashTable(ms, iend, ZSTD_dtlm_fast);
+        ZSTD_fillHashTable(ms, iend, ZSTD_dtlm_fast); 
         break;
 
     case ZSTD_dfast:
-        ZSTD_fillDoubleHashTable(ms, iend, ZSTD_dtlm_fast);
+        ZSTD_fillDoubleHashTable(ms, iend, ZSTD_dtlm_fast); 
         break;
 
     case ZSTD_greedy:
@@ -255,7 +255,7 @@ static size_t ZSTD_ldm_fillFastTables(ZSTD_matchState_t* ms,
     case ZSTD_btlazy2:
     case ZSTD_btopt:
     case ZSTD_btultra:
-    case ZSTD_btultra2:
+    case ZSTD_btultra2: 
         break;
     default:
         assert(0);  /* not possible : not a valid strategy id */
@@ -520,7 +520,7 @@ size_t ZSTD_ldm_generateSequences(
      */
     assert(ldmState->window.nextSrc >= (BYTE const*)src + srcSize);
     /* The input could be very large (in zstdmt), so it must be broken up into
-     * chunks to enforce the maximum distance and handle overflow correction.
+     * chunks to enforce the maximum distance and handle overflow correction. 
      */
     assert(sequences->pos <= sequences->size);
     assert(sequences->size <= sequences->capacity);
@@ -660,10 +660,10 @@ void ZSTD_ldm_skipRawSeqStoreBytes(rawSeqStore_t* rawSeqStore, size_t nbBytes) {
 size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
     ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
     ZSTD_paramSwitch_e useRowMatchFinder,
-    void const* src, size_t srcSize)
+    void const* src, size_t srcSize) 
 {
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    unsigned const minMatch = cParams->minMatch;
+    const ZSTD_compressionParameters* const cParams = &ms->cParams; 
+    unsigned const minMatch = cParams->minMatch; 
     ZSTD_blockCompressor const blockCompressor =
         ZSTD_selectBlockCompressor(cParams->strategy, useRowMatchFinder, ZSTD_matchState_dictMode(ms));
     /* Input bounds */
@@ -672,7 +672,7 @@ size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
     /* Input positions */
     BYTE const* ip = istart;
 
-    DEBUGLOG(5, "ZSTD_ldm_blockCompress: srcSize=%zu", srcSize);
+    DEBUGLOG(5, "ZSTD_ldm_blockCompress: srcSize=%zu", srcSize); 
     /* If using opt parser, use LDMs only as candidates rather than always accepting them */
     if (cParams->strategy >= ZSTD_btopt) {
         size_t lastLLSize;
@@ -698,12 +698,12 @@ size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
 
         /* Fill tables for block compressor */
         ZSTD_ldm_limitTableUpdate(ms, ip);
-        ZSTD_ldm_fillFastTables(ms, ip);
+        ZSTD_ldm_fillFastTables(ms, ip); 
         /* Run the block compressor */
         DEBUGLOG(5, "pos %u : calling block compressor on segment of size %u", (unsigned)(ip-istart), sequence.litLength);
         {
             size_t const newLitLength =
-                blockCompressor(ms, seqStore, rep, ip, sequence.litLength);
+                blockCompressor(ms, seqStore, rep, ip, sequence.litLength); 
             ip += sequence.litLength;
             /* Update the repcodes */
             for (i = ZSTD_REP_NUM - 1; i > 0; i--)
@@ -718,7 +718,7 @@ size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
     }
     /* Fill the tables for the block compressor */
     ZSTD_ldm_limitTableUpdate(ms, ip);
-    ZSTD_ldm_fillFastTables(ms, ip);
+    ZSTD_ldm_fillFastTables(ms, ip); 
     /* Compress the last literals */
-    return blockCompressor(ms, seqStore, rep, ip, iend - ip);
+    return blockCompressor(ms, seqStore, rep, ip, iend - ip); 
 }
diff --git a/contrib/libs/zstd/lib/compress/zstd_ldm.h b/contrib/libs/zstd/lib/compress/zstd_ldm.h
index 4e68dbf52e3..9d48aafb48e 100644
--- a/contrib/libs/zstd/lib/compress/zstd_ldm.h
+++ b/contrib/libs/zstd/lib/compress/zstd_ldm.h
@@ -22,7 +22,7 @@ extern "C" {
 *  Long distance matching
 ***************************************/
 
-#define ZSTD_LDM_DEFAULT_WINDOW_LOG ZSTD_WINDOWLOG_LIMIT_DEFAULT
+#define ZSTD_LDM_DEFAULT_WINDOW_LOG ZSTD_WINDOWLOG_LIMIT_DEFAULT 
 
 void ZSTD_ldm_fillHashTable(
             ldmState_t* state, const BYTE* ip,
@@ -67,7 +67,7 @@ size_t ZSTD_ldm_generateSequences(
 size_t ZSTD_ldm_blockCompress(rawSeqStore_t* rawSeqStore,
             ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
             ZSTD_paramSwitch_e useRowMatchFinder,
-            void const* src, size_t srcSize);
+            void const* src, size_t srcSize); 
 
 /**
  * ZSTD_ldm_skipSequences():
@@ -99,7 +99,7 @@ size_t ZSTD_ldm_getTableSize(ldmParams_t params);
 size_t ZSTD_ldm_getMaxNbSeq(ldmParams_t params, size_t maxChunkSize);
 
 /** ZSTD_ldm_adjustParameters() :
- *  If the params->hashRateLog is not set, set it to its default value based on
+ *  If the params->hashRateLog is not set, set it to its default value based on 
  *  windowLog and params->hashLog.
  *
  *  Ensures that params->bucketSizeLog is <= params->hashLog (setting it to
diff --git a/contrib/libs/zstd/lib/compress/zstd_opt.c b/contrib/libs/zstd/lib/compress/zstd_opt.c
index 1b1ddad4289..1216ecd879f 100644
--- a/contrib/libs/zstd/lib/compress/zstd_opt.c
+++ b/contrib/libs/zstd/lib/compress/zstd_opt.c
@@ -9,77 +9,77 @@
  */
 
 #include "zstd_compress_internal.h"
-#include "hist.h"
+#include "hist.h" 
 #include "zstd_opt.h"
 
 
-#define ZSTD_LITFREQ_ADD    2   /* scaling factor for litFreq, so that frequencies adapt faster to new stats */
+#define ZSTD_LITFREQ_ADD    2   /* scaling factor for litFreq, so that frequencies adapt faster to new stats */ 
 #define ZSTD_MAX_PRICE     (1<<30)
 
-#define ZSTD_PREDEF_THRESHOLD 1024   /* if srcSize < ZSTD_PREDEF_THRESHOLD, symbols' cost is assumed static, directly determined by pre-defined distributions */
-
+#define ZSTD_PREDEF_THRESHOLD 1024   /* if srcSize < ZSTD_PREDEF_THRESHOLD, symbols' cost is assumed static, directly determined by pre-defined distributions */ 
 
+ 
 /*-*************************************
 *  Price functions for optimal parser
 ***************************************/
-
+ 
 #if 0    /* approximation at bit level (for tests) */
-#  define BITCOST_ACCURACY 0
-#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)
+#  define BITCOST_ACCURACY 0 
+#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY) 
 #  define WEIGHT(stat, opt) ((void)opt, ZSTD_bitWeight(stat))
 #elif 0  /* fractional bit accuracy (for tests) */
-#  define BITCOST_ACCURACY 8
-#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)
-#  define WEIGHT(stat,opt) ((void)opt, ZSTD_fracWeight(stat))
-#else    /* opt==approx, ultra==accurate */
-#  define BITCOST_ACCURACY 8
-#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)
-#  define WEIGHT(stat,opt) (opt ? ZSTD_fracWeight(stat) : ZSTD_bitWeight(stat))
-#endif
-
-MEM_STATIC U32 ZSTD_bitWeight(U32 stat)
-{
-    return (ZSTD_highbit32(stat+1) * BITCOST_MULTIPLIER);
-}
-
-MEM_STATIC U32 ZSTD_fracWeight(U32 rawStat)
+#  define BITCOST_ACCURACY 8 
+#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY) 
+#  define WEIGHT(stat,opt) ((void)opt, ZSTD_fracWeight(stat)) 
+#else    /* opt==approx, ultra==accurate */ 
+#  define BITCOST_ACCURACY 8 
+#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY) 
+#  define WEIGHT(stat,opt) (opt ? ZSTD_fracWeight(stat) : ZSTD_bitWeight(stat)) 
+#endif 
+ 
+MEM_STATIC U32 ZSTD_bitWeight(U32 stat) 
 {
-    U32 const stat = rawStat + 1;
-    U32 const hb = ZSTD_highbit32(stat);
-    U32 const BWeight = hb * BITCOST_MULTIPLIER;
-    U32 const FWeight = (stat << BITCOST_ACCURACY) >> hb;
-    U32 const weight = BWeight + FWeight;
-    assert(hb + BITCOST_ACCURACY < 31);
-    return weight;
+    return (ZSTD_highbit32(stat+1) * BITCOST_MULTIPLIER); 
 }
 
-#if (DEBUGLEVEL>=2)
-/* debugging function,
- * @return price in bytes as fractional value
- * for debug messages only */
-MEM_STATIC double ZSTD_fCost(U32 price)
+MEM_STATIC U32 ZSTD_fracWeight(U32 rawStat) 
+{ 
+    U32 const stat = rawStat + 1; 
+    U32 const hb = ZSTD_highbit32(stat); 
+    U32 const BWeight = hb * BITCOST_MULTIPLIER; 
+    U32 const FWeight = (stat << BITCOST_ACCURACY) >> hb; 
+    U32 const weight = BWeight + FWeight; 
+    assert(hb + BITCOST_ACCURACY < 31); 
+    return weight; 
+} 
+
+#if (DEBUGLEVEL>=2) 
+/* debugging function, 
+ * @return price in bytes as fractional value 
+ * for debug messages only */ 
+MEM_STATIC double ZSTD_fCost(U32 price) 
 {
-    return (double)price / (BITCOST_MULTIPLIER*8);
-}
-#endif
+    return (double)price / (BITCOST_MULTIPLIER*8); 
+} 
+#endif 
 
-static int ZSTD_compressedLiterals(optState_t const* const optPtr)
-{
+static int ZSTD_compressedLiterals(optState_t const* const optPtr) 
+{ 
     return optPtr->literalCompressionMode != ZSTD_ps_disable;
-}
-
-static void ZSTD_setBasePrices(optState_t* optPtr, int optLevel)
-{
-    if (ZSTD_compressedLiterals(optPtr))
-        optPtr->litSumBasePrice = WEIGHT(optPtr->litSum, optLevel);
-    optPtr->litLengthSumBasePrice = WEIGHT(optPtr->litLengthSum, optLevel);
-    optPtr->matchLengthSumBasePrice = WEIGHT(optPtr->matchLengthSum, optLevel);
-    optPtr->offCodeSumBasePrice = WEIGHT(optPtr->offCodeSum, optLevel);
-}
-
-
+} 
+
+static void ZSTD_setBasePrices(optState_t* optPtr, int optLevel) 
+{ 
+    if (ZSTD_compressedLiterals(optPtr)) 
+        optPtr->litSumBasePrice = WEIGHT(optPtr->litSum, optLevel); 
+    optPtr->litLengthSumBasePrice = WEIGHT(optPtr->litLengthSum, optLevel); 
+    optPtr->matchLengthSumBasePrice = WEIGHT(optPtr->matchLengthSum, optLevel); 
+    optPtr->offCodeSumBasePrice = WEIGHT(optPtr->offCodeSum, optLevel); 
+} 
+ 
+ 
 static U32 sum_u32(const unsigned table[], size_t nbElts)
-{
+{ 
     size_t n;
     U32 total = 0;
     for (n=0; n<nbElts; n++) {
@@ -90,16 +90,16 @@ static U32 sum_u32(const unsigned table[], size_t nbElts)
 
 static U32 ZSTD_downscaleStats(unsigned* table, U32 lastEltIndex, U32 shift)
 {
-    U32 s, sum=0;
+    U32 s, sum=0; 
     DEBUGLOG(5, "ZSTD_downscaleStats (nbElts=%u, shift=%u)", (unsigned)lastEltIndex+1, (unsigned)shift);
     assert(shift < 30);
-    for (s=0; s<lastEltIndex+1; s++) {
+    for (s=0; s<lastEltIndex+1; s++) { 
         table[s] = 1 + (table[s] >> shift);
-        sum += table[s];
-    }
-    return sum;
-}
-
+        sum += table[s]; 
+    } 
+    return sum; 
+} 
+ 
 /* ZSTD_scaleStats() :
  * reduce all elements in table is sum too large
  * return the resulting sum of elements */
@@ -113,90 +113,90 @@ static U32 ZSTD_scaleStats(unsigned* table, U32 lastEltIndex, U32 logTarget)
     return ZSTD_downscaleStats(table, lastEltIndex, ZSTD_highbit32(factor));
 }
 
-/* ZSTD_rescaleFreqs() :
- * if first block (detected by optPtr->litLengthSum == 0) : init statistics
- *    take hints from dictionary if there is one
+/* ZSTD_rescaleFreqs() : 
+ * if first block (detected by optPtr->litLengthSum == 0) : init statistics 
+ *    take hints from dictionary if there is one 
  *    and init from zero if there is none,
  *    using src for literals stats, and baseline stats for sequence symbols
- * otherwise downscale existing stats, to be used as seed for next block.
- */
-static void
-ZSTD_rescaleFreqs(optState_t* const optPtr,
-            const BYTE* const src, size_t const srcSize,
-                  int const optLevel)
-{
-    int const compressedLiterals = ZSTD_compressedLiterals(optPtr);
-    DEBUGLOG(5, "ZSTD_rescaleFreqs (srcSize=%u)", (unsigned)srcSize);
-    optPtr->priceType = zop_dynamic;
-
-    if (optPtr->litLengthSum == 0) {  /* first block : init */
-        if (srcSize <= ZSTD_PREDEF_THRESHOLD) {  /* heuristic */
-            DEBUGLOG(5, "(srcSize <= ZSTD_PREDEF_THRESHOLD) => zop_predef");
-            optPtr->priceType = zop_predef;
+ * otherwise downscale existing stats, to be used as seed for next block. 
+ */ 
+static void 
+ZSTD_rescaleFreqs(optState_t* const optPtr, 
+            const BYTE* const src, size_t const srcSize, 
+                  int const optLevel) 
+{ 
+    int const compressedLiterals = ZSTD_compressedLiterals(optPtr); 
+    DEBUGLOG(5, "ZSTD_rescaleFreqs (srcSize=%u)", (unsigned)srcSize); 
+    optPtr->priceType = zop_dynamic; 
+ 
+    if (optPtr->litLengthSum == 0) {  /* first block : init */ 
+        if (srcSize <= ZSTD_PREDEF_THRESHOLD) {  /* heuristic */ 
+            DEBUGLOG(5, "(srcSize <= ZSTD_PREDEF_THRESHOLD) => zop_predef"); 
+            optPtr->priceType = zop_predef; 
         }
 
-        assert(optPtr->symbolCosts != NULL);
-        if (optPtr->symbolCosts->huf.repeatMode == HUF_repeat_valid) {
-            /* huffman table presumed generated by dictionary */
-            optPtr->priceType = zop_dynamic;
-
-            if (compressedLiterals) {
-                unsigned lit;
-                assert(optPtr->litFreq != NULL);
-                optPtr->litSum = 0;
-                for (lit=0; lit<=MaxLit; lit++) {
-                    U32 const scaleLog = 11;   /* scale to 2K */
+        assert(optPtr->symbolCosts != NULL); 
+        if (optPtr->symbolCosts->huf.repeatMode == HUF_repeat_valid) { 
+            /* huffman table presumed generated by dictionary */ 
+            optPtr->priceType = zop_dynamic; 
+
+            if (compressedLiterals) { 
+                unsigned lit; 
+                assert(optPtr->litFreq != NULL); 
+                optPtr->litSum = 0; 
+                for (lit=0; lit<=MaxLit; lit++) { 
+                    U32 const scaleLog = 11;   /* scale to 2K */ 
                     U32 const bitCost = HUF_getNbBitsFromCTable(optPtr->symbolCosts->huf.CTable, lit);
-                    assert(bitCost <= scaleLog);
-                    optPtr->litFreq[lit] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;
-                    optPtr->litSum += optPtr->litFreq[lit];
-            }   }
-
-            {   unsigned ll;
-                FSE_CState_t llstate;
-                FSE_initCState(&llstate, optPtr->symbolCosts->fse.litlengthCTable);
-                optPtr->litLengthSum = 0;
-                for (ll=0; ll<=MaxLL; ll++) {
-                    U32 const scaleLog = 10;   /* scale to 1K */
-                    U32 const bitCost = FSE_getMaxNbBits(llstate.symbolTT, ll);
-                    assert(bitCost < scaleLog);
-                    optPtr->litLengthFreq[ll] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;
-                    optPtr->litLengthSum += optPtr->litLengthFreq[ll];
-            }   }
-
-            {   unsigned ml;
-                FSE_CState_t mlstate;
-                FSE_initCState(&mlstate, optPtr->symbolCosts->fse.matchlengthCTable);
-                optPtr->matchLengthSum = 0;
-                for (ml=0; ml<=MaxML; ml++) {
-                    U32 const scaleLog = 10;
-                    U32 const bitCost = FSE_getMaxNbBits(mlstate.symbolTT, ml);
-                    assert(bitCost < scaleLog);
-                    optPtr->matchLengthFreq[ml] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;
-                    optPtr->matchLengthSum += optPtr->matchLengthFreq[ml];
-            }   }
-
-            {   unsigned of;
-                FSE_CState_t ofstate;
-                FSE_initCState(&ofstate, optPtr->symbolCosts->fse.offcodeCTable);
-                optPtr->offCodeSum = 0;
-                for (of=0; of<=MaxOff; of++) {
-                    U32 const scaleLog = 10;
-                    U32 const bitCost = FSE_getMaxNbBits(ofstate.symbolTT, of);
-                    assert(bitCost < scaleLog);
-                    optPtr->offCodeFreq[of] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;
-                    optPtr->offCodeSum += optPtr->offCodeFreq[of];
-            }   }
-
-        } else {  /* not a dictionary */
-
-            assert(optPtr->litFreq != NULL);
-            if (compressedLiterals) {
-                unsigned lit = MaxLit;
-                HIST_count_simple(optPtr->litFreq, &lit, src, srcSize);   /* use raw first block to init statistics */
+                    assert(bitCost <= scaleLog); 
+                    optPtr->litFreq[lit] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/; 
+                    optPtr->litSum += optPtr->litFreq[lit]; 
+            }   } 
+
+            {   unsigned ll; 
+                FSE_CState_t llstate; 
+                FSE_initCState(&llstate, optPtr->symbolCosts->fse.litlengthCTable); 
+                optPtr->litLengthSum = 0; 
+                for (ll=0; ll<=MaxLL; ll++) { 
+                    U32 const scaleLog = 10;   /* scale to 1K */ 
+                    U32 const bitCost = FSE_getMaxNbBits(llstate.symbolTT, ll); 
+                    assert(bitCost < scaleLog); 
+                    optPtr->litLengthFreq[ll] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/; 
+                    optPtr->litLengthSum += optPtr->litLengthFreq[ll]; 
+            }   } 
+ 
+            {   unsigned ml; 
+                FSE_CState_t mlstate; 
+                FSE_initCState(&mlstate, optPtr->symbolCosts->fse.matchlengthCTable); 
+                optPtr->matchLengthSum = 0; 
+                for (ml=0; ml<=MaxML; ml++) { 
+                    U32 const scaleLog = 10; 
+                    U32 const bitCost = FSE_getMaxNbBits(mlstate.symbolTT, ml); 
+                    assert(bitCost < scaleLog); 
+                    optPtr->matchLengthFreq[ml] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/; 
+                    optPtr->matchLengthSum += optPtr->matchLengthFreq[ml]; 
+            }   } 
+ 
+            {   unsigned of; 
+                FSE_CState_t ofstate; 
+                FSE_initCState(&ofstate, optPtr->symbolCosts->fse.offcodeCTable); 
+                optPtr->offCodeSum = 0; 
+                for (of=0; of<=MaxOff; of++) { 
+                    U32 const scaleLog = 10; 
+                    U32 const bitCost = FSE_getMaxNbBits(ofstate.symbolTT, of); 
+                    assert(bitCost < scaleLog); 
+                    optPtr->offCodeFreq[of] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/; 
+                    optPtr->offCodeSum += optPtr->offCodeFreq[of]; 
+            }   } 
+ 
+        } else {  /* not a dictionary */ 
+ 
+            assert(optPtr->litFreq != NULL); 
+            if (compressedLiterals) { 
+                unsigned lit = MaxLit; 
+                HIST_count_simple(optPtr->litFreq, &lit, src, srcSize);   /* use raw first block to init statistics */ 
                 optPtr->litSum = ZSTD_downscaleStats(optPtr->litFreq, MaxLit, 8);
-            }
-
+            } 
+ 
             {   unsigned const baseLLfreqs[MaxLL+1] = {
                     4, 2, 1, 1, 1, 1, 1, 1,
                     1, 1, 1, 1, 1, 1, 1, 1,
@@ -206,14 +206,14 @@ ZSTD_rescaleFreqs(optState_t* const optPtr,
                 };
                 ZSTD_memcpy(optPtr->litLengthFreq, baseLLfreqs, sizeof(baseLLfreqs));
                 optPtr->litLengthSum = sum_u32(baseLLfreqs, MaxLL+1);
-            }
-
-            {   unsigned ml;
-                for (ml=0; ml<=MaxML; ml++)
-                    optPtr->matchLengthFreq[ml] = 1;
-            }
-            optPtr->matchLengthSum = MaxML+1;
-
+            } 
+ 
+            {   unsigned ml; 
+                for (ml=0; ml<=MaxML; ml++) 
+                    optPtr->matchLengthFreq[ml] = 1; 
+            } 
+            optPtr->matchLengthSum = MaxML+1; 
+ 
             {   unsigned const baseOFCfreqs[MaxOff+1] = {
                     6, 2, 1, 1, 2, 3, 4, 4,
                     4, 3, 2, 1, 1, 1, 1, 1,
@@ -222,52 +222,52 @@ ZSTD_rescaleFreqs(optState_t* const optPtr,
                 };
                 ZSTD_memcpy(optPtr->offCodeFreq, baseOFCfreqs, sizeof(baseOFCfreqs));
                 optPtr->offCodeSum = sum_u32(baseOFCfreqs, MaxOff+1);
-            }
-
+            } 
+ 
 
         }
-
-    } else {   /* new block : re-use previous statistics, scaled down */
-
-        if (compressedLiterals)
+ 
+    } else {   /* new block : re-use previous statistics, scaled down */ 
+ 
+        if (compressedLiterals) 
             optPtr->litSum = ZSTD_scaleStats(optPtr->litFreq, MaxLit, 12);
         optPtr->litLengthSum = ZSTD_scaleStats(optPtr->litLengthFreq, MaxLL, 11);
         optPtr->matchLengthSum = ZSTD_scaleStats(optPtr->matchLengthFreq, MaxML, 11);
         optPtr->offCodeSum = ZSTD_scaleStats(optPtr->offCodeFreq, MaxOff, 11);
     }
 
-    ZSTD_setBasePrices(optPtr, optLevel);
+    ZSTD_setBasePrices(optPtr, optLevel); 
 }
 
 /* ZSTD_rawLiteralsCost() :
- * price of literals (only) in specified segment (which length can be 0).
- * does not include price of literalLength symbol */
+ * price of literals (only) in specified segment (which length can be 0). 
+ * does not include price of literalLength symbol */ 
 static U32 ZSTD_rawLiteralsCost(const BYTE* const literals, U32 const litLength,
-                                const optState_t* const optPtr,
-                                int optLevel)
+                                const optState_t* const optPtr, 
+                                int optLevel) 
 {
     if (litLength == 0) return 0;
 
-    if (!ZSTD_compressedLiterals(optPtr))
-        return (litLength << 3) * BITCOST_MULTIPLIER;  /* Uncompressed - 8 bytes per literal. */
-
-    if (optPtr->priceType == zop_predef)
-        return (litLength*6) * BITCOST_MULTIPLIER;  /* 6 bit per literal - no statistic used */
-
-    /* dynamic statistics */
-    {   U32 price = litLength * optPtr->litSumBasePrice;
-        U32 u;
-        for (u=0; u < litLength; u++) {
-            assert(WEIGHT(optPtr->litFreq[literals[u]], optLevel) <= optPtr->litSumBasePrice);   /* literal cost should never be negative */
-            price -= WEIGHT(optPtr->litFreq[literals[u]], optLevel);
-        }
-        return price;
+    if (!ZSTD_compressedLiterals(optPtr)) 
+        return (litLength << 3) * BITCOST_MULTIPLIER;  /* Uncompressed - 8 bytes per literal. */ 
+ 
+    if (optPtr->priceType == zop_predef) 
+        return (litLength*6) * BITCOST_MULTIPLIER;  /* 6 bit per literal - no statistic used */ 
+ 
+    /* dynamic statistics */ 
+    {   U32 price = litLength * optPtr->litSumBasePrice; 
+        U32 u; 
+        for (u=0; u < litLength; u++) { 
+            assert(WEIGHT(optPtr->litFreq[literals[u]], optLevel) <= optPtr->litSumBasePrice);   /* literal cost should never be negative */ 
+            price -= WEIGHT(optPtr->litFreq[literals[u]], optLevel); 
+        } 
+        return price; 
     }
 }
 
 /* ZSTD_litLengthPrice() :
  * cost of literalLength symbol */
-static U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optPtr, int optLevel)
+static U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optPtr, int optLevel) 
 {
     assert(litLength <= ZSTD_BLOCKSIZE_MAX);
     if (optPtr->priceType == zop_predef)
@@ -280,11 +280,11 @@ static U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optP
     if (litLength == ZSTD_BLOCKSIZE_MAX)
         return BITCOST_MULTIPLIER + ZSTD_litLengthPrice(ZSTD_BLOCKSIZE_MAX - 1, optPtr, optLevel);
 
-    /* dynamic statistics */
+    /* dynamic statistics */ 
     {   U32 const llCode = ZSTD_LLcode(litLength);
-        return (LL_bits[llCode] * BITCOST_MULTIPLIER)
-             + optPtr->litLengthSumBasePrice
-             - WEIGHT(optPtr->litLengthFreq[llCode], optLevel);
+        return (LL_bits[llCode] * BITCOST_MULTIPLIER) 
+             + optPtr->litLengthSumBasePrice 
+             - WEIGHT(optPtr->litLengthFreq[llCode], optLevel); 
     }
 }
 
@@ -294,45 +294,45 @@ static U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optP
  * @offcode : expects a scale where 0,1,2 are repcodes 1-3, and 3+ are real_offsets+2
  * @optLevel: when <2, favors small offset for decompression speed (improved cache efficiency)
  */
-FORCE_INLINE_TEMPLATE U32
+FORCE_INLINE_TEMPLATE U32 
 ZSTD_getMatchPrice(U32 const offcode,
-                   U32 const matchLength,
-             const optState_t* const optPtr,
-                   int const optLevel)
+                   U32 const matchLength, 
+             const optState_t* const optPtr, 
+                   int const optLevel) 
 {
     U32 price;
     U32 const offCode = ZSTD_highbit32(STORED_TO_OFFBASE(offcode));
     U32 const mlBase = matchLength - MINMATCH;
     assert(matchLength >= MINMATCH);
 
-    if (optPtr->priceType == zop_predef)  /* fixed scheme, do not use statistics */
-        return WEIGHT(mlBase, optLevel) + ((16 + offCode) * BITCOST_MULTIPLIER);
+    if (optPtr->priceType == zop_predef)  /* fixed scheme, do not use statistics */ 
+        return WEIGHT(mlBase, optLevel) + ((16 + offCode) * BITCOST_MULTIPLIER); 
 
-    /* dynamic statistics */
-    price = (offCode * BITCOST_MULTIPLIER) + (optPtr->offCodeSumBasePrice - WEIGHT(optPtr->offCodeFreq[offCode], optLevel));
-    if ((optLevel<2) /*static*/ && offCode >= 20)
-        price += (offCode-19)*2 * BITCOST_MULTIPLIER; /* handicap for long distance offsets, favor decompression speed */
+    /* dynamic statistics */ 
+    price = (offCode * BITCOST_MULTIPLIER) + (optPtr->offCodeSumBasePrice - WEIGHT(optPtr->offCodeFreq[offCode], optLevel)); 
+    if ((optLevel<2) /*static*/ && offCode >= 20) 
+        price += (offCode-19)*2 * BITCOST_MULTIPLIER; /* handicap for long distance offsets, favor decompression speed */ 
 
     /* match Length */
     {   U32 const mlCode = ZSTD_MLcode(mlBase);
-        price += (ML_bits[mlCode] * BITCOST_MULTIPLIER) + (optPtr->matchLengthSumBasePrice - WEIGHT(optPtr->matchLengthFreq[mlCode], optLevel));
+        price += (ML_bits[mlCode] * BITCOST_MULTIPLIER) + (optPtr->matchLengthSumBasePrice - WEIGHT(optPtr->matchLengthFreq[mlCode], optLevel)); 
     }
 
-    price += BITCOST_MULTIPLIER / 5;   /* heuristic : make matches a bit more costly to favor less sequences -> faster decompression speed */
-
+    price += BITCOST_MULTIPLIER / 5;   /* heuristic : make matches a bit more costly to favor less sequences -> faster decompression speed */ 
+ 
     DEBUGLOG(8, "ZSTD_getMatchPrice(ml:%u) = %u", matchLength, price);
     return price;
 }
 
-/* ZSTD_updateStats() :
- * assumption : literals + litLengtn <= iend */
+/* ZSTD_updateStats() : 
+ * assumption : literals + litLengtn <= iend */ 
 static void ZSTD_updateStats(optState_t* const optPtr,
                              U32 litLength, const BYTE* literals,
                              U32 offsetCode, U32 matchLength)
 {
     /* literals */
-    if (ZSTD_compressedLiterals(optPtr)) {
-        U32 u;
+    if (ZSTD_compressedLiterals(optPtr)) { 
+        U32 u; 
         for (u=0; u < litLength; u++)
             optPtr->litFreq[literals[u]] += ZSTD_LITFREQ_ADD;
         optPtr->litSum += litLength*ZSTD_LITFREQ_ADD;
@@ -412,9 +412,9 @@ static U32 ZSTD_insertBt1(
                 const ZSTD_matchState_t* ms,
                 const BYTE* const ip, const BYTE* const iend,
                 U32 const target,
-                U32 const mls, const int extDict)
+                U32 const mls, const int extDict) 
 {
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    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);
@@ -454,7 +454,7 @@ static U32 ZSTD_insertBt1(
     assert(ip <= iend-8);   /* required for h calculation */
     hashTable[h] = curr;   /* Update Hash Table */
 
-    assert(windowLow > 0);
+    assert(windowLow > 0); 
     for (; nbCompares && (matchIndex >= windowLow); --nbCompares) {
         U32* const nextPtr = bt + 2*(matchIndex & btMask);
         size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
@@ -481,8 +481,8 @@ static U32 ZSTD_insertBt1(
         }
 #endif
 
-        if (!extDict || (matchIndex+matchLength >= dictLimit)) {
-            assert(matchIndex+matchLength >= dictLimit);   /* might be wrong if actually extDict */
+        if (!extDict || (matchIndex+matchLength >= dictLimit)) { 
+            assert(matchIndex+matchLength >= dictLimit);   /* might be wrong if actually extDict */ 
             match = base + matchIndex;
             matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);
         } else {
@@ -528,15 +528,15 @@ static U32 ZSTD_insertBt1(
 
 FORCE_INLINE_TEMPLATE
 void ZSTD_updateTree_internal(
-                ZSTD_matchState_t* ms,
+                ZSTD_matchState_t* ms, 
                 const BYTE* const ip, const BYTE* const iend,
-                const U32 mls, const ZSTD_dictMode_e dictMode)
+                const U32 mls, const ZSTD_dictMode_e dictMode) 
 {
     const BYTE* const base = ms->window.base;
     U32 const target = (U32)(ip - base);
     U32 idx = ms->nextToUpdate;
-    DEBUGLOG(6, "ZSTD_updateTree_internal, from %u to %u  (dictMode:%u)",
-                idx, target, dictMode);
+    DEBUGLOG(6, "ZSTD_updateTree_internal, from %u to %u  (dictMode:%u)", 
+                idx, target, dictMode); 
 
     while(idx < target) {
         U32 const forward = ZSTD_insertBt1(ms, base+idx, iend, target, mls, dictMode == ZSTD_extDict);
@@ -548,22 +548,22 @@ void ZSTD_updateTree_internal(
     ms->nextToUpdate = target;
 }
 
-void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend) {
-    ZSTD_updateTree_internal(ms, ip, iend, ms->cParams.minMatch, ZSTD_noDict);
+void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend) { 
+    ZSTD_updateTree_internal(ms, ip, iend, ms->cParams.minMatch, ZSTD_noDict); 
 }
 
 FORCE_INLINE_TEMPLATE
 U32 ZSTD_insertBtAndGetAllMatches (
                     ZSTD_match_t* matches,   /* store result (found matches) in this table (presumed large enough) */
-                    ZSTD_matchState_t* ms,
+                    ZSTD_matchState_t* ms, 
                     U32* nextToUpdate3,
-                    const BYTE* const ip, const BYTE* const iLimit, const ZSTD_dictMode_e dictMode,
+                    const BYTE* const ip, const BYTE* const iLimit, const ZSTD_dictMode_e dictMode, 
                     const U32 rep[ZSTD_REP_NUM],
-                    U32 const ll0,   /* tells if associated literal length is 0 or not. This value must be 0 or 1 */
-                    const U32 lengthToBeat,
-                    U32 const mls /* template */)
+                    U32 const ll0,   /* tells if associated literal length is 0 or not. This value must be 0 or 1 */ 
+                    const U32 lengthToBeat, 
+                    U32 const mls /* template */) 
 {
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    const ZSTD_compressionParameters* const cParams = &ms->cParams; 
     U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);
     const BYTE* const base = ms->window.base;
     U32 const curr = (U32)(ip-base);
@@ -582,7 +582,7 @@ U32 ZSTD_insertBtAndGetAllMatches (
     const BYTE* const prefixStart = base + dictLimit;
     U32 const btLow = (btMask >= curr) ? 0 : curr - btMask;
     U32 const windowLow = ZSTD_getLowestMatchIndex(ms, curr, cParams->windowLog);
-    U32 const matchLow = windowLow ? windowLow : 1;
+    U32 const matchLow = windowLow ? windowLow : 1; 
     U32* smallerPtr = bt + 2*(curr&btMask);
     U32* largerPtr  = bt + 2*(curr&btMask) + 1;
     U32 matchEndIdx = curr+8+1;   /* farthest referenced position of any match => detects repetitive patterns */
@@ -590,24 +590,24 @@ U32 ZSTD_insertBtAndGetAllMatches (
     U32 mnum = 0;
     U32 nbCompares = 1U << cParams->searchLog;
 
-    const ZSTD_matchState_t* dms    = dictMode == ZSTD_dictMatchState ? ms->dictMatchState : NULL;
-    const ZSTD_compressionParameters* const dmsCParams =
-                                      dictMode == ZSTD_dictMatchState ? &dms->cParams : NULL;
-    const BYTE* const dmsBase       = dictMode == ZSTD_dictMatchState ? dms->window.base : NULL;
-    const BYTE* const dmsEnd        = dictMode == ZSTD_dictMatchState ? dms->window.nextSrc : NULL;
-    U32         const dmsHighLimit  = dictMode == ZSTD_dictMatchState ? (U32)(dmsEnd - dmsBase) : 0;
-    U32         const dmsLowLimit   = dictMode == ZSTD_dictMatchState ? dms->window.lowLimit : 0;
-    U32         const dmsIndexDelta = dictMode == ZSTD_dictMatchState ? windowLow - dmsHighLimit : 0;
-    U32         const dmsHashLog    = dictMode == ZSTD_dictMatchState ? dmsCParams->hashLog : hashLog;
-    U32         const dmsBtLog      = dictMode == ZSTD_dictMatchState ? dmsCParams->chainLog - 1 : btLog;
-    U32         const dmsBtMask     = dictMode == ZSTD_dictMatchState ? (1U << dmsBtLog) - 1 : 0;
-    U32         const dmsBtLow      = dictMode == ZSTD_dictMatchState && dmsBtMask < dmsHighLimit - dmsLowLimit ? dmsHighLimit - dmsBtMask : dmsLowLimit;
-
+    const ZSTD_matchState_t* dms    = dictMode == ZSTD_dictMatchState ? ms->dictMatchState : NULL; 
+    const ZSTD_compressionParameters* const dmsCParams = 
+                                      dictMode == ZSTD_dictMatchState ? &dms->cParams : NULL; 
+    const BYTE* const dmsBase       = dictMode == ZSTD_dictMatchState ? dms->window.base : NULL; 
+    const BYTE* const dmsEnd        = dictMode == ZSTD_dictMatchState ? dms->window.nextSrc : NULL; 
+    U32         const dmsHighLimit  = dictMode == ZSTD_dictMatchState ? (U32)(dmsEnd - dmsBase) : 0; 
+    U32         const dmsLowLimit   = dictMode == ZSTD_dictMatchState ? dms->window.lowLimit : 0; 
+    U32         const dmsIndexDelta = dictMode == ZSTD_dictMatchState ? windowLow - dmsHighLimit : 0; 
+    U32         const dmsHashLog    = dictMode == ZSTD_dictMatchState ? dmsCParams->hashLog : hashLog; 
+    U32         const dmsBtLog      = dictMode == ZSTD_dictMatchState ? dmsCParams->chainLog - 1 : btLog; 
+    U32         const dmsBtMask     = dictMode == ZSTD_dictMatchState ? (1U << dmsBtLog) - 1 : 0; 
+    U32         const dmsBtLow      = dictMode == ZSTD_dictMatchState && dmsBtMask < dmsHighLimit - dmsLowLimit ? dmsHighLimit - dmsBtMask : dmsLowLimit; 
+ 
     size_t bestLength = lengthToBeat-1;
     DEBUGLOG(8, "ZSTD_insertBtAndGetAllMatches: current=%u", curr);
 
     /* check repCode */
-    assert(ll0 <= 1);   /* necessarily 1 or 0 */
+    assert(ll0 <= 1);   /* necessarily 1 or 0 */ 
     {   U32 const lastR = ZSTD_REP_NUM + ll0;
         U32 repCode;
         for (repCode = ll0; repCode < lastR; repCode++) {
@@ -623,26 +623,26 @@ U32 ZSTD_insertBtAndGetAllMatches (
                     repLen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repOffset, iLimit) + minMatch;
                 }
             } else {  /* repIndex < dictLimit || repIndex >= curr */
-                const BYTE* const repMatch = dictMode == ZSTD_dictMatchState ?
-                                             dmsBase + repIndex - dmsIndexDelta :
-                                             dictBase + repIndex;
+                const BYTE* const repMatch = dictMode == ZSTD_dictMatchState ? 
+                                             dmsBase + repIndex - dmsIndexDelta : 
+                                             dictBase + repIndex; 
                 assert(curr >= windowLow);
-                if ( dictMode == ZSTD_extDict
+                if ( dictMode == ZSTD_extDict 
                   && ( ((repOffset-1) /*intentional overflow*/ < curr - windowLow)  /* equivalent to `curr > repIndex >= windowLow` */
                      & (((U32)((dictLimit-1) - repIndex) >= 3) ) /* intentional overflow : do not test positions overlapping 2 memory segments */)
                   && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {
                     repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, dictEnd, prefixStart) + minMatch;
-                }
-                if (dictMode == ZSTD_dictMatchState
+                } 
+                if (dictMode == ZSTD_dictMatchState 
                   && ( ((repOffset-1) /*intentional overflow*/ < curr - (dmsLowLimit + dmsIndexDelta))  /* equivalent to `curr > repIndex >= dmsLowLimit` */
-                     & ((U32)((dictLimit-1) - repIndex) >= 3) ) /* intentional overflow : do not test positions overlapping 2 memory segments */
-                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {
-                    repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, dmsEnd, prefixStart) + minMatch;
+                     & ((U32)((dictLimit-1) - repIndex) >= 3) ) /* intentional overflow : do not test positions overlapping 2 memory segments */ 
+                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) { 
+                    repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, dmsEnd, prefixStart) + minMatch; 
             }   }
             /* save longer solution */
             if (repLen > bestLength) {
-                DEBUGLOG(8, "found repCode %u (ll0:%u, offset:%u) of length %u",
-                            repCode, ll0, repOffset, repLen);
+                DEBUGLOG(8, "found repCode %u (ll0:%u, offset:%u) of length %u", 
+                            repCode, ll0, repOffset, repLen); 
                 bestLength = repLen;
                 matches[mnum].off = STORE_REPCODE(repCode - ll0 + 1);  /* expect value between 1 and 3 */
                 matches[mnum].len = (U32)repLen;
@@ -655,10 +655,10 @@ U32 ZSTD_insertBtAndGetAllMatches (
     /* HC3 match finder */
     if ((mls == 3) /*static*/ && (bestLength < mls)) {
         U32 const matchIndex3 = ZSTD_insertAndFindFirstIndexHash3(ms, nextToUpdate3, ip);
-        if ((matchIndex3 >= matchLow)
+        if ((matchIndex3 >= matchLow) 
           & (curr - matchIndex3 < (1<<18)) /*heuristic : longer distance likely too expensive*/ ) {
             size_t mlen;
-            if ((dictMode == ZSTD_noDict) /*static*/ || (dictMode == ZSTD_dictMatchState) /*static*/ || (matchIndex3 >= dictLimit)) {
+            if ((dictMode == ZSTD_noDict) /*static*/ || (dictMode == ZSTD_dictMatchState) /*static*/ || (matchIndex3 >= dictLimit)) { 
                 const BYTE* const match = base + matchIndex3;
                 mlen = ZSTD_count(ip, match, iLimit);
             } else {
@@ -681,7 +681,7 @@ U32 ZSTD_insertBtAndGetAllMatches (
                     ms->nextToUpdate = curr+1;  /* skip insertion */
                     return 1;
         }   }   }
-        /* no dictMatchState lookup: dicts don't have a populated HC3 table */
+        /* no dictMatchState lookup: dicts don't have a populated HC3 table */ 
     }  /* if (mls == 3) */
 
     hashTable[h] = curr;   /* Update Hash Table */
@@ -692,7 +692,7 @@ U32 ZSTD_insertBtAndGetAllMatches (
         size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
         assert(curr > matchIndex);
 
-        if ((dictMode == ZSTD_noDict) || (dictMode == ZSTD_dictMatchState) || (matchIndex+matchLength >= dictLimit)) {
+        if ((dictMode == ZSTD_noDict) || (dictMode == ZSTD_dictMatchState) || (matchIndex+matchLength >= dictLimit)) { 
             assert(matchIndex+matchLength >= dictLimit);  /* ensure the condition is correct when !extDict */
             match = base + matchIndex;
             if (matchIndex >= dictLimit) assert(memcmp(match, ip, matchLength) == 0);  /* ensure early section of match is equal as expected */
@@ -706,7 +706,7 @@ U32 ZSTD_insertBtAndGetAllMatches (
         }
 
         if (matchLength > bestLength) {
-            DEBUGLOG(8, "found match of length %u at distance %u (offCode=%u)",
+            DEBUGLOG(8, "found match of length %u at distance %u (offCode=%u)", 
                     (U32)matchLength, curr - matchIndex, STORE_OFFSET(curr - matchIndex));
             assert(matchEndIdx > matchIndex);
             if (matchLength > matchEndIdx - matchIndex)
@@ -715,10 +715,10 @@ U32 ZSTD_insertBtAndGetAllMatches (
             matches[mnum].off = STORE_OFFSET(curr - matchIndex);
             matches[mnum].len = (U32)matchLength;
             mnum++;
-            if ( (matchLength > ZSTD_OPT_NUM)
-               | (ip+matchLength == iLimit) /* equal : no way to know if inf or sup */) {
-                if (dictMode == ZSTD_dictMatchState) nbCompares = 0; /* break should also skip searching dms */
-                break; /* drop, to preserve bt consistency (miss a little bit of compression) */
+            if ( (matchLength > ZSTD_OPT_NUM) 
+               | (ip+matchLength == iLimit) /* equal : no way to know if inf or sup */) { 
+                if (dictMode == ZSTD_dictMatchState) nbCompares = 0; /* break should also skip searching dms */ 
+                break; /* drop, to preserve bt consistency (miss a little bit of compression) */ 
         }   }
 
         if (match[matchLength] < ip[matchLength]) {
@@ -739,44 +739,44 @@ U32 ZSTD_insertBtAndGetAllMatches (
     *smallerPtr = *largerPtr = 0;
 
     assert(nbCompares <= (1U << ZSTD_SEARCHLOG_MAX)); /* Check we haven't underflowed. */
-    if (dictMode == ZSTD_dictMatchState && nbCompares) {
-        size_t const dmsH = ZSTD_hashPtr(ip, dmsHashLog, mls);
-        U32 dictMatchIndex = dms->hashTable[dmsH];
-        const U32* const dmsBt = dms->chainTable;
-        commonLengthSmaller = commonLengthLarger = 0;
+    if (dictMode == ZSTD_dictMatchState && nbCompares) { 
+        size_t const dmsH = ZSTD_hashPtr(ip, dmsHashLog, mls); 
+        U32 dictMatchIndex = dms->hashTable[dmsH]; 
+        const U32* const dmsBt = dms->chainTable; 
+        commonLengthSmaller = commonLengthLarger = 0; 
         for (; nbCompares && (dictMatchIndex > dmsLowLimit); --nbCompares) {
-            const U32* const nextPtr = dmsBt + 2*(dictMatchIndex & dmsBtMask);
-            size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
-            const BYTE* match = dmsBase + dictMatchIndex;
-            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dmsEnd, prefixStart);
-            if (dictMatchIndex+matchLength >= dmsHighLimit)
-                match = base + dictMatchIndex + dmsIndexDelta;   /* to prepare for next usage of match[matchLength] */
-
-            if (matchLength > bestLength) {
-                matchIndex = dictMatchIndex + dmsIndexDelta;
-                DEBUGLOG(8, "found dms match of length %u at distance %u (offCode=%u)",
+            const U32* const nextPtr = dmsBt + 2*(dictMatchIndex & dmsBtMask); 
+            size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */ 
+            const BYTE* match = dmsBase + dictMatchIndex; 
+            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dmsEnd, prefixStart); 
+            if (dictMatchIndex+matchLength >= dmsHighLimit) 
+                match = base + dictMatchIndex + dmsIndexDelta;   /* to prepare for next usage of match[matchLength] */ 
+ 
+            if (matchLength > bestLength) { 
+                matchIndex = dictMatchIndex + dmsIndexDelta; 
+                DEBUGLOG(8, "found dms match of length %u at distance %u (offCode=%u)", 
                         (U32)matchLength, curr - matchIndex, STORE_OFFSET(curr - matchIndex));
-                if (matchLength > matchEndIdx - matchIndex)
-                    matchEndIdx = matchIndex + (U32)matchLength;
-                bestLength = matchLength;
+                if (matchLength > matchEndIdx - matchIndex) 
+                    matchEndIdx = matchIndex + (U32)matchLength; 
+                bestLength = matchLength; 
                 matches[mnum].off = STORE_OFFSET(curr - matchIndex);
-                matches[mnum].len = (U32)matchLength;
-                mnum++;
-                if ( (matchLength > ZSTD_OPT_NUM)
-                   | (ip+matchLength == iLimit) /* equal : no way to know if inf or sup */) {
-                    break;   /* drop, to guarantee consistency (miss a little bit of compression) */
+                matches[mnum].len = (U32)matchLength; 
+                mnum++; 
+                if ( (matchLength > ZSTD_OPT_NUM) 
+                   | (ip+matchLength == iLimit) /* equal : no way to know if inf or sup */) { 
+                    break;   /* drop, to guarantee consistency (miss a little bit of compression) */ 
             }   }
-
-            if (dictMatchIndex <= dmsBtLow) { break; }   /* beyond tree size, stop the search */
-            if (match[matchLength] < ip[matchLength]) {
-                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 */
-                commonLengthLarger = matchLength;
-                dictMatchIndex = nextPtr[0];
+ 
+            if (dictMatchIndex <= dmsBtLow) { break; }   /* beyond tree size, stop the search */ 
+            if (match[matchLength] < ip[matchLength]) { 
+                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 */ 
+                commonLengthLarger = matchLength; 
+                dictMatchIndex = nextPtr[0]; 
     }   }   }  /* if (dictMode == ZSTD_dictMatchState) */
-
+ 
     assert(matchEndIdx > curr+8);
     ms->nextToUpdate = matchEndIdx - 8;  /* skip repetitive patterns */
     return mnum;
@@ -1011,35 +1011,35 @@ ZSTD_optLdm_processMatchCandidate(ZSTD_optLdm_t* optLdm,
 *  Optimal parser
 *********************************/
 
-static U32 ZSTD_totalLen(ZSTD_optimal_t sol)
-{
-    return sol.litlen + sol.mlen;
-}
-
-#if 0 /* debug */
-
-static void
-listStats(const U32* table, int lastEltID)
+static U32 ZSTD_totalLen(ZSTD_optimal_t sol) 
 {
-    int const nbElts = lastEltID + 1;
-    int enb;
-    for (enb=0; enb < nbElts; enb++) {
-        (void)table;
+    return sol.litlen + sol.mlen; 
+} 
+
+#if 0 /* debug */ 
+
+static void 
+listStats(const U32* table, int lastEltID) 
+{ 
+    int const nbElts = lastEltID + 1; 
+    int enb; 
+    for (enb=0; enb < nbElts; enb++) { 
+        (void)table; 
         /* RAWLOG(2, "%3i:%3i,  ", enb, table[enb]); */
-        RAWLOG(2, "%4i,", table[enb]);
+        RAWLOG(2, "%4i,", table[enb]); 
     }
-    RAWLOG(2, " \n");
+    RAWLOG(2, " \n"); 
 }
 
-#endif
+#endif 
 
-FORCE_INLINE_TEMPLATE size_t
-ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
-                               seqStore_t* seqStore,
-                               U32 rep[ZSTD_REP_NUM],
-                         const void* src, size_t srcSize,
-                         const int optLevel,
-                         const ZSTD_dictMode_e dictMode)
+FORCE_INLINE_TEMPLATE size_t 
+ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms, 
+                               seqStore_t* seqStore, 
+                               U32 rep[ZSTD_REP_NUM], 
+                         const void* src, size_t srcSize, 
+                         const int optLevel, 
+                         const ZSTD_dictMode_e dictMode) 
 {
     optState_t* const optStatePtr = &ms->opt;
     const BYTE* const istart = (const BYTE*)src;
@@ -1049,17 +1049,17 @@ ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
     const BYTE* const ilimit = iend - 8;
     const BYTE* const base = ms->window.base;
     const BYTE* const prefixStart = base + ms->window.dictLimit;
-    const ZSTD_compressionParameters* const cParams = &ms->cParams;
+    const ZSTD_compressionParameters* const cParams = &ms->cParams; 
 
     ZSTD_getAllMatchesFn getAllMatches = ZSTD_selectBtGetAllMatches(ms, dictMode);
 
     U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);
-    U32 const minMatch = (cParams->minMatch == 3) ? 3 : 4;
+    U32 const minMatch = (cParams->minMatch == 3) ? 3 : 4; 
     U32 nextToUpdate3 = ms->nextToUpdate;
 
     ZSTD_optimal_t* const opt = optStatePtr->priceTable;
     ZSTD_match_t* const matches = optStatePtr->matchTable;
-    ZSTD_optimal_t lastSequence;
+    ZSTD_optimal_t lastSequence; 
     ZSTD_optLdm_t optLdm;
 
     optLdm.seqStore = ms->ldmSeqStore ? *ms->ldmSeqStore : kNullRawSeqStore;
@@ -1067,10 +1067,10 @@ ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
     ZSTD_opt_getNextMatchAndUpdateSeqStore(&optLdm, (U32)(ip-istart), (U32)(iend-ip));
 
     /* init */
-    DEBUGLOG(5, "ZSTD_compressBlock_opt_generic: current=%u, prefix=%u, nextToUpdate=%u",
-                (U32)(ip - base), ms->window.dictLimit, ms->nextToUpdate);
-    assert(optLevel <= 2);
-    ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize, optLevel);
+    DEBUGLOG(5, "ZSTD_compressBlock_opt_generic: current=%u, prefix=%u, nextToUpdate=%u", 
+                (U32)(ip - base), ms->window.dictLimit, ms->nextToUpdate); 
+    assert(optLevel <= 2); 
+    ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize, optLevel); 
     ip += (ip==prefixStart);
 
     /* Match Loop */
@@ -1087,7 +1087,7 @@ ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
 
             /* initialize opt[0] */
             { U32 i ; for (i=0; i<ZSTD_REP_NUM; i++) opt[0].rep[i] = rep[i]; }
-            opt[0].mlen = 0;  /* means is_a_literal */
+            opt[0].mlen = 0;  /* means is_a_literal */ 
             opt[0].litlen = litlen;
             /* We don't need to include the actual price of the literals because
              * it is static for the duration of the forward pass, and is included
@@ -1099,17 +1099,17 @@ ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
             /* large match -> immediate encoding */
             {   U32 const maxML = matches[nbMatches-1].len;
                 U32 const maxOffcode = matches[nbMatches-1].off;
-                DEBUGLOG(6, "found %u matches of maxLength=%u and maxOffCode=%u at cPos=%u => start new series",
+                DEBUGLOG(6, "found %u matches of maxLength=%u and maxOffCode=%u at cPos=%u => start new series", 
                             nbMatches, maxML, maxOffcode, (U32)(ip-prefixStart));
 
                 if (maxML > sufficient_len) {
-                    lastSequence.litlen = litlen;
-                    lastSequence.mlen = maxML;
+                    lastSequence.litlen = litlen; 
+                    lastSequence.mlen = maxML; 
                     lastSequence.off = maxOffcode;
-                    DEBUGLOG(6, "large match (%u>%u), immediate encoding",
-                                maxML, sufficient_len);
+                    DEBUGLOG(6, "large match (%u>%u), immediate encoding", 
+                                maxML, sufficient_len); 
                     cur = 0;
-                    last_pos = ZSTD_totalLen(lastSequence);
+                    last_pos = ZSTD_totalLen(lastSequence); 
                     goto _shortestPath;
             }   }
 
@@ -1118,17 +1118,17 @@ ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
             {   U32 const literalsPrice = (U32)opt[0].price + ZSTD_litLengthPrice(0, optStatePtr, optLevel);
                 U32 pos;
                 U32 matchNb;
-                for (pos = 1; pos < minMatch; pos++) {
-                    opt[pos].price = ZSTD_MAX_PRICE;   /* mlen, litlen and price will be fixed during forward scanning */
+                for (pos = 1; pos < minMatch; pos++) { 
+                    opt[pos].price = ZSTD_MAX_PRICE;   /* mlen, litlen and price will be fixed during forward scanning */ 
                 }
                 for (matchNb = 0; matchNb < nbMatches; matchNb++) {
                     U32 const offcode = matches[matchNb].off;
                     U32 const end = matches[matchNb].len;
                     for ( ; pos <= end ; pos++ ) {
                         U32 const matchPrice = ZSTD_getMatchPrice(offcode, pos, optStatePtr, optLevel);
-                        U32 const sequencePrice = literalsPrice + matchPrice;
-                        DEBUGLOG(7, "rPos:%u => set initial price : %.2f",
-                                    pos, ZSTD_fCost(sequencePrice));
+                        U32 const sequencePrice = literalsPrice + matchPrice; 
+                        DEBUGLOG(7, "rPos:%u => set initial price : %.2f", 
+                                    pos, ZSTD_fCost(sequencePrice)); 
                         opt[pos].mlen = pos;
                         opt[pos].off = offcode;
                         opt[pos].litlen = litlen;
@@ -1142,29 +1142,29 @@ ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
         for (cur = 1; cur <= last_pos; cur++) {
             const BYTE* const inr = ip + cur;
             assert(cur < ZSTD_OPT_NUM);
-            DEBUGLOG(7, "cPos:%zi==rPos:%u", inr-istart, cur)
+            DEBUGLOG(7, "cPos:%zi==rPos:%u", inr-istart, cur) 
 
             /* Fix current position with one literal if cheaper */
-            {   U32 const litlen = (opt[cur-1].mlen == 0) ? opt[cur-1].litlen + 1 : 1;
-                int const price = opt[cur-1].price
+            {   U32 const litlen = (opt[cur-1].mlen == 0) ? opt[cur-1].litlen + 1 : 1; 
+                int const price = opt[cur-1].price 
                                 + (int)ZSTD_rawLiteralsCost(ip+cur-1, 1, optStatePtr, optLevel)
                                 + (int)ZSTD_litLengthPrice(litlen, optStatePtr, optLevel)
                                 - (int)ZSTD_litLengthPrice(litlen-1, optStatePtr, optLevel);
                 assert(price < 1000000000); /* overflow check */
                 if (price <= opt[cur].price) {
-                    DEBUGLOG(7, "cPos:%zi==rPos:%u : better price (%.2f<=%.2f) using literal (ll==%u) (hist:%u,%u,%u)",
-                                inr-istart, cur, ZSTD_fCost(price), ZSTD_fCost(opt[cur].price), litlen,
-                                opt[cur-1].rep[0], opt[cur-1].rep[1], opt[cur-1].rep[2]);
-                    opt[cur].mlen = 0;
+                    DEBUGLOG(7, "cPos:%zi==rPos:%u : better price (%.2f<=%.2f) using literal (ll==%u) (hist:%u,%u,%u)", 
+                                inr-istart, cur, ZSTD_fCost(price), ZSTD_fCost(opt[cur].price), litlen, 
+                                opt[cur-1].rep[0], opt[cur-1].rep[1], opt[cur-1].rep[2]); 
+                    opt[cur].mlen = 0; 
                     opt[cur].off = 0;
                     opt[cur].litlen = litlen;
                     opt[cur].price = price;
-                } else {
-                    DEBUGLOG(7, "cPos:%zi==rPos:%u : literal would cost more (%.2f>%.2f) (hist:%u,%u,%u)",
-                                inr-istart, cur, ZSTD_fCost(price), ZSTD_fCost(opt[cur].price),
-                                opt[cur].rep[0], opt[cur].rep[1], opt[cur].rep[2]);
-                }
-            }
+                } else { 
+                    DEBUGLOG(7, "cPos:%zi==rPos:%u : literal would cost more (%.2f>%.2f) (hist:%u,%u,%u)", 
+                                inr-istart, cur, ZSTD_fCost(price), ZSTD_fCost(opt[cur].price), 
+                                opt[cur].rep[0], opt[cur].rep[1], opt[cur].rep[2]); 
+                } 
+            } 
 
             /* Set the repcodes of the current position. We must do it here
              * because we rely on the repcodes of the 2nd to last sequence being
@@ -1186,42 +1186,42 @@ ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
 
             if (cur == last_pos) break;
 
-            if ( (optLevel==0) /*static_test*/
-              && (opt[cur+1].price <= opt[cur].price + (BITCOST_MULTIPLIER/2)) ) {
-                DEBUGLOG(7, "move to next rPos:%u : price is <=", cur+1);
+            if ( (optLevel==0) /*static_test*/ 
+              && (opt[cur+1].price <= opt[cur].price + (BITCOST_MULTIPLIER/2)) ) { 
+                DEBUGLOG(7, "move to next rPos:%u : price is <=", cur+1); 
                 continue;  /* skip unpromising positions; about ~+6% speed, -0.01 ratio */
-            }
+            } 
 
             assert(opt[cur].price >= 0);
-            {   U32 const ll0 = (opt[cur].mlen != 0);
-                U32 const litlen = (opt[cur].mlen == 0) ? opt[cur].litlen : 0;
+            {   U32 const ll0 = (opt[cur].mlen != 0); 
+                U32 const litlen = (opt[cur].mlen == 0) ? opt[cur].litlen : 0; 
                 U32 const previousPrice = (U32)opt[cur].price;
-                U32 const basePrice = previousPrice + ZSTD_litLengthPrice(0, optStatePtr, optLevel);
+                U32 const basePrice = previousPrice + ZSTD_litLengthPrice(0, optStatePtr, optLevel); 
                 U32 nbMatches = getAllMatches(matches, ms, &nextToUpdate3, inr, iend, opt[cur].rep, ll0, minMatch);
                 U32 matchNb;
 
                 ZSTD_optLdm_processMatchCandidate(&optLdm, matches, &nbMatches,
                                                   (U32)(inr-istart), (U32)(iend-inr));
 
-                if (!nbMatches) {
-                    DEBUGLOG(7, "rPos:%u : no match found", cur);
-                    continue;
-                }
+                if (!nbMatches) { 
+                    DEBUGLOG(7, "rPos:%u : no match found", cur); 
+                    continue; 
+                } 
 
                 {   U32 const maxML = matches[nbMatches-1].len;
-                    DEBUGLOG(7, "cPos:%zi==rPos:%u, found %u matches, of maxLength=%u",
-                                inr-istart, cur, nbMatches, maxML);
+                    DEBUGLOG(7, "cPos:%zi==rPos:%u, found %u matches, of maxLength=%u", 
+                                inr-istart, cur, nbMatches, maxML); 
 
                     if ( (maxML > sufficient_len)
-                      || (cur + maxML >= ZSTD_OPT_NUM) ) {
-                        lastSequence.mlen = maxML;
-                        lastSequence.off = matches[nbMatches-1].off;
-                        lastSequence.litlen = litlen;
-                        cur -= (opt[cur].mlen==0) ? opt[cur].litlen : 0;  /* last sequence is actually only literals, fix cur to last match - note : may underflow, in which case, it's first sequence, and it's okay */
-                        last_pos = cur + ZSTD_totalLen(lastSequence);
-                        if (cur > ZSTD_OPT_NUM) cur = 0;   /* underflow => first match */
+                      || (cur + maxML >= ZSTD_OPT_NUM) ) { 
+                        lastSequence.mlen = maxML; 
+                        lastSequence.off = matches[nbMatches-1].off; 
+                        lastSequence.litlen = litlen; 
+                        cur -= (opt[cur].mlen==0) ? opt[cur].litlen : 0;  /* last sequence is actually only literals, fix cur to last match - note : may underflow, in which case, it's first sequence, and it's okay */ 
+                        last_pos = cur + ZSTD_totalLen(lastSequence); 
+                        if (cur > ZSTD_OPT_NUM) cur = 0;   /* underflow => first match */ 
                         goto _shortestPath;
-                }   }
+                }   } 
 
                 /* set prices using matches found at position == cur */
                 for (matchNb = 0; matchNb < nbMatches; matchNb++) {
@@ -1230,35 +1230,35 @@ ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
                     U32 const startML = (matchNb>0) ? matches[matchNb-1].len+1 : minMatch;
                     U32 mlen;
 
-                    DEBUGLOG(7, "testing match %u => offCode=%4u, mlen=%2u, llen=%2u",
+                    DEBUGLOG(7, "testing match %u => offCode=%4u, mlen=%2u, llen=%2u", 
                                 matchNb, matches[matchNb].off, lastML, litlen);
 
-                    for (mlen = lastML; mlen >= startML; mlen--) {  /* scan downward */
+                    for (mlen = lastML; mlen >= startML; mlen--) {  /* scan downward */ 
                         U32 const pos = cur + mlen;
                         int const price = (int)basePrice + (int)ZSTD_getMatchPrice(offset, mlen, optStatePtr, optLevel);
 
                         if ((pos > last_pos) || (price < opt[pos].price)) {
-                            DEBUGLOG(7, "rPos:%u (ml=%2u) => new better price (%.2f<%.2f)",
-                                        pos, mlen, ZSTD_fCost(price), ZSTD_fCost(opt[pos].price));
-                            while (last_pos < pos) { opt[last_pos+1].price = ZSTD_MAX_PRICE; last_pos++; }   /* fill empty positions */
+                            DEBUGLOG(7, "rPos:%u (ml=%2u) => new better price (%.2f<%.2f)", 
+                                        pos, mlen, ZSTD_fCost(price), ZSTD_fCost(opt[pos].price)); 
+                            while (last_pos < pos) { opt[last_pos+1].price = ZSTD_MAX_PRICE; last_pos++; }   /* fill empty positions */ 
                             opt[pos].mlen = mlen;
                             opt[pos].off = offset;
                             opt[pos].litlen = litlen;
                             opt[pos].price = price;
                         } else {
-                            DEBUGLOG(7, "rPos:%u (ml=%2u) => new price is worse (%.2f>=%.2f)",
-                                        pos, mlen, ZSTD_fCost(price), ZSTD_fCost(opt[pos].price));
-                            if (optLevel==0) break;  /* early update abort; gets ~+10% speed for about -0.01 ratio loss */
+                            DEBUGLOG(7, "rPos:%u (ml=%2u) => new price is worse (%.2f>=%.2f)", 
+                                        pos, mlen, ZSTD_fCost(price), ZSTD_fCost(opt[pos].price)); 
+                            if (optLevel==0) break;  /* early update abort; gets ~+10% speed for about -0.01 ratio loss */ 
                         }
             }   }   }
         }  /* for (cur = 1; cur <= last_pos; cur++) */
 
-        lastSequence = opt[last_pos];
-        cur = last_pos > ZSTD_totalLen(lastSequence) ? last_pos - ZSTD_totalLen(lastSequence) : 0;  /* single sequence, and it starts before `ip` */
-        assert(cur < ZSTD_OPT_NUM);  /* control overflow*/
+        lastSequence = opt[last_pos]; 
+        cur = last_pos > ZSTD_totalLen(lastSequence) ? last_pos - ZSTD_totalLen(lastSequence) : 0;  /* single sequence, and it starts before `ip` */ 
+        assert(cur < ZSTD_OPT_NUM);  /* control overflow*/ 
 
 _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
-        assert(opt[0].mlen == 0);
+        assert(opt[0].mlen == 0); 
 
         /* Set the next chunk's repcodes based on the repcodes of the beginning
          * of the last match, and the last sequence. This avoids us having to
@@ -1271,50 +1271,50 @@ _shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */
             ZSTD_memcpy(rep, opt[cur].rep, sizeof(repcodes_t));
         }
 
-        {   U32 const storeEnd = cur + 1;
-            U32 storeStart = storeEnd;
-            U32 seqPos = cur;
-
-            DEBUGLOG(6, "start reverse traversal (last_pos:%u, cur:%u)",
-                        last_pos, cur); (void)last_pos;
-            assert(storeEnd < ZSTD_OPT_NUM);
-            DEBUGLOG(6, "last sequence copied into pos=%u (llen=%u,mlen=%u,ofc=%u)",
-                        storeEnd, lastSequence.litlen, lastSequence.mlen, lastSequence.off);
-            opt[storeEnd] = lastSequence;
-            while (seqPos > 0) {
-                U32 const backDist = ZSTD_totalLen(opt[seqPos]);
-                storeStart--;
-                DEBUGLOG(6, "sequence from rPos=%u copied into pos=%u (llen=%u,mlen=%u,ofc=%u)",
-                            seqPos, storeStart, opt[seqPos].litlen, opt[seqPos].mlen, opt[seqPos].off);
-                opt[storeStart] = opt[seqPos];
-                seqPos = (seqPos > backDist) ? seqPos - backDist : 0;
-            }
-
-            /* save sequences */
-            DEBUGLOG(6, "sending selected sequences into seqStore")
-            {   U32 storePos;
-                for (storePos=storeStart; storePos <= storeEnd; storePos++) {
-                    U32 const llen = opt[storePos].litlen;
-                    U32 const mlen = opt[storePos].mlen;
-                    U32 const offCode = opt[storePos].off;
-                    U32 const advance = llen + mlen;
-                    DEBUGLOG(6, "considering seq starting at %zi, llen=%u, mlen=%u",
-                                anchor - istart, (unsigned)llen, (unsigned)mlen);
-
-                    if (mlen==0) {  /* only literals => must be last "sequence", actually starting a new stream of sequences */
-                        assert(storePos == storeEnd);   /* must be last sequence */
-                        ip = anchor + llen;     /* last "sequence" is a bunch of literals => don't progress anchor */
-                        continue;   /* will finish */
+        {   U32 const storeEnd = cur + 1; 
+            U32 storeStart = storeEnd; 
+            U32 seqPos = cur; 
+
+            DEBUGLOG(6, "start reverse traversal (last_pos:%u, cur:%u)", 
+                        last_pos, cur); (void)last_pos; 
+            assert(storeEnd < ZSTD_OPT_NUM); 
+            DEBUGLOG(6, "last sequence copied into pos=%u (llen=%u,mlen=%u,ofc=%u)", 
+                        storeEnd, lastSequence.litlen, lastSequence.mlen, lastSequence.off); 
+            opt[storeEnd] = lastSequence; 
+            while (seqPos > 0) { 
+                U32 const backDist = ZSTD_totalLen(opt[seqPos]); 
+                storeStart--; 
+                DEBUGLOG(6, "sequence from rPos=%u copied into pos=%u (llen=%u,mlen=%u,ofc=%u)", 
+                            seqPos, storeStart, opt[seqPos].litlen, opt[seqPos].mlen, opt[seqPos].off); 
+                opt[storeStart] = opt[seqPos]; 
+                seqPos = (seqPos > backDist) ? seqPos - backDist : 0; 
+            } 
+
+            /* save sequences */ 
+            DEBUGLOG(6, "sending selected sequences into seqStore") 
+            {   U32 storePos; 
+                for (storePos=storeStart; storePos <= storeEnd; storePos++) { 
+                    U32 const llen = opt[storePos].litlen; 
+                    U32 const mlen = opt[storePos].mlen; 
+                    U32 const offCode = opt[storePos].off; 
+                    U32 const advance = llen + mlen; 
+                    DEBUGLOG(6, "considering seq starting at %zi, llen=%u, mlen=%u", 
+                                anchor - istart, (unsigned)llen, (unsigned)mlen); 
+ 
+                    if (mlen==0) {  /* only literals => must be last "sequence", actually starting a new stream of sequences */ 
+                        assert(storePos == storeEnd);   /* must be last sequence */ 
+                        ip = anchor + llen;     /* last "sequence" is a bunch of literals => don't progress anchor */ 
+                        continue;   /* will finish */ 
                     }
 
-                    assert(anchor + llen <= iend);
-                    ZSTD_updateStats(optStatePtr, llen, anchor, offCode, mlen);
+                    assert(anchor + llen <= iend); 
+                    ZSTD_updateStats(optStatePtr, llen, anchor, offCode, mlen); 
                     ZSTD_storeSeq(seqStore, llen, anchor, iend, offCode, mlen);
-                    anchor += advance;
-                    ip = anchor;
-            }   }
-            ZSTD_setBasePrices(optStatePtr, optLevel);
-        }
+                    anchor += advance; 
+                    ip = anchor; 
+            }   } 
+            ZSTD_setBasePrices(optStatePtr, optLevel); 
+        } 
     }   /* while (ip < ilimit) */
 
     /* Return the last literals size */
@@ -1337,110 +1337,110 @@ static size_t ZSTD_compressBlock_opt2(
 
 size_t ZSTD_compressBlock_btopt(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize)
+        const void* src, size_t srcSize) 
 {
     DEBUGLOG(5, "ZSTD_compressBlock_btopt");
     return ZSTD_compressBlock_opt0(ms, seqStore, rep, src, srcSize, ZSTD_noDict);
 }
 
-
-
-
-/* ZSTD_initStats_ultra():
- * make a first compression pass, just to seed stats with more accurate starting values.
- * only works on first block, with no dictionary and no ldm.
- * this function cannot error, hence its contract must be respected.
- */
-static void
-ZSTD_initStats_ultra(ZSTD_matchState_t* ms,
-                     seqStore_t* seqStore,
-                     U32 rep[ZSTD_REP_NUM],
-               const void* src, size_t srcSize)
-{
-    U32 tmpRep[ZSTD_REP_NUM];  /* updated rep codes will sink here */
+ 
+ 
+ 
+/* ZSTD_initStats_ultra(): 
+ * make a first compression pass, just to seed stats with more accurate starting values. 
+ * only works on first block, with no dictionary and no ldm. 
+ * this function cannot error, hence its contract must be respected. 
+ */ 
+static void 
+ZSTD_initStats_ultra(ZSTD_matchState_t* ms, 
+                     seqStore_t* seqStore, 
+                     U32 rep[ZSTD_REP_NUM], 
+               const void* src, size_t srcSize) 
+{ 
+    U32 tmpRep[ZSTD_REP_NUM];  /* updated rep codes will sink here */ 
     ZSTD_memcpy(tmpRep, rep, sizeof(tmpRep));
-
-    DEBUGLOG(4, "ZSTD_initStats_ultra (srcSize=%zu)", srcSize);
-    assert(ms->opt.litLengthSum == 0);    /* first block */
-    assert(seqStore->sequences == seqStore->sequencesStart);   /* no ldm */
-    assert(ms->window.dictLimit == ms->window.lowLimit);   /* no dictionary */
-    assert(ms->window.dictLimit - ms->nextToUpdate <= 1);  /* no prefix (note: intentional overflow, defined as 2-complement) */
-
+ 
+    DEBUGLOG(4, "ZSTD_initStats_ultra (srcSize=%zu)", srcSize); 
+    assert(ms->opt.litLengthSum == 0);    /* first block */ 
+    assert(seqStore->sequences == seqStore->sequencesStart);   /* no ldm */ 
+    assert(ms->window.dictLimit == ms->window.lowLimit);   /* no dictionary */ 
+    assert(ms->window.dictLimit - ms->nextToUpdate <= 1);  /* no prefix (note: intentional overflow, defined as 2-complement) */ 
+ 
     ZSTD_compressBlock_opt2(ms, seqStore, tmpRep, src, srcSize, ZSTD_noDict);   /* generate stats into ms->opt*/
-
-    /* invalidate first scan from history */
-    ZSTD_resetSeqStore(seqStore);
-    ms->window.base -= srcSize;
-    ms->window.dictLimit += (U32)srcSize;
-    ms->window.lowLimit = ms->window.dictLimit;
-    ms->nextToUpdate = ms->window.dictLimit;
-
-}
-
+ 
+    /* invalidate first scan from history */ 
+    ZSTD_resetSeqStore(seqStore); 
+    ms->window.base -= srcSize; 
+    ms->window.dictLimit += (U32)srcSize; 
+    ms->window.lowLimit = ms->window.dictLimit; 
+    ms->nextToUpdate = ms->window.dictLimit; 
+ 
+} 
+ 
 size_t ZSTD_compressBlock_btultra(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize)
+        const void* src, size_t srcSize) 
 {
-    DEBUGLOG(5, "ZSTD_compressBlock_btultra (srcSize=%zu)", srcSize);
+    DEBUGLOG(5, "ZSTD_compressBlock_btultra (srcSize=%zu)", srcSize); 
     return ZSTD_compressBlock_opt2(ms, seqStore, rep, src, srcSize, ZSTD_noDict);
 }
 
-size_t ZSTD_compressBlock_btultra2(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize)
-{
+size_t ZSTD_compressBlock_btultra2( 
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+        const void* src, size_t srcSize) 
+{ 
     U32 const curr = (U32)((const BYTE*)src - ms->window.base);
-    DEBUGLOG(5, "ZSTD_compressBlock_btultra2 (srcSize=%zu)", srcSize);
-
-    /* 2-pass strategy:
-     * this strategy makes a first pass over first block to collect statistics
-     * and seed next round's statistics with it.
-     * After 1st pass, function forgets everything, and starts a new block.
-     * Consequently, this can only work if no data has been previously loaded in tables,
-     * aka, no dictionary, no prefix, no ldm preprocessing.
-     * The compression ratio gain is generally small (~0.5% on first block),
-     * the cost is 2x cpu time on first block. */
-    assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
-    if ( (ms->opt.litLengthSum==0)   /* first block */
-      && (seqStore->sequences == seqStore->sequencesStart)  /* no ldm */
-      && (ms->window.dictLimit == ms->window.lowLimit)   /* no dictionary */
+    DEBUGLOG(5, "ZSTD_compressBlock_btultra2 (srcSize=%zu)", srcSize); 
+ 
+    /* 2-pass strategy: 
+     * this strategy makes a first pass over first block to collect statistics 
+     * and seed next round's statistics with it. 
+     * After 1st pass, function forgets everything, and starts a new block. 
+     * Consequently, this can only work if no data has been previously loaded in tables, 
+     * aka, no dictionary, no prefix, no ldm preprocessing. 
+     * The compression ratio gain is generally small (~0.5% on first block), 
+     * the cost is 2x cpu time on first block. */ 
+    assert(srcSize <= ZSTD_BLOCKSIZE_MAX); 
+    if ( (ms->opt.litLengthSum==0)   /* first block */ 
+      && (seqStore->sequences == seqStore->sequencesStart)  /* no ldm */ 
+      && (ms->window.dictLimit == ms->window.lowLimit)   /* no dictionary */ 
       && (curr == ms->window.dictLimit)   /* start of frame, nothing already loaded nor skipped */
-      && (srcSize > ZSTD_PREDEF_THRESHOLD)
-      ) {
-        ZSTD_initStats_ultra(ms, seqStore, rep, src, srcSize);
-    }
-
+      && (srcSize > ZSTD_PREDEF_THRESHOLD) 
+      ) { 
+        ZSTD_initStats_ultra(ms, seqStore, rep, src, srcSize); 
+    } 
+ 
     return ZSTD_compressBlock_opt2(ms, seqStore, rep, src, srcSize, ZSTD_noDict);
-}
-
-size_t ZSTD_compressBlock_btopt_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize)
-{
+} 
+ 
+size_t ZSTD_compressBlock_btopt_dictMatchState( 
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+        const void* src, size_t srcSize) 
+{ 
     return ZSTD_compressBlock_opt0(ms, seqStore, rep, src, srcSize, ZSTD_dictMatchState);
-}
-
-size_t ZSTD_compressBlock_btultra_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize)
-{
+} 
+ 
+size_t ZSTD_compressBlock_btultra_dictMatchState( 
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+        const void* src, size_t srcSize) 
+{ 
     return ZSTD_compressBlock_opt2(ms, seqStore, rep, src, srcSize, ZSTD_dictMatchState);
-}
-
+} 
+ 
 size_t ZSTD_compressBlock_btopt_extDict(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize)
+        const void* src, size_t srcSize) 
 {
     return ZSTD_compressBlock_opt0(ms, seqStore, rep, src, srcSize, ZSTD_extDict);
 }
 
 size_t ZSTD_compressBlock_btultra_extDict(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        const void* src, size_t srcSize)
+        const void* src, size_t srcSize) 
 {
     return ZSTD_compressBlock_opt2(ms, seqStore, rep, src, srcSize, ZSTD_extDict);
 }
-
-/* note : no btultra2 variant for extDict nor dictMatchState,
- * because btultra2 is not meant to work with dictionaries
- * and is only specific for the first block (no prefix) */
+ 
+/* note : no btultra2 variant for extDict nor dictMatchState, 
+ * because btultra2 is not meant to work with dictionaries 
+ * and is only specific for the first block (no prefix) */ 
diff --git a/contrib/libs/zstd/lib/compress/zstd_opt.h b/contrib/libs/zstd/lib/compress/zstd_opt.h
index 627255f53de..dae2f849124 100644
--- a/contrib/libs/zstd/lib/compress/zstd_opt.h
+++ b/contrib/libs/zstd/lib/compress/zstd_opt.h
@@ -17,38 +17,38 @@ extern "C" {
 
 #include "zstd_compress_internal.h"
 
-/* used in ZSTD_loadDictionaryContent() */
-void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend);
+/* used in ZSTD_loadDictionaryContent() */ 
+void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend); 
 
 size_t ZSTD_compressBlock_btopt(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
+        void const* src, size_t srcSize); 
 size_t ZSTD_compressBlock_btultra(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_btultra2(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-
-
-size_t ZSTD_compressBlock_btopt_dictMatchState(
-        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-size_t ZSTD_compressBlock_btultra_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); 
+size_t ZSTD_compressBlock_btultra2( 
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+        void const* src, size_t srcSize); 
+
+ 
+size_t ZSTD_compressBlock_btopt_dictMatchState( 
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+        void const* src, size_t srcSize); 
+size_t ZSTD_compressBlock_btultra_dictMatchState( 
+        ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+        void const* src, size_t srcSize); 
+ 
 size_t ZSTD_compressBlock_btopt_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); 
 size_t ZSTD_compressBlock_btultra_extDict(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
-        void const* src, size_t srcSize);
-
-        /* note : no btultra2 variant for extDict nor dictMatchState,
-         * because btultra2 is not meant to work with dictionaries
-         * and is only specific for the first block (no prefix) */
+        void const* src, size_t srcSize); 
 
+        /* note : no btultra2 variant for extDict nor dictMatchState, 
+         * because btultra2 is not meant to work with dictionaries 
+         * and is only specific for the first block (no prefix) */ 
+ 
 #if defined (__cplusplus)
 }
 #endif
diff --git a/contrib/libs/zstd/lib/compress/zstdmt_compress.c b/contrib/libs/zstd/lib/compress/zstdmt_compress.c
index 6bc14b035e1..4f44037d2c2 100644
--- a/contrib/libs/zstd/lib/compress/zstdmt_compress.c
+++ b/contrib/libs/zstd/lib/compress/zstdmt_compress.c
@@ -15,10 +15,10 @@
 #endif
 
 
-/* ======   Constants   ====== */
-#define ZSTDMT_OVERLAPLOG_DEFAULT 0
-
-
+/* ======   Constants   ====== */ 
+#define ZSTDMT_OVERLAPLOG_DEFAULT 0 
+ 
+ 
 /* ======   Dependencies   ====== */
 #include "../common/zstd_deps.h"   /* ZSTD_memcpy, ZSTD_memset, INT_MAX, UINT_MAX */
 #include "../common/mem.h"         /* MEM_STATIC */
@@ -35,9 +35,9 @@
 #define ZSTD_RESIZE_SEQPOOL 0
 
 /* ======   Debug   ====== */
-#if defined(DEBUGLEVEL) && (DEBUGLEVEL>=2) \
-    && !defined(_MSC_VER) \
-    && !defined(__MINGW32__)
+#if defined(DEBUGLEVEL) && (DEBUGLEVEL>=2) \ 
+    && !defined(_MSC_VER) \ 
+    && !defined(__MINGW32__) 
 
 #  include <stdio.h>
 #  include <unistd.h>
@@ -46,8 +46,8 @@
 #  define DEBUG_PRINTHEX(l,p,n) {            \
     unsigned debug_u;                        \
     for (debug_u=0; debug_u<(n); debug_u++)  \
-        RAWLOG(l, "%02X ", ((const unsigned char*)(p))[debug_u]); \
-    RAWLOG(l, " \n");                        \
+        RAWLOG(l, "%02X ", ((const unsigned char*)(p))[debug_u]); \ 
+    RAWLOG(l, " \n");                        \ 
 }
 
 static unsigned long long GetCurrentClockTimeMicroseconds(void)
@@ -55,13 +55,13 @@ static unsigned long long GetCurrentClockTimeMicroseconds(void)
    static clock_t _ticksPerSecond = 0;
    if (_ticksPerSecond <= 0) _ticksPerSecond = sysconf(_SC_CLK_TCK);
 
-   {   struct tms junk; clock_t newTicks = (clock_t) times(&junk);
-       return ((((unsigned long long)newTicks)*(1000000))/_ticksPerSecond);
-}  }
+   {   struct tms junk; clock_t newTicks = (clock_t) times(&junk); 
+       return ((((unsigned long long)newTicks)*(1000000))/_ticksPerSecond); 
+}  } 
 
 #define MUTEX_WAIT_TIME_DLEVEL 6
 #define ZSTD_PTHREAD_MUTEX_LOCK(mutex) {          \
-    if (DEBUGLEVEL >= MUTEX_WAIT_TIME_DLEVEL) {   \
+    if (DEBUGLEVEL >= MUTEX_WAIT_TIME_DLEVEL) {   \ 
         unsigned long long const beforeTime = GetCurrentClockTimeMicroseconds(); \
         ZSTD_pthread_mutex_lock(mutex);           \
         {   unsigned long long const afterTime = GetCurrentClockTimeMicroseconds(); \
@@ -158,24 +158,24 @@ static void ZSTDMT_setBufferSize(ZSTDMT_bufferPool* const bufPool, size_t const
     ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);
 }
 
-
+ 
 static ZSTDMT_bufferPool* ZSTDMT_expandBufferPool(ZSTDMT_bufferPool* srcBufPool, unsigned maxNbBuffers)
-{
-    if (srcBufPool==NULL) return NULL;
-    if (srcBufPool->totalBuffers >= maxNbBuffers) /* good enough */
-        return srcBufPool;
-    /* need a larger buffer pool */
-    {   ZSTD_customMem const cMem = srcBufPool->cMem;
-        size_t const bSize = srcBufPool->bufferSize;   /* forward parameters */
-        ZSTDMT_bufferPool* newBufPool;
-        ZSTDMT_freeBufferPool(srcBufPool);
+{ 
+    if (srcBufPool==NULL) return NULL; 
+    if (srcBufPool->totalBuffers >= maxNbBuffers) /* good enough */ 
+        return srcBufPool; 
+    /* need a larger buffer pool */ 
+    {   ZSTD_customMem const cMem = srcBufPool->cMem; 
+        size_t const bSize = srcBufPool->bufferSize;   /* forward parameters */ 
+        ZSTDMT_bufferPool* newBufPool; 
+        ZSTDMT_freeBufferPool(srcBufPool); 
         newBufPool = ZSTDMT_createBufferPool(maxNbBuffers, cMem);
-        if (newBufPool==NULL) return newBufPool;
-        ZSTDMT_setBufferSize(newBufPool, bSize);
-        return newBufPool;
-    }
-}
-
+        if (newBufPool==NULL) return newBufPool; 
+        ZSTDMT_setBufferSize(newBufPool, bSize); 
+        return newBufPool; 
+    } 
+} 
+ 
 /** ZSTDMT_getBuffer() :
  *  assumption : bufPool must be valid
  * @return : a buffer, with start pointer and size
@@ -245,7 +245,7 @@ static buffer_t ZSTDMT_resizeBuffer(ZSTDMT_bufferPool* bufPool, buffer_t buffer)
 /* store buffer for later re-use, up to pool capacity */
 static void ZSTDMT_releaseBuffer(ZSTDMT_bufferPool* bufPool, buffer_t buf)
 {
-    DEBUGLOG(5, "ZSTDMT_releaseBuffer");
+    DEBUGLOG(5, "ZSTDMT_releaseBuffer"); 
     if (buf.start == NULL) return;   /* compatible with release on NULL */
     ZSTD_pthread_mutex_lock(&bufPool->poolMutex);
     if (bufPool->nbBuffers < bufPool->totalBuffers) {
@@ -325,7 +325,7 @@ static void ZSTDMT_setNbSeq(ZSTDMT_seqPool* const seqPool, size_t const nbSeq)
 static ZSTDMT_seqPool* ZSTDMT_createSeqPool(unsigned nbWorkers, ZSTD_customMem cMem)
 {
     ZSTDMT_seqPool* const seqPool = ZSTDMT_createBufferPool(SEQ_POOL_MAX_NB_BUFFERS(nbWorkers), cMem);
-    if (seqPool == NULL) return NULL;
+    if (seqPool == NULL) return NULL; 
     ZSTDMT_setNbSeq(seqPool, 0);
     return seqPool;
 }
@@ -335,10 +335,10 @@ static void ZSTDMT_freeSeqPool(ZSTDMT_seqPool* seqPool)
     ZSTDMT_freeBufferPool(seqPool);
 }
 
-static ZSTDMT_seqPool* ZSTDMT_expandSeqPool(ZSTDMT_seqPool* pool, U32 nbWorkers)
-{
+static ZSTDMT_seqPool* ZSTDMT_expandSeqPool(ZSTDMT_seqPool* pool, U32 nbWorkers) 
+{ 
     return ZSTDMT_expandBufferPool(pool, SEQ_POOL_MAX_NB_BUFFERS(nbWorkers));
-}
+} 
 
 
 /* =====   CCtx Pool   ===== */
@@ -346,8 +346,8 @@ static ZSTDMT_seqPool* ZSTDMT_expandSeqPool(ZSTDMT_seqPool* pool, U32 nbWorkers)
 
 typedef struct {
     ZSTD_pthread_mutex_t poolMutex;
-    int totalCCtx;
-    int availCCtx;
+    int totalCCtx; 
+    int availCCtx; 
     ZSTD_customMem cMem;
     ZSTD_CCtx* cctx[1];   /* variable size */
 } ZSTDMT_CCtxPool;
@@ -355,16 +355,16 @@ typedef struct {
 /* note : all CCtx borrowed from the pool should be released back to the pool _before_ freeing the pool */
 static void ZSTDMT_freeCCtxPool(ZSTDMT_CCtxPool* pool)
 {
-    int cid;
-    for (cid=0; cid<pool->totalCCtx; cid++)
-        ZSTD_freeCCtx(pool->cctx[cid]);  /* note : compatible with free on NULL */
+    int cid; 
+    for (cid=0; cid<pool->totalCCtx; cid++) 
+        ZSTD_freeCCtx(pool->cctx[cid]);  /* note : compatible with free on NULL */ 
     ZSTD_pthread_mutex_destroy(&pool->poolMutex);
     ZSTD_customFree(pool, pool->cMem);
 }
 
 /* ZSTDMT_createCCtxPool() :
  * implies nbWorkers >= 1 , checked by caller ZSTDMT_createCCtx() */
-static ZSTDMT_CCtxPool* ZSTDMT_createCCtxPool(int nbWorkers,
+static ZSTDMT_CCtxPool* ZSTDMT_createCCtxPool(int nbWorkers, 
                                               ZSTD_customMem cMem)
 {
     ZSTDMT_CCtxPool* const cctxPool = (ZSTDMT_CCtxPool*) ZSTD_customCalloc(
@@ -384,18 +384,18 @@ static ZSTDMT_CCtxPool* ZSTDMT_createCCtxPool(int nbWorkers,
     return cctxPool;
 }
 
-static ZSTDMT_CCtxPool* ZSTDMT_expandCCtxPool(ZSTDMT_CCtxPool* srcPool,
-                                              int nbWorkers)
-{
-    if (srcPool==NULL) return NULL;
-    if (nbWorkers <= srcPool->totalCCtx) return srcPool;   /* good enough */
-    /* need a larger cctx pool */
-    {   ZSTD_customMem const cMem = srcPool->cMem;
-        ZSTDMT_freeCCtxPool(srcPool);
-        return ZSTDMT_createCCtxPool(nbWorkers, cMem);
-    }
-}
-
+static ZSTDMT_CCtxPool* ZSTDMT_expandCCtxPool(ZSTDMT_CCtxPool* srcPool, 
+                                              int nbWorkers) 
+{ 
+    if (srcPool==NULL) return NULL; 
+    if (nbWorkers <= srcPool->totalCCtx) return srcPool;   /* good enough */ 
+    /* need a larger cctx pool */ 
+    {   ZSTD_customMem const cMem = srcPool->cMem; 
+        ZSTDMT_freeCCtxPool(srcPool); 
+        return ZSTDMT_createCCtxPool(nbWorkers, cMem); 
+    } 
+} 
+ 
 /* only works during initialization phase, not during compression */
 static size_t ZSTDMT_sizeof_CCtxPool(ZSTDMT_CCtxPool* cctxPool)
 {
@@ -462,7 +462,7 @@ typedef struct {
      * Must be acquired after the main mutex when acquiring both.
      */
     ZSTD_pthread_mutex_t ldmWindowMutex;
-    ZSTD_pthread_cond_t ldmWindowCond;  /* Signaled when ldmWindow is updated */
+    ZSTD_pthread_cond_t ldmWindowCond;  /* Signaled when ldmWindow is updated */ 
     ZSTD_window_t ldmWindow;  /* A thread-safe copy of ldmState.window */
 } serialState_t;
 
@@ -479,7 +479,7 @@ ZSTDMT_serialState_reset(serialState_t* serialState,
         DEBUGLOG(4, "LDM window size = %u KB", (1U << params.cParams.windowLog) >> 10);
         ZSTD_ldm_adjustParameters(&params.ldmParams, &params.cParams);
         assert(params.ldmParams.hashLog >= params.ldmParams.bucketSizeLog);
-        assert(params.ldmParams.hashRateLog < 32);
+        assert(params.ldmParams.hashRateLog < 32); 
     } else {
         ZSTD_memset(&params.ldmParams, 0, sizeof(params.ldmParams));
     }
@@ -497,7 +497,7 @@ ZSTDMT_serialState_reset(serialState_t* serialState,
             serialState->params.ldmParams.bucketSizeLog;
         size_t const numBuckets = (size_t)1 << bucketLog;
         /* Size the seq pool tables */
-        ZSTDMT_setNbSeq(seqPool, ZSTD_ldm_getMaxNbSeq(params.ldmParams, jobSize));
+        ZSTDMT_setNbSeq(seqPool, ZSTD_ldm_getMaxNbSeq(params.ldmParams, jobSize)); 
         /* Reset the window */
         ZSTD_window_init(&serialState->ldmState.window);
         /* Resize tables and output space if necessary. */
@@ -533,7 +533,7 @@ ZSTDMT_serialState_reset(serialState_t* serialState,
     }
 
     serialState->params = params;
-    serialState->params.jobSize = (U32)jobSize;
+    serialState->params.jobSize = (U32)jobSize; 
     return 0;
 }
 
@@ -566,7 +566,7 @@ static void ZSTDMT_serialState_update(serialState_t* serialState,
     /* Wait for our turn */
     ZSTD_PTHREAD_MUTEX_LOCK(&serialState->mutex);
     while (serialState->nextJobID < jobID) {
-        DEBUGLOG(5, "wait for serialState->cond");
+        DEBUGLOG(5, "wait for serialState->cond"); 
         ZSTD_pthread_cond_wait(&serialState->cond, &serialState->mutex);
     }
     /* A future job may error and skip our job */
@@ -576,7 +576,7 @@ static void ZSTDMT_serialState_update(serialState_t* serialState,
             size_t error;
             assert(seqStore.seq != NULL && seqStore.pos == 0 &&
                    seqStore.size == 0 && seqStore.capacity > 0);
-            assert(src.size <= serialState->params.jobSize);
+            assert(src.size <= serialState->params.jobSize); 
             ZSTD_window_update(&serialState->ldmState.window, src.start, src.size, /* forceNonContiguous */ 0);
             error = ZSTD_ldm_generateSequences(
                 &serialState->ldmState, &seqStore,
@@ -656,33 +656,33 @@ typedef struct {
     unsigned frameChecksumNeeded;        /* used only by mtctx */
 } ZSTDMT_jobDescription;
 
-#define JOB_ERROR(e) {                          \
-    ZSTD_PTHREAD_MUTEX_LOCK(&job->job_mutex);   \
-    job->cSize = e;                             \
-    ZSTD_pthread_mutex_unlock(&job->job_mutex); \
-    goto _endJob;                               \
-}
-
+#define JOB_ERROR(e) {                          \ 
+    ZSTD_PTHREAD_MUTEX_LOCK(&job->job_mutex);   \ 
+    job->cSize = e;                             \ 
+    ZSTD_pthread_mutex_unlock(&job->job_mutex); \ 
+    goto _endJob;                               \ 
+} 
+ 
 /* ZSTDMT_compressionJob() is a POOL_function type */
-static void ZSTDMT_compressionJob(void* jobDescription)
+static void ZSTDMT_compressionJob(void* jobDescription) 
 {
     ZSTDMT_jobDescription* const job = (ZSTDMT_jobDescription*)jobDescription;
     ZSTD_CCtx_params jobParams = job->params;   /* do not modify job->params ! copy it, modify the copy */
     ZSTD_CCtx* const cctx = ZSTDMT_getCCtx(job->cctxPool);
     rawSeqStore_t rawSeqStore = ZSTDMT_getSeq(job->seqPool);
     buffer_t dstBuff = job->dstBuff;
-    size_t lastCBlockSize = 0;
-
-    /* resources */
-    if (cctx==NULL) JOB_ERROR(ERROR(memory_allocation));
-    if (dstBuff.start == NULL) {   /* streaming job : doesn't provide a dstBuffer */
-        dstBuff = ZSTDMT_getBuffer(job->bufPool);
-        if (dstBuff.start==NULL) JOB_ERROR(ERROR(memory_allocation));
-        job->dstBuff = dstBuff;   /* this value can be read in ZSTDMT_flush, when it copies the whole job */
-    }
+    size_t lastCBlockSize = 0; 
+
+    /* resources */ 
+    if (cctx==NULL) JOB_ERROR(ERROR(memory_allocation)); 
+    if (dstBuff.start == NULL) {   /* streaming job : doesn't provide a dstBuffer */ 
+        dstBuff = ZSTDMT_getBuffer(job->bufPool); 
+        if (dstBuff.start==NULL) JOB_ERROR(ERROR(memory_allocation)); 
+        job->dstBuff = dstBuff;   /* this value can be read in ZSTDMT_flush, when it copies the whole job */ 
+    } 
     if (jobParams.ldmParams.enableLdm == ZSTD_ps_enable && rawSeqStore.seq == NULL)
-        JOB_ERROR(ERROR(memory_allocation));
-
+        JOB_ERROR(ERROR(memory_allocation)); 
+ 
     /* Don't compute the checksum for chunks, since we compute it externally,
      * but write it in the header.
      */
@@ -697,30 +697,30 @@ static void ZSTDMT_compressionJob(void* jobDescription)
     if (job->cdict) {
         size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, NULL, 0, ZSTD_dct_auto, ZSTD_dtlm_fast, job->cdict, &jobParams, job->fullFrameSize);
         assert(job->firstJob);  /* only allowed for first job */
-        if (ZSTD_isError(initError)) JOB_ERROR(initError);
+        if (ZSTD_isError(initError)) JOB_ERROR(initError); 
     } else {  /* srcStart points at reloaded section */
         U64 const pledgedSrcSize = job->firstJob ? job->fullFrameSize : job->src.size;
-        {   size_t const forceWindowError = ZSTD_CCtxParams_setParameter(&jobParams, ZSTD_c_forceMaxWindow, !job->firstJob);
-            if (ZSTD_isError(forceWindowError)) JOB_ERROR(forceWindowError);
-        }
+        {   size_t const forceWindowError = ZSTD_CCtxParams_setParameter(&jobParams, ZSTD_c_forceMaxWindow, !job->firstJob); 
+            if (ZSTD_isError(forceWindowError)) JOB_ERROR(forceWindowError); 
+        } 
         if (!job->firstJob) {
             size_t const err = ZSTD_CCtxParams_setParameter(&jobParams, ZSTD_c_deterministicRefPrefix, 0);
             if (ZSTD_isError(err)) JOB_ERROR(err);
         }
         {   size_t const initError = ZSTD_compressBegin_advanced_internal(cctx,
                                         job->prefix.start, job->prefix.size, ZSTD_dct_rawContent, /* load dictionary in "content-only" mode (no header analysis) */
-                                        ZSTD_dtlm_fast,
+                                        ZSTD_dtlm_fast, 
                                         NULL, /*cdict*/
                                         &jobParams, pledgedSrcSize);
-            if (ZSTD_isError(initError)) JOB_ERROR(initError);
-    }   }
+            if (ZSTD_isError(initError)) JOB_ERROR(initError); 
+    }   } 
 
     /* Perform serial step as early as possible, but after CCtx initialization */
     ZSTDMT_serialState_update(job->serial, cctx, rawSeqStore, job->src, job->jobID);
 
     if (!job->firstJob) {  /* flush and overwrite frame header when it's not first job */
         size_t const hSize = ZSTD_compressContinue(cctx, dstBuff.start, dstBuff.capacity, job->src.start, 0);
-        if (ZSTD_isError(hSize)) JOB_ERROR(hSize);
+        if (ZSTD_isError(hSize)) JOB_ERROR(hSize); 
         DEBUGLOG(5, "ZSTDMT_compressionJob: flush and overwrite %u bytes of frame header (not first job)", (U32)hSize);
         ZSTD_invalidateRepCodes(cctx);
     }
@@ -738,7 +738,7 @@ static void ZSTDMT_compressionJob(void* jobDescription)
         assert(job->cSize == 0);
         for (chunkNb = 1; chunkNb < nbChunks; chunkNb++) {
             size_t const cSize = ZSTD_compressContinue(cctx, op, oend-op, ip, chunkSize);
-            if (ZSTD_isError(cSize)) JOB_ERROR(cSize);
+            if (ZSTD_isError(cSize)) JOB_ERROR(cSize); 
             ip += chunkSize;
             op += cSize; assert(op < oend);
             /* stats */
@@ -751,16 +751,16 @@ static void ZSTDMT_compressionJob(void* jobDescription)
             ZSTD_pthread_mutex_unlock(&job->job_mutex);
         }
         /* last block */
-        assert(chunkSize > 0);
-        assert((chunkSize & (chunkSize - 1)) == 0);  /* chunkSize must be power of 2 for mask==(chunkSize-1) to work */
+        assert(chunkSize > 0); 
+        assert((chunkSize & (chunkSize - 1)) == 0);  /* chunkSize must be power of 2 for mask==(chunkSize-1) to work */ 
         if ((nbChunks > 0) | job->lastJob /*must output a "last block" flag*/ ) {
             size_t const lastBlockSize1 = job->src.size & (chunkSize-1);
             size_t const lastBlockSize = ((lastBlockSize1==0) & (job->src.size>=chunkSize)) ? chunkSize : lastBlockSize1;
             size_t const cSize = (job->lastJob) ?
                  ZSTD_compressEnd     (cctx, op, oend-op, ip, lastBlockSize) :
                  ZSTD_compressContinue(cctx, op, oend-op, ip, lastBlockSize);
-            if (ZSTD_isError(cSize)) JOB_ERROR(cSize);
-            lastCBlockSize = cSize;
+            if (ZSTD_isError(cSize)) JOB_ERROR(cSize); 
+            lastCBlockSize = cSize; 
     }   }
     if (!job->firstJob) {
         /* Double check that we don't have an ext-dict, because then our
@@ -780,9 +780,9 @@ _endJob:
     ZSTDMT_releaseCCtx(job->cctxPool, cctx);
     /* report */
     ZSTD_PTHREAD_MUTEX_LOCK(&job->job_mutex);
-    if (ZSTD_isError(job->cSize)) assert(lastCBlockSize == 0);
-    job->cSize += lastCBlockSize;
-    job->consumed = job->src.size;  /* when job->consumed == job->src.size , compression job is presumed completed */
+    if (ZSTD_isError(job->cSize)) assert(lastCBlockSize == 0); 
+    job->cSize += lastCBlockSize; 
+    job->consumed = job->src.size;  /* when job->consumed == job->src.size , compression job is presumed completed */ 
     ZSTD_pthread_cond_signal(&job->job_cond);
     ZSTD_pthread_mutex_unlock(&job->job_mutex);
 }
@@ -814,7 +814,7 @@ typedef struct {
 
 static const roundBuff_t kNullRoundBuff = {NULL, 0, 0};
 
-#define RSYNC_LENGTH 32
+#define RSYNC_LENGTH 32 
 /* Don't create chunks smaller than the zstd block size.
  * This stops us from regressing compression ratio too much,
  * and ensures our output fits in ZSTD_compressBound().
@@ -824,13 +824,13 @@ static const roundBuff_t kNullRoundBuff = {NULL, 0, 0};
  */
 #define RSYNC_MIN_BLOCK_LOG ZSTD_BLOCKSIZELOG_MAX
 #define RSYNC_MIN_BLOCK_SIZE (1<<RSYNC_MIN_BLOCK_LOG)
-
-typedef struct {
-  U64 hash;
-  U64 hitMask;
-  U64 primePower;
-} rsyncState_t;
-
+ 
+typedef struct { 
+  U64 hash; 
+  U64 hitMask; 
+  U64 primePower; 
+} rsyncState_t; 
+ 
 struct ZSTDMT_CCtx_s {
     POOL_ctx* factory;
     ZSTDMT_jobDescription* jobs;
@@ -840,11 +840,11 @@ struct ZSTDMT_CCtx_s {
     ZSTD_CCtx_params params;
     size_t targetSectionSize;
     size_t targetPrefixSize;
-    int jobReady;        /* 1 => one job is already prepared, but pool has shortage of workers. Don't create a new job. */
-    inBuff_t inBuff;
+    int jobReady;        /* 1 => one job is already prepared, but pool has shortage of workers. Don't create a new job. */ 
+    inBuff_t inBuff; 
     roundBuff_t roundBuff;
     serialState_t serial;
-    rsyncState_t rsync;
+    rsyncState_t rsync; 
     unsigned jobIDMask;
     unsigned doneJobID;
     unsigned nextJobID;
@@ -894,25 +894,25 @@ static ZSTDMT_jobDescription* ZSTDMT_createJobsTable(U32* nbJobsPtr, ZSTD_custom
     return jobTable;
 }
 
-static size_t ZSTDMT_expandJobsTable (ZSTDMT_CCtx* mtctx, U32 nbWorkers) {
-    U32 nbJobs = nbWorkers + 2;
-    if (nbJobs > mtctx->jobIDMask+1) {  /* need more job capacity */
-        ZSTDMT_freeJobsTable(mtctx->jobs, mtctx->jobIDMask+1, mtctx->cMem);
-        mtctx->jobIDMask = 0;
-        mtctx->jobs = ZSTDMT_createJobsTable(&nbJobs, mtctx->cMem);
-        if (mtctx->jobs==NULL) return ERROR(memory_allocation);
-        assert((nbJobs != 0) && ((nbJobs & (nbJobs - 1)) == 0));  /* ensure nbJobs is a power of 2 */
-        mtctx->jobIDMask = nbJobs - 1;
-    }
-    return 0;
-}
-
-
+static size_t ZSTDMT_expandJobsTable (ZSTDMT_CCtx* mtctx, U32 nbWorkers) { 
+    U32 nbJobs = nbWorkers + 2; 
+    if (nbJobs > mtctx->jobIDMask+1) {  /* need more job capacity */ 
+        ZSTDMT_freeJobsTable(mtctx->jobs, mtctx->jobIDMask+1, mtctx->cMem); 
+        mtctx->jobIDMask = 0; 
+        mtctx->jobs = ZSTDMT_createJobsTable(&nbJobs, mtctx->cMem); 
+        if (mtctx->jobs==NULL) return ERROR(memory_allocation); 
+        assert((nbJobs != 0) && ((nbJobs & (nbJobs - 1)) == 0));  /* ensure nbJobs is a power of 2 */ 
+        mtctx->jobIDMask = nbJobs - 1; 
+    } 
+    return 0; 
+} 
+ 
+ 
 /* ZSTDMT_CCtxParam_setNbWorkers():
  * Internal use only */
 static size_t ZSTDMT_CCtxParam_setNbWorkers(ZSTD_CCtx_params* params, unsigned nbWorkers)
 {
-    return ZSTD_CCtxParams_setParameter(params, ZSTD_c_nbWorkers, (int)nbWorkers);
+    return ZSTD_CCtxParams_setParameter(params, ZSTD_c_nbWorkers, (int)nbWorkers); 
 }
 
 MEM_STATIC ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced_internal(unsigned nbWorkers, ZSTD_customMem cMem, ZSTD_threadPool* pool)
@@ -958,17 +958,17 @@ MEM_STATIC ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced_internal(unsigned nbWorkers,
 }
 
 ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbWorkers, ZSTD_customMem cMem, ZSTD_threadPool* pool)
-{
-#ifdef ZSTD_MULTITHREAD
+{ 
+#ifdef ZSTD_MULTITHREAD 
     return ZSTDMT_createCCtx_advanced_internal(nbWorkers, cMem, pool);
-#else
-    (void)nbWorkers;
-    (void)cMem;
+#else 
+    (void)nbWorkers; 
+    (void)cMem; 
     (void)pool;
-    return NULL;
-#endif
-}
-
+    return NULL; 
+#endif 
+} 
+ 
 
 /* ZSTDMT_releaseAllJobResources() :
  * note : ensure all workers are killed first ! */
@@ -1001,7 +1001,7 @@ static void ZSTDMT_waitForAllJobsCompleted(ZSTDMT_CCtx* mtctx)
         unsigned const jobID = mtctx->doneJobID & mtctx->jobIDMask;
         ZSTD_PTHREAD_MUTEX_LOCK(&mtctx->jobs[jobID].job_mutex);
         while (mtctx->jobs[jobID].consumed < mtctx->jobs[jobID].src.size) {
-            DEBUGLOG(4, "waiting for jobCompleted signal from job %u", mtctx->doneJobID);   /* we want to block when waiting for data to flush */
+            DEBUGLOG(4, "waiting for jobCompleted signal from job %u", mtctx->doneJobID);   /* we want to block when waiting for data to flush */ 
             ZSTD_pthread_cond_wait(&mtctx->jobs[jobID].job_cond, &mtctx->jobs[jobID].job_mutex);
         }
         ZSTD_pthread_mutex_unlock(&mtctx->jobs[jobID].job_mutex);
@@ -1041,25 +1041,25 @@ size_t ZSTDMT_sizeof_CCtx(ZSTDMT_CCtx* mtctx)
 }
 
 
-/* ZSTDMT_resize() :
- * @return : error code if fails, 0 on success */
-static size_t ZSTDMT_resize(ZSTDMT_CCtx* mtctx, unsigned nbWorkers)
-{
-    if (POOL_resize(mtctx->factory, nbWorkers)) return ERROR(memory_allocation);
+/* ZSTDMT_resize() : 
+ * @return : error code if fails, 0 on success */ 
+static size_t ZSTDMT_resize(ZSTDMT_CCtx* mtctx, unsigned nbWorkers) 
+{ 
+    if (POOL_resize(mtctx->factory, nbWorkers)) return ERROR(memory_allocation); 
     FORWARD_IF_ERROR( ZSTDMT_expandJobsTable(mtctx, nbWorkers) , "");
     mtctx->bufPool = ZSTDMT_expandBufferPool(mtctx->bufPool, BUF_POOL_MAX_NB_BUFFERS(nbWorkers));
-    if (mtctx->bufPool == NULL) return ERROR(memory_allocation);
-    mtctx->cctxPool = ZSTDMT_expandCCtxPool(mtctx->cctxPool, nbWorkers);
-    if (mtctx->cctxPool == NULL) return ERROR(memory_allocation);
-    mtctx->seqPool = ZSTDMT_expandSeqPool(mtctx->seqPool, nbWorkers);
-    if (mtctx->seqPool == NULL) return ERROR(memory_allocation);
-    ZSTDMT_CCtxParam_setNbWorkers(&mtctx->params, nbWorkers);
-    return 0;
+    if (mtctx->bufPool == NULL) return ERROR(memory_allocation); 
+    mtctx->cctxPool = ZSTDMT_expandCCtxPool(mtctx->cctxPool, nbWorkers); 
+    if (mtctx->cctxPool == NULL) return ERROR(memory_allocation); 
+    mtctx->seqPool = ZSTDMT_expandSeqPool(mtctx->seqPool, nbWorkers); 
+    if (mtctx->seqPool == NULL) return ERROR(memory_allocation); 
+    ZSTDMT_CCtxParam_setNbWorkers(&mtctx->params, nbWorkers); 
+    return 0; 
 }
 
-
+ 
 /*! ZSTDMT_updateCParams_whileCompressing() :
- *  Updates a selected set of compression parameters, remaining compatible with currently active frame.
+ *  Updates a selected set of compression parameters, remaining compatible with currently active frame. 
  *  New parameters will be applied to next compression job. */
 void ZSTDMT_updateCParams_whileCompressing(ZSTDMT_CCtx* mtctx, const ZSTD_CCtx_params* cctxParams)
 {
@@ -1077,33 +1077,33 @@ void ZSTDMT_updateCParams_whileCompressing(ZSTDMT_CCtx* mtctx, const ZSTD_CCtx_p
 /* ZSTDMT_getFrameProgression():
  * tells how much data has been consumed (input) and produced (output) for current frame.
  * able to count progression inside worker threads.
- * Note : mutex will be acquired during statistics collection inside workers. */
+ * Note : mutex will be acquired during statistics collection inside workers. */ 
 ZSTD_frameProgression ZSTDMT_getFrameProgression(ZSTDMT_CCtx* mtctx)
 {
     ZSTD_frameProgression fps;
-    DEBUGLOG(5, "ZSTDMT_getFrameProgression");
-    fps.ingested = mtctx->consumed + mtctx->inBuff.filled;
+    DEBUGLOG(5, "ZSTDMT_getFrameProgression"); 
+    fps.ingested = mtctx->consumed + mtctx->inBuff.filled; 
     fps.consumed = mtctx->consumed;
-    fps.produced = fps.flushed = mtctx->produced;
-    fps.currentJobID = mtctx->nextJobID;
-    fps.nbActiveWorkers = 0;
+    fps.produced = fps.flushed = mtctx->produced; 
+    fps.currentJobID = mtctx->nextJobID; 
+    fps.nbActiveWorkers = 0; 
     {   unsigned jobNb;
         unsigned lastJobNb = mtctx->nextJobID + mtctx->jobReady; assert(mtctx->jobReady <= 1);
         DEBUGLOG(6, "ZSTDMT_getFrameProgression: jobs: from %u to <%u (jobReady:%u)",
                     mtctx->doneJobID, lastJobNb, mtctx->jobReady)
         for (jobNb = mtctx->doneJobID ; jobNb < lastJobNb ; jobNb++) {
             unsigned const wJobID = jobNb & mtctx->jobIDMask;
-            ZSTDMT_jobDescription* jobPtr = &mtctx->jobs[wJobID];
-            ZSTD_pthread_mutex_lock(&jobPtr->job_mutex);
-            {   size_t const cResult = jobPtr->cSize;
+            ZSTDMT_jobDescription* jobPtr = &mtctx->jobs[wJobID]; 
+            ZSTD_pthread_mutex_lock(&jobPtr->job_mutex); 
+            {   size_t const cResult = jobPtr->cSize; 
                 size_t const produced = ZSTD_isError(cResult) ? 0 : cResult;
-                size_t const flushed = ZSTD_isError(cResult) ? 0 : jobPtr->dstFlushed;
-                assert(flushed <= produced);
-                fps.ingested += jobPtr->src.size;
-                fps.consumed += jobPtr->consumed;
+                size_t const flushed = ZSTD_isError(cResult) ? 0 : jobPtr->dstFlushed; 
+                assert(flushed <= produced); 
+                fps.ingested += jobPtr->src.size; 
+                fps.consumed += jobPtr->consumed; 
                 fps.produced += produced;
-                fps.flushed  += flushed;
-                fps.nbActiveWorkers += (jobPtr->consumed < jobPtr->src.size);
+                fps.flushed  += flushed; 
+                fps.nbActiveWorkers += (jobPtr->consumed < jobPtr->src.size); 
             }
             ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);
         }
@@ -1112,39 +1112,39 @@ ZSTD_frameProgression ZSTDMT_getFrameProgression(ZSTDMT_CCtx* mtctx)
 }
 
 
-size_t ZSTDMT_toFlushNow(ZSTDMT_CCtx* mtctx)
-{
-    size_t toFlush;
-    unsigned const jobID = mtctx->doneJobID;
-    assert(jobID <= mtctx->nextJobID);
-    if (jobID == mtctx->nextJobID) return 0;   /* no active job => nothing to flush */
-
-    /* look into oldest non-fully-flushed job */
-    {   unsigned const wJobID = jobID & mtctx->jobIDMask;
-        ZSTDMT_jobDescription* const jobPtr = &mtctx->jobs[wJobID];
-        ZSTD_pthread_mutex_lock(&jobPtr->job_mutex);
-        {   size_t const cResult = jobPtr->cSize;
-            size_t const produced = ZSTD_isError(cResult) ? 0 : cResult;
-            size_t const flushed = ZSTD_isError(cResult) ? 0 : jobPtr->dstFlushed;
-            assert(flushed <= produced);
+size_t ZSTDMT_toFlushNow(ZSTDMT_CCtx* mtctx) 
+{ 
+    size_t toFlush; 
+    unsigned const jobID = mtctx->doneJobID; 
+    assert(jobID <= mtctx->nextJobID); 
+    if (jobID == mtctx->nextJobID) return 0;   /* no active job => nothing to flush */ 
+ 
+    /* look into oldest non-fully-flushed job */ 
+    {   unsigned const wJobID = jobID & mtctx->jobIDMask; 
+        ZSTDMT_jobDescription* const jobPtr = &mtctx->jobs[wJobID]; 
+        ZSTD_pthread_mutex_lock(&jobPtr->job_mutex); 
+        {   size_t const cResult = jobPtr->cSize; 
+            size_t const produced = ZSTD_isError(cResult) ? 0 : cResult; 
+            size_t const flushed = ZSTD_isError(cResult) ? 0 : jobPtr->dstFlushed; 
+            assert(flushed <= produced); 
             assert(jobPtr->consumed <= jobPtr->src.size);
-            toFlush = produced - flushed;
+            toFlush = produced - flushed; 
             /* if toFlush==0, nothing is available to flush.
              * However, jobID is expected to still be active:
              * if jobID was already completed and fully flushed,
              * ZSTDMT_flushProduced() should have already moved onto next job.
              * Therefore, some input has not yet been consumed. */
             if (toFlush==0) {
-                assert(jobPtr->consumed < jobPtr->src.size);
-            }
-        }
-        ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);
-    }
-
-    return toFlush;
-}
-
-
+                assert(jobPtr->consumed < jobPtr->src.size); 
+            } 
+        } 
+        ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex); 
+    } 
+ 
+    return toFlush; 
+} 
+ 
+ 
 /* ------------------------------------------ */
 /* =====   Multi-threaded compression   ===== */
 /* ------------------------------------------ */
@@ -1153,8 +1153,8 @@ static unsigned ZSTDMT_computeTargetJobLog(const ZSTD_CCtx_params* params)
 {
     unsigned jobLog;
     if (params->ldmParams.enableLdm == ZSTD_ps_enable) {
-        /* In Long Range Mode, the windowLog is typically oversized.
-         * In which case, it's preferable to determine the jobSize
+        /* In Long Range Mode, the windowLog is typically oversized. 
+         * In which case, it's preferable to determine the jobSize 
          * based on cycleLog instead. */
         jobLog = MAX(21, ZSTD_cycleLog(params->cParams.chainLog, params->cParams.strategy) + 3);
     } else {
@@ -1163,53 +1163,53 @@ static unsigned ZSTDMT_computeTargetJobLog(const ZSTD_CCtx_params* params)
     return MIN(jobLog, (unsigned)ZSTDMT_JOBLOG_MAX);
 }
 
-static int ZSTDMT_overlapLog_default(ZSTD_strategy strat)
-{
-    switch(strat)
-    {
-        case ZSTD_btultra2:
-            return 9;
-        case ZSTD_btultra:
-        case ZSTD_btopt:
-            return 8;
-        case ZSTD_btlazy2:
-        case ZSTD_lazy2:
-            return 7;
-        case ZSTD_lazy:
-        case ZSTD_greedy:
-        case ZSTD_dfast:
-        case ZSTD_fast:
-        default:;
-    }
-    return 6;
-}
-
-static int ZSTDMT_overlapLog(int ovlog, ZSTD_strategy strat)
+static int ZSTDMT_overlapLog_default(ZSTD_strategy strat) 
 {
-    assert(0 <= ovlog && ovlog <= 9);
-    if (ovlog == 0) return ZSTDMT_overlapLog_default(strat);
-    return ovlog;
+    switch(strat) 
+    { 
+        case ZSTD_btultra2: 
+            return 9; 
+        case ZSTD_btultra: 
+        case ZSTD_btopt: 
+            return 8; 
+        case ZSTD_btlazy2: 
+        case ZSTD_lazy2: 
+            return 7; 
+        case ZSTD_lazy: 
+        case ZSTD_greedy: 
+        case ZSTD_dfast: 
+        case ZSTD_fast: 
+        default:; 
+    } 
+    return 6; 
 }
 
+static int ZSTDMT_overlapLog(int ovlog, ZSTD_strategy strat) 
+{ 
+    assert(0 <= ovlog && ovlog <= 9); 
+    if (ovlog == 0) return ZSTDMT_overlapLog_default(strat); 
+    return ovlog; 
+} 
+ 
 static size_t ZSTDMT_computeOverlapSize(const ZSTD_CCtx_params* params)
-{
+{ 
     int const overlapRLog = 9 - ZSTDMT_overlapLog(params->overlapLog, params->cParams.strategy);
     int ovLog = (overlapRLog >= 8) ? 0 : (params->cParams.windowLog - overlapRLog);
-    assert(0 <= overlapRLog && overlapRLog <= 8);
+    assert(0 <= overlapRLog && overlapRLog <= 8); 
     if (params->ldmParams.enableLdm == ZSTD_ps_enable) {
-        /* In Long Range Mode, the windowLog is typically oversized.
-         * In which case, it's preferable to determine the jobSize
-         * based on chainLog instead.
-         * Then, ovLog becomes a fraction of the jobSize, rather than windowSize */
+        /* In Long Range Mode, the windowLog is typically oversized. 
+         * In which case, it's preferable to determine the jobSize 
+         * based on chainLog instead. 
+         * Then, ovLog becomes a fraction of the jobSize, rather than windowSize */ 
         ovLog = MIN(params->cParams.windowLog, ZSTDMT_computeTargetJobLog(params) - 2)
-                - overlapRLog;
-    }
+                - overlapRLog; 
+    } 
     assert(0 <= ovLog && ovLog <= ZSTD_WINDOWLOG_MAX);
     DEBUGLOG(4, "overlapLog : %i", params->overlapLog);
-    DEBUGLOG(4, "overlap size : %i", 1 << ovLog);
-    return (ovLog==0) ? 0 : (size_t)1 << ovLog;
-}
-
+    DEBUGLOG(4, "overlap size : %i", 1 << ovLog); 
+    return (ovLog==0) ? 0 : (size_t)1 << ovLog; 
+} 
+ 
 /* ====================================== */
 /* =======      Streaming API     ======= */
 /* ====================================== */
@@ -1220,20 +1220,20 @@ size_t ZSTDMT_initCStream_internal(
         const ZSTD_CDict* cdict, ZSTD_CCtx_params params,
         unsigned long long pledgedSrcSize)
 {
-    DEBUGLOG(4, "ZSTDMT_initCStream_internal (pledgedSrcSize=%u, nbWorkers=%u, cctxPool=%u)",
-                (U32)pledgedSrcSize, params.nbWorkers, mtctx->cctxPool->totalCCtx);
-
-    /* params supposed partially fully validated at this point */
+    DEBUGLOG(4, "ZSTDMT_initCStream_internal (pledgedSrcSize=%u, nbWorkers=%u, cctxPool=%u)", 
+                (U32)pledgedSrcSize, params.nbWorkers, mtctx->cctxPool->totalCCtx); 
+ 
+    /* params supposed partially fully validated at this point */ 
     assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));
     assert(!((dict) && (cdict)));  /* either dict or cdict, not both */
 
     /* init */
-    if (params.nbWorkers != mtctx->params.nbWorkers)
+    if (params.nbWorkers != mtctx->params.nbWorkers) 
         FORWARD_IF_ERROR( ZSTDMT_resize(mtctx, params.nbWorkers) , "");
 
-    if (params.jobSize != 0 && params.jobSize < ZSTDMT_JOBSIZE_MIN) params.jobSize = ZSTDMT_JOBSIZE_MIN;
+    if (params.jobSize != 0 && params.jobSize < ZSTDMT_JOBSIZE_MIN) params.jobSize = ZSTDMT_JOBSIZE_MIN; 
     if (params.jobSize > (size_t)ZSTDMT_JOBSIZE_MAX) params.jobSize = (size_t)ZSTDMT_JOBSIZE_MAX;
-
+ 
     DEBUGLOG(4, "ZSTDMT_initCStream_internal: %u workers", params.nbWorkers);
 
     if (mtctx->allJobsCompleted == 0) {   /* previous compression not correctly finished */
@@ -1258,27 +1258,27 @@ size_t ZSTDMT_initCStream_internal(
     }
 
     mtctx->targetPrefixSize = ZSTDMT_computeOverlapSize(&params);
-    DEBUGLOG(4, "overlapLog=%i => %u KB", params.overlapLog, (U32)(mtctx->targetPrefixSize>>10));
+    DEBUGLOG(4, "overlapLog=%i => %u KB", params.overlapLog, (U32)(mtctx->targetPrefixSize>>10)); 
     mtctx->targetSectionSize = params.jobSize;
-    if (mtctx->targetSectionSize == 0) {
+    if (mtctx->targetSectionSize == 0) { 
         mtctx->targetSectionSize = 1ULL << ZSTDMT_computeTargetJobLog(&params);
-    }
+    } 
     assert(mtctx->targetSectionSize <= (size_t)ZSTDMT_JOBSIZE_MAX);
 
-    if (params.rsyncable) {
-        /* Aim for the targetsectionSize as the average job size. */
+    if (params.rsyncable) { 
+        /* Aim for the targetsectionSize as the average job size. */ 
         U32 const jobSizeKB = (U32)(mtctx->targetSectionSize >> 10);
         U32 const rsyncBits = (assert(jobSizeKB >= 1), ZSTD_highbit32(jobSizeKB) + 10);
         /* We refuse to create jobs < RSYNC_MIN_BLOCK_SIZE bytes, so make sure our
          * expected job size is at least 4x larger. */
         assert(rsyncBits >= RSYNC_MIN_BLOCK_LOG + 2);
-        DEBUGLOG(4, "rsyncLog = %u", rsyncBits);
-        mtctx->rsync.hash = 0;
-        mtctx->rsync.hitMask = (1ULL << rsyncBits) - 1;
-        mtctx->rsync.primePower = ZSTD_rollingHash_primePower(RSYNC_LENGTH);
-    }
+        DEBUGLOG(4, "rsyncLog = %u", rsyncBits); 
+        mtctx->rsync.hash = 0; 
+        mtctx->rsync.hitMask = (1ULL << rsyncBits) - 1; 
+        mtctx->rsync.primePower = ZSTD_rollingHash_primePower(RSYNC_LENGTH); 
+    } 
     if (mtctx->targetSectionSize < mtctx->targetPrefixSize) mtctx->targetSectionSize = mtctx->targetPrefixSize;  /* job size must be >= overlap size */
-    DEBUGLOG(4, "Job Size : %u KB (note : set to %u)", (U32)(mtctx->targetSectionSize>>10), (U32)params.jobSize);
+    DEBUGLOG(4, "Job Size : %u KB (note : set to %u)", (U32)(mtctx->targetSectionSize>>10), (U32)params.jobSize); 
     DEBUGLOG(4, "inBuff Size : %u KB", (U32)(mtctx->targetSectionSize>>10));
     ZSTDMT_setBufferSize(mtctx->bufPool, ZSTD_compressBound(mtctx->targetSectionSize));
     {
@@ -1328,7 +1328,7 @@ size_t ZSTDMT_initCStream_internal(
 /* ZSTDMT_writeLastEmptyBlock()
  * Write a single empty block with an end-of-frame to finish a frame.
  * Job must be created from streaming variant.
- * This function is always successful if expected conditions are fulfilled.
+ * This function is always successful if expected conditions are fulfilled. 
  */
 static void ZSTDMT_writeLastEmptyBlock(ZSTDMT_jobDescription* job)
 {
@@ -1380,7 +1380,7 @@ static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* mtctx, size_t srcSize, ZS
         mtctx->jobs[jobID].jobID = mtctx->nextJobID;
         mtctx->jobs[jobID].firstJob = (mtctx->nextJobID==0);
         mtctx->jobs[jobID].lastJob = endFrame;
-        mtctx->jobs[jobID].frameChecksumNeeded = mtctx->params.fParams.checksumFlag && endFrame && (mtctx->nextJobID>0);
+        mtctx->jobs[jobID].frameChecksumNeeded = mtctx->params.fParams.checksumFlag && endFrame && (mtctx->nextJobID>0); 
         mtctx->jobs[jobID].dstFlushed = 0;
 
         /* Update the round buffer pos and clear the input buffer to be reset */
@@ -1428,8 +1428,8 @@ static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* mtctx, size_t srcSize, ZS
 
 
 /*! ZSTDMT_flushProduced() :
- *  flush whatever data has been produced but not yet flushed in current job.
- *  move to next job if current one is fully flushed.
+ *  flush whatever data has been produced but not yet flushed in current job. 
+ *  move to next job if current one is fully flushed. 
  * `output` : `pos` will be updated with amount of data flushed .
  * `blockToFlush` : if >0, the function will block and wait if there is no data available to flush .
  * @return : amount of data remaining within internal buffer, 0 if no more, 1 if unknown but > 0, or an error code */
@@ -1458,7 +1458,7 @@ static size_t ZSTDMT_flushProduced(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, u
     /* try to flush something */
     {   size_t cSize = mtctx->jobs[wJobID].cSize;                  /* shared */
         size_t const srcConsumed = mtctx->jobs[wJobID].consumed;   /* shared */
-        size_t const srcSize = mtctx->jobs[wJobID].src.size;       /* read-only, could be done after mutex lock, but no-declaration-after-statement */
+        size_t const srcSize = mtctx->jobs[wJobID].src.size;       /* read-only, could be done after mutex lock, but no-declaration-after-statement */ 
         ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);
         if (ZSTD_isError(cSize)) {
             DEBUGLOG(5, "ZSTDMT_flushProduced: job %u : compression error detected : %s",
@@ -1478,7 +1478,7 @@ static size_t ZSTDMT_flushProduced(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, u
             mtctx->jobs[wJobID].cSize += 4;  /* can write this shared value, as worker is no longer active */
             mtctx->jobs[wJobID].frameChecksumNeeded = 0;
         }
-
+ 
         if (cSize > 0) {   /* compression is ongoing or completed */
             size_t const toFlush = MIN(cSize - mtctx->jobs[wJobID].dstFlushed, output->size - output->pos);
             DEBUGLOG(5, "ZSTDMT_flushProduced: Flushing %u bytes from job %u (completion:%u/%u, generated:%u)",
@@ -1494,12 +1494,12 @@ static size_t ZSTDMT_flushProduced(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, u
             output->pos += toFlush;
             mtctx->jobs[wJobID].dstFlushed += toFlush;  /* can write : this value is only used by mtctx */
 
-            if ( (srcConsumed == srcSize)    /* job is completed */
+            if ( (srcConsumed == srcSize)    /* job is completed */ 
               && (mtctx->jobs[wJobID].dstFlushed == cSize) ) {   /* output buffer fully flushed => free this job position */
                 DEBUGLOG(5, "Job %u completed (%u bytes), moving to next one",
                         mtctx->doneJobID, (U32)mtctx->jobs[wJobID].dstFlushed);
                 ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[wJobID].dstBuff);
-                DEBUGLOG(5, "dstBuffer released");
+                DEBUGLOG(5, "dstBuffer released"); 
                 mtctx->jobs[wJobID].dstBuff = g_nullBuffer;
                 mtctx->jobs[wJobID].cSize = 0;   /* ensure this job slot is considered "not started" in future check */
                 mtctx->consumed += srcSize;
@@ -1580,7 +1580,7 @@ static int ZSTDMT_doesOverlapWindow(buffer_t buffer, ZSTD_window_t window)
     range_t extDict;
     range_t prefix;
 
-    DEBUGLOG(5, "ZSTDMT_doesOverlapWindow");
+    DEBUGLOG(5, "ZSTDMT_doesOverlapWindow"); 
     extDict.start = window.dictBase + window.lowLimit;
     extDict.size = window.dictLimit - window.lowLimit;
 
@@ -1601,13 +1601,13 @@ static void ZSTDMT_waitForLdmComplete(ZSTDMT_CCtx* mtctx, buffer_t buffer)
 {
     if (mtctx->params.ldmParams.enableLdm == ZSTD_ps_enable) {
         ZSTD_pthread_mutex_t* mutex = &mtctx->serial.ldmWindowMutex;
-        DEBUGLOG(5, "ZSTDMT_waitForLdmComplete");
+        DEBUGLOG(5, "ZSTDMT_waitForLdmComplete"); 
         DEBUGLOG(5, "source  [0x%zx, 0x%zx)",
                     (size_t)buffer.start,
                     (size_t)buffer.start + buffer.capacity);
         ZSTD_PTHREAD_MUTEX_LOCK(mutex);
         while (ZSTDMT_doesOverlapWindow(buffer, mtctx->serial.ldmWindow)) {
-            DEBUGLOG(5, "Waiting for LDM to finish...");
+            DEBUGLOG(5, "Waiting for LDM to finish..."); 
             ZSTD_pthread_cond_wait(&mtctx->serial.ldmWindowCond, mutex);
         }
         DEBUGLOG(6, "Done waiting for LDM to finish");
@@ -1627,7 +1627,7 @@ static int ZSTDMT_tryGetInputRange(ZSTDMT_CCtx* mtctx)
     size_t const target = mtctx->targetSectionSize;
     buffer_t buffer;
 
-    DEBUGLOG(5, "ZSTDMT_tryGetInputRange");
+    DEBUGLOG(5, "ZSTDMT_tryGetInputRange"); 
     assert(mtctx->inBuff.buffer.start == NULL);
     assert(mtctx->roundBuff.capacity >= target);
 
@@ -1641,7 +1641,7 @@ static int ZSTDMT_tryGetInputRange(ZSTDMT_CCtx* mtctx)
         buffer.start = start;
         buffer.capacity = prefixSize;
         if (ZSTDMT_isOverlapped(buffer, inUse)) {
-            DEBUGLOG(5, "Waiting for buffer...");
+            DEBUGLOG(5, "Waiting for buffer..."); 
             return 0;
         }
         ZSTDMT_waitForLdmComplete(mtctx, buffer);
@@ -1653,7 +1653,7 @@ static int ZSTDMT_tryGetInputRange(ZSTDMT_CCtx* mtctx)
     buffer.capacity = target;
 
     if (ZSTDMT_isOverlapped(buffer, inUse)) {
-        DEBUGLOG(5, "Waiting for buffer...");
+        DEBUGLOG(5, "Waiting for buffer..."); 
         return 0;
     }
     assert(!ZSTDMT_isOverlapped(buffer, mtctx->inBuff.prefix));
@@ -1674,49 +1674,49 @@ static int ZSTDMT_tryGetInputRange(ZSTDMT_CCtx* mtctx)
     return 1;
 }
 
-typedef struct {
-  size_t toLoad;  /* The number of bytes to load from the input. */
-  int flush;      /* Boolean declaring if we must flush because we found a synchronization point. */
-} syncPoint_t;
-
-/**
- * Searches through the input for a synchronization point. If one is found, we
- * will instruct the caller to flush, and return the number of bytes to load.
- * Otherwise, we will load as many bytes as possible and instruct the caller
- * to continue as normal.
- */
-static syncPoint_t
-findSynchronizationPoint(ZSTDMT_CCtx const* mtctx, ZSTD_inBuffer const input)
-{
-    BYTE const* const istart = (BYTE const*)input.src + input.pos;
-    U64 const primePower = mtctx->rsync.primePower;
-    U64 const hitMask = mtctx->rsync.hitMask;
-
-    syncPoint_t syncPoint;
-    U64 hash;
-    BYTE const* prev;
-    size_t pos;
-
-    syncPoint.toLoad = MIN(input.size - input.pos, mtctx->targetSectionSize - mtctx->inBuff.filled);
-    syncPoint.flush = 0;
-    if (!mtctx->params.rsyncable)
-        /* Rsync is disabled. */
-        return syncPoint;
+typedef struct { 
+  size_t toLoad;  /* The number of bytes to load from the input. */ 
+  int flush;      /* Boolean declaring if we must flush because we found a synchronization point. */ 
+} syncPoint_t; 
+
+/** 
+ * Searches through the input for a synchronization point. If one is found, we 
+ * will instruct the caller to flush, and return the number of bytes to load. 
+ * Otherwise, we will load as many bytes as possible and instruct the caller 
+ * to continue as normal. 
+ */ 
+static syncPoint_t 
+findSynchronizationPoint(ZSTDMT_CCtx const* mtctx, ZSTD_inBuffer const input) 
+{ 
+    BYTE const* const istart = (BYTE const*)input.src + input.pos; 
+    U64 const primePower = mtctx->rsync.primePower; 
+    U64 const hitMask = mtctx->rsync.hitMask; 
+ 
+    syncPoint_t syncPoint; 
+    U64 hash; 
+    BYTE const* prev; 
+    size_t pos; 
+ 
+    syncPoint.toLoad = MIN(input.size - input.pos, mtctx->targetSectionSize - mtctx->inBuff.filled); 
+    syncPoint.flush = 0; 
+    if (!mtctx->params.rsyncable) 
+        /* Rsync is disabled. */ 
+        return syncPoint; 
     if (mtctx->inBuff.filled + input.size - input.pos < RSYNC_MIN_BLOCK_SIZE)
         /* We don't emit synchronization points if it would produce too small blocks.
          * We don't have enough input to find a synchronization point, so don't look.
          */
         return syncPoint;
-    if (mtctx->inBuff.filled + syncPoint.toLoad < RSYNC_LENGTH)
-        /* Not enough to compute the hash.
-         * We will miss any synchronization points in this RSYNC_LENGTH byte
-         * window. However, since it depends only in the internal buffers, if the
-         * state is already synchronized, we will remain synchronized.
-         * Additionally, the probability that we miss a synchronization point is
-         * low: RSYNC_LENGTH / targetSectionSize.
-         */
-        return syncPoint;
-    /* Initialize the loop variables. */
+    if (mtctx->inBuff.filled + syncPoint.toLoad < RSYNC_LENGTH) 
+        /* Not enough to compute the hash. 
+         * We will miss any synchronization points in this RSYNC_LENGTH byte 
+         * window. However, since it depends only in the internal buffers, if the 
+         * state is already synchronized, we will remain synchronized. 
+         * Additionally, the probability that we miss a synchronization point is 
+         * low: RSYNC_LENGTH / targetSectionSize. 
+         */ 
+        return syncPoint; 
+    /* Initialize the loop variables. */ 
     if (mtctx->inBuff.filled < RSYNC_MIN_BLOCK_SIZE) {
         /* We don't need to scan the first RSYNC_MIN_BLOCK_SIZE positions
          * because they can't possibly be a sync point. So we can start
@@ -1735,13 +1735,13 @@ findSynchronizationPoint(ZSTDMT_CCtx const* mtctx, ZSTD_inBuffer const input)
     } else {
         /* We have enough bytes buffered to initialize the hash,
          * and are have processed enough bytes to find a sync point.
-         * Start scanning at the beginning of the input.
-         */
+         * Start scanning at the beginning of the input. 
+         */ 
         assert(mtctx->inBuff.filled >= RSYNC_MIN_BLOCK_SIZE);
         assert(RSYNC_MIN_BLOCK_SIZE >= RSYNC_LENGTH);
-        pos = 0;
-        prev = (BYTE const*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled - RSYNC_LENGTH;
-        hash = ZSTD_rollingHash_compute(prev, RSYNC_LENGTH);
+        pos = 0; 
+        prev = (BYTE const*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled - RSYNC_LENGTH; 
+        hash = ZSTD_rollingHash_compute(prev, RSYNC_LENGTH); 
         if ((hash & hitMask) == hitMask) {
             /* We're already at a sync point so don't load any more until
              * we're able to flush this sync point.
@@ -1752,36 +1752,36 @@ findSynchronizationPoint(ZSTDMT_CCtx const* mtctx, ZSTD_inBuffer const input)
             syncPoint.flush = 1;
             return syncPoint;
         }
-    }
-    /* Starting with the hash of the previous RSYNC_LENGTH bytes, roll
-     * through the input. If we hit a synchronization point, then cut the
-     * job off, and tell the compressor to flush the job. Otherwise, load
-     * all the bytes and continue as normal.
-     * If we go too long without a synchronization point (targetSectionSize)
-     * then a block will be emitted anyways, but this is okay, since if we
-     * are already synchronized we will remain synchronized.
-     */
-    for (; pos < syncPoint.toLoad; ++pos) {
-        BYTE const toRemove = pos < RSYNC_LENGTH ? prev[pos] : istart[pos - RSYNC_LENGTH];
+    } 
+    /* Starting with the hash of the previous RSYNC_LENGTH bytes, roll 
+     * through the input. If we hit a synchronization point, then cut the 
+     * job off, and tell the compressor to flush the job. Otherwise, load 
+     * all the bytes and continue as normal. 
+     * If we go too long without a synchronization point (targetSectionSize) 
+     * then a block will be emitted anyways, but this is okay, since if we 
+     * are already synchronized we will remain synchronized. 
+     */ 
+    for (; pos < syncPoint.toLoad; ++pos) { 
+        BYTE const toRemove = pos < RSYNC_LENGTH ? prev[pos] : istart[pos - RSYNC_LENGTH]; 
         assert(pos < RSYNC_LENGTH || ZSTD_rollingHash_compute(istart + pos - RSYNC_LENGTH, RSYNC_LENGTH) == hash);
-        hash = ZSTD_rollingHash_rotate(hash, toRemove, istart[pos], primePower);
+        hash = ZSTD_rollingHash_rotate(hash, toRemove, istart[pos], primePower); 
         assert(mtctx->inBuff.filled + pos >= RSYNC_MIN_BLOCK_SIZE);
-        if ((hash & hitMask) == hitMask) {
-            syncPoint.toLoad = pos + 1;
-            syncPoint.flush = 1;
-            break;
-        }
-    }
-    return syncPoint;
-}
-
-size_t ZSTDMT_nextInputSizeHint(const ZSTDMT_CCtx* mtctx)
-{
-    size_t hintInSize = mtctx->targetSectionSize - mtctx->inBuff.filled;
-    if (hintInSize==0) hintInSize = mtctx->targetSectionSize;
-    return hintInSize;
-}
-
+        if ((hash & hitMask) == hitMask) { 
+            syncPoint.toLoad = pos + 1; 
+            syncPoint.flush = 1; 
+            break; 
+        } 
+    } 
+    return syncPoint; 
+} 
+ 
+size_t ZSTDMT_nextInputSizeHint(const ZSTDMT_CCtx* mtctx) 
+{ 
+    size_t hintInSize = mtctx->targetSectionSize - mtctx->inBuff.filled; 
+    if (hintInSize==0) hintInSize = mtctx->targetSectionSize; 
+    return hintInSize; 
+} 
+ 
 /** ZSTDMT_compressStream_generic() :
  *  internal use only - exposed to be invoked from zstd_compress.c
  *  assumption : output and input are valid (pos <= size)
@@ -1811,23 +1811,23 @@ size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
                 /* It is only possible for this operation to fail if there are
                  * still compression jobs ongoing.
                  */
-                DEBUGLOG(5, "ZSTDMT_tryGetInputRange failed");
+                DEBUGLOG(5, "ZSTDMT_tryGetInputRange failed"); 
                 assert(mtctx->doneJobID != mtctx->nextJobID);
-            } else
-                DEBUGLOG(5, "ZSTDMT_tryGetInputRange completed successfully : mtctx->inBuff.buffer.start = %p", mtctx->inBuff.buffer.start);
+            } else 
+                DEBUGLOG(5, "ZSTDMT_tryGetInputRange completed successfully : mtctx->inBuff.buffer.start = %p", mtctx->inBuff.buffer.start); 
         }
         if (mtctx->inBuff.buffer.start != NULL) {
-            syncPoint_t const syncPoint = findSynchronizationPoint(mtctx, *input);
-            if (syncPoint.flush && endOp == ZSTD_e_continue) {
-                endOp = ZSTD_e_flush;
-            }
+            syncPoint_t const syncPoint = findSynchronizationPoint(mtctx, *input); 
+            if (syncPoint.flush && endOp == ZSTD_e_continue) { 
+                endOp = ZSTD_e_flush; 
+            } 
             assert(mtctx->inBuff.buffer.capacity >= mtctx->targetSectionSize);
             DEBUGLOG(5, "ZSTDMT_compressStream_generic: adding %u bytes on top of %u to buffer of size %u",
-                        (U32)syncPoint.toLoad, (U32)mtctx->inBuff.filled, (U32)mtctx->targetSectionSize);
+                        (U32)syncPoint.toLoad, (U32)mtctx->inBuff.filled, (U32)mtctx->targetSectionSize); 
             ZSTD_memcpy((char*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled, (const char*)input->src + input->pos, syncPoint.toLoad);
-            input->pos += syncPoint.toLoad;
-            mtctx->inBuff.filled += syncPoint.toLoad;
-            forwardInputProgress = syncPoint.toLoad>0;
+            input->pos += syncPoint.toLoad; 
+            mtctx->inBuff.filled += syncPoint.toLoad; 
+            forwardInputProgress = syncPoint.toLoad>0; 
         }
     }
     if ((input->pos < input->size) && (endOp == ZSTD_e_end)) {
@@ -1853,7 +1853,7 @@ size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
     /* check for potential compressed data ready to be flushed */
     {   size_t const remainingToFlush = ZSTDMT_flushProduced(mtctx, output, !forwardInputProgress, endOp); /* block if there was no forward input progress */
         if (input->pos < input->size) return MAX(remainingToFlush, 1);  /* input not consumed : do not end flush yet */
-        DEBUGLOG(5, "end of ZSTDMT_compressStream_generic: remainingToFlush = %u", (U32)remainingToFlush);
+        DEBUGLOG(5, "end of ZSTDMT_compressStream_generic: remainingToFlush = %u", (U32)remainingToFlush); 
         return remainingToFlush;
     }
 }
diff --git a/contrib/libs/zstd/lib/compress/zstdmt_compress.h b/contrib/libs/zstd/lib/compress/zstdmt_compress.h
index 271eb1ac71f..41af87e629c 100644
--- a/contrib/libs/zstd/lib/compress/zstdmt_compress.h
+++ b/contrib/libs/zstd/lib/compress/zstdmt_compress.h
@@ -17,13 +17,13 @@
 
 
 /* Note : This is an internal API.
- *        These APIs used to be exposed with ZSTDLIB_API,
+ *        These APIs used to be exposed with ZSTDLIB_API, 
  *        because it used to be the only way to invoke MT compression.
  *        Now, you must use ZSTD_compress2 and ZSTD_compressStream2() instead.
- *
- *        This API requires ZSTD_MULTITHREAD to be defined during compilation,
- *        otherwise ZSTDMT_createCCtx*() will fail.
- */
+ * 
+ *        This API requires ZSTD_MULTITHREAD to be defined during compilation, 
+ *        otherwise ZSTDMT_createCCtx*() will fail. 
+ */ 
 
 /* ===   Dependencies   === */
 #include "../common/zstd_deps.h"   /* size_t */
@@ -31,17 +31,17 @@
 #include "../zstd.h"            /* ZSTD_inBuffer, ZSTD_outBuffer, ZSTDLIB_API */
 
 
-/* ===   Constants   === */
+/* ===   Constants   === */ 
 #ifndef ZSTDMT_NBWORKERS_MAX /* a different value can be selected at compile time */
 #  define ZSTDMT_NBWORKERS_MAX ((sizeof(void*)==4) /*32-bit*/ ? 64 : 256)
-#endif
+#endif 
 #ifndef ZSTDMT_JOBSIZE_MIN   /* a different value can be selected at compile time */
 #  define ZSTDMT_JOBSIZE_MIN (512 KB)
-#endif
+#endif 
 #define ZSTDMT_JOBLOG_MAX   (MEM_32bits() ? 29 : 30)
-#define ZSTDMT_JOBSIZE_MAX  (MEM_32bits() ? (512 MB) : (1024 MB))
-
-
+#define ZSTDMT_JOBSIZE_MAX  (MEM_32bits() ? (512 MB) : (1024 MB)) 
+ 
+ 
 /* ========================================================
  * ===  Private interface, for use by ZSTD_compress.c   ===
  * ===  Not exposed in libzstd. Never invoke directly   ===
@@ -49,7 +49,7 @@
 
 /* ===   Memory management   === */
 typedef struct ZSTDMT_CCtx_s ZSTDMT_CCtx;
-/* Requires ZSTD_MULTITHREAD to be defined during compilation, otherwise it will return NULL. */
+/* Requires ZSTD_MULTITHREAD to be defined during compilation, otherwise it will return NULL. */ 
 ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbWorkers,
                                         ZSTD_customMem cMem,
 					ZSTD_threadPool *pool);
@@ -86,22 +86,22 @@ size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
                                      ZSTD_inBuffer* input,
                                      ZSTD_EndDirective endOp);
 
- /*! ZSTDMT_toFlushNow()
-  *  Tell how many bytes are ready to be flushed immediately.
-  *  Probe the oldest active job (not yet entirely flushed) and check its output buffer.
-  *  If return 0, it means there is no active job,
-  *  or, it means oldest job is still active, but everything produced has been flushed so far,
-  *  therefore flushing is limited by speed of oldest job. */
-size_t ZSTDMT_toFlushNow(ZSTDMT_CCtx* mtctx);
+ /*! ZSTDMT_toFlushNow() 
+  *  Tell how many bytes are ready to be flushed immediately. 
+  *  Probe the oldest active job (not yet entirely flushed) and check its output buffer. 
+  *  If return 0, it means there is no active job, 
+  *  or, it means oldest job is still active, but everything produced has been flushed so far, 
+  *  therefore flushing is limited by speed of oldest job. */ 
+size_t ZSTDMT_toFlushNow(ZSTDMT_CCtx* mtctx); 
 
 /*! ZSTDMT_updateCParams_whileCompressing() :
  *  Updates only a selected set of compression parameters, to remain compatible with current frame.
  *  New parameters will be applied to next compression job. */
 void ZSTDMT_updateCParams_whileCompressing(ZSTDMT_CCtx* mtctx, const ZSTD_CCtx_params* cctxParams);
 
-/*! ZSTDMT_getFrameProgression():
- *  tells how much data has been consumed (input) and produced (output) for current frame.
- *  able to count progression inside worker threads.
+/*! ZSTDMT_getFrameProgression(): 
+ *  tells how much data has been consumed (input) and produced (output) for current frame. 
+ *  able to count progression inside worker threads. 
  */
 ZSTD_frameProgression ZSTDMT_getFrameProgression(ZSTDMT_CCtx* mtctx);