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

7 files changed, 2142 insertions, 2142 deletions

diff --git a/contrib/libs/zstd/lib/decompress/huf_decompress.c b/contrib/libs/zstd/lib/decompress/huf_decompress.c
index 671f5640cd..2027188255 100644
--- a/contrib/libs/zstd/lib/decompress/huf_decompress.c
+++ b/contrib/libs/zstd/lib/decompress/huf_decompress.c
@@ -24,31 +24,31 @@
 #include "../common/error_private.h"
 #include "../common/zstd_internal.h"
 
-/* ************************************************************** 
+/* **************************************************************
 *  Constants
 ****************************************************************/
 
 #define HUF_DECODER_FAST_TABLELOG 11
 
 /* **************************************************************
-*  Macros 
-****************************************************************/ 
-
-/* These two optional macros force the use one way or another of the two 
- * Huffman decompression implementations. You can't force in both directions 
- * at the same time. 
- */ 
-#if defined(HUF_FORCE_DECOMPRESS_X1) && \ 
-    defined(HUF_FORCE_DECOMPRESS_X2) 
-#error "Cannot force the use of the X1 and X2 decoders at the same time!" 
-#endif 
- 
+*  Macros
+****************************************************************/
+
+/* These two optional macros force the use one way or another of the two
+ * Huffman decompression implementations. You can't force in both directions
+ * at the same time.
+ */
+#if defined(HUF_FORCE_DECOMPRESS_X1) && \
+    defined(HUF_FORCE_DECOMPRESS_X2)
+#error "Cannot force the use of the X1 and X2 decoders at the same time!"
+#endif
+
 #if ZSTD_ENABLE_ASM_X86_64_BMI2 && DYNAMIC_BMI2
 # define HUF_ASM_X86_64_BMI2_ATTRS BMI2_TARGET_ATTRIBUTE
 #else
 # define HUF_ASM_X86_64_BMI2_ATTRS
 #endif
- 
+
 #ifdef __cplusplus
 # define HUF_EXTERN_C extern "C"
 #else
@@ -81,51 +81,51 @@
 #define HUF_ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))
 
 
-/* ************************************************************** 
-*  BMI2 Variant Wrappers 
-****************************************************************/ 
-#if DYNAMIC_BMI2 
- 
-#define HUF_DGEN(fn)                                                        \ 
-                                                                            \ 
-    static size_t fn##_default(                                             \ 
-                  void* dst,  size_t dstSize,                               \ 
-            const void* cSrc, size_t cSrcSize,                              \ 
-            const HUF_DTable* DTable)                                       \ 
-    {                                                                       \ 
-        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \ 
-    }                                                                       \ 
-                                                                            \ 
+/* **************************************************************
+*  BMI2 Variant Wrappers
+****************************************************************/
+#if DYNAMIC_BMI2
+
+#define HUF_DGEN(fn)                                                        \
+                                                                            \
+    static size_t fn##_default(                                             \
+                  void* dst,  size_t dstSize,                               \
+            const void* cSrc, size_t cSrcSize,                              \
+            const HUF_DTable* DTable)                                       \
+    {                                                                       \
+        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \
+    }                                                                       \
+                                                                            \
     static BMI2_TARGET_ATTRIBUTE size_t fn##_bmi2(                          \
-                  void* dst,  size_t dstSize,                               \ 
-            const void* cSrc, size_t cSrcSize,                              \ 
-            const HUF_DTable* DTable)                                       \ 
-    {                                                                       \ 
-        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \ 
-    }                                                                       \ 
-                                                                            \ 
-    static size_t fn(void* dst, size_t dstSize, void const* cSrc,           \ 
-                     size_t cSrcSize, HUF_DTable const* DTable, int bmi2)   \ 
-    {                                                                       \ 
-        if (bmi2) {                                                         \ 
-            return fn##_bmi2(dst, dstSize, cSrc, cSrcSize, DTable);         \ 
-        }                                                                   \ 
-        return fn##_default(dst, dstSize, cSrc, cSrcSize, DTable);          \ 
-    } 
- 
-#else 
- 
-#define HUF_DGEN(fn)                                                        \ 
-    static size_t fn(void* dst, size_t dstSize, void const* cSrc,           \ 
-                     size_t cSrcSize, HUF_DTable const* DTable, int bmi2)   \ 
-    {                                                                       \ 
-        (void)bmi2;                                                         \ 
-        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \ 
-    } 
- 
-#endif 
- 
- 
+                  void* dst,  size_t dstSize,                               \
+            const void* cSrc, size_t cSrcSize,                              \
+            const HUF_DTable* DTable)                                       \
+    {                                                                       \
+        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \
+    }                                                                       \
+                                                                            \
+    static size_t fn(void* dst, size_t dstSize, void const* cSrc,           \
+                     size_t cSrcSize, HUF_DTable const* DTable, int bmi2)   \
+    {                                                                       \
+        if (bmi2) {                                                         \
+            return fn##_bmi2(dst, dstSize, cSrc, cSrcSize, DTable);         \
+        }                                                                   \
+        return fn##_default(dst, dstSize, cSrc, cSrcSize, DTable);          \
+    }
+
+#else
+
+#define HUF_DGEN(fn)                                                        \
+    static size_t fn(void* dst, size_t dstSize, void const* cSrc,           \
+                     size_t cSrcSize, HUF_DTable const* DTable, int bmi2)   \
+    {                                                                       \
+        (void)bmi2;                                                         \
+        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \
+    }
+
+#endif
+
+
 /*-***************************/
 /*  generic DTableDesc       */
 /*-***************************/
@@ -273,8 +273,8 @@ static size_t HUF_initRemainingDStream(BIT_DStream_t* bit, HUF_DecompressAsmArgs
 #endif
 
 
-#ifndef HUF_FORCE_DECOMPRESS_X2 
- 
+#ifndef HUF_FORCE_DECOMPRESS_X2
+
 /*-***************************/
 /*  single-symbol decoding   */
 /*-***************************/
@@ -334,7 +334,7 @@ typedef struct {
 } HUF_ReadDTableX1_Workspace;
 
 
-size_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize) 
+size_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize)
 {
     return HUF_readDTableX1_wksp_bmi2(DTable, src, srcSize, workSpace, wkspSize, /* bmi2 */ 0);
 }
@@ -345,13 +345,13 @@ size_t HUF_readDTableX1_wksp_bmi2(HUF_DTable* DTable, const void* src, size_t sr
     U32 nbSymbols = 0;
     size_t iSize;
     void* const dtPtr = DTable + 1;
-    HUF_DEltX1* const dt = (HUF_DEltX1*)dtPtr; 
+    HUF_DEltX1* const dt = (HUF_DEltX1*)dtPtr;
     HUF_ReadDTableX1_Workspace* wksp = (HUF_ReadDTableX1_Workspace*)workSpace;
 
     DEBUG_STATIC_ASSERT(HUF_DECOMPRESS_WORKSPACE_SIZE >= sizeof(*wksp));
     if (sizeof(*wksp) > wkspSize) return ERROR(tableLog_tooLarge);
 
-    DEBUG_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUF_DTable)); 
+    DEBUG_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUF_DTable));
     /* ZSTD_memset(huffWeight, 0, sizeof(huffWeight)); */   /* is not necessary, even though some analyzer complain ... */
 
     iSize = HUF_readStats_wksp(wksp->huffWeight, HUF_SYMBOLVALUE_MAX + 1, wksp->rankVal, &nbSymbols, &tableLog, src, srcSize, wksp->statsWksp, sizeof(wksp->statsWksp), bmi2);
@@ -478,7 +478,7 @@ size_t HUF_readDTableX1_wksp_bmi2(HUF_DTable* DTable, const void* src, size_t sr
 }
 
 FORCE_INLINE_TEMPLATE BYTE
-HUF_decodeSymbolX1(BIT_DStream_t* Dstream, const HUF_DEltX1* dt, const U32 dtLog) 
+HUF_decodeSymbolX1(BIT_DStream_t* Dstream, const HUF_DEltX1* dt, const U32 dtLog)
 {
     size_t const val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
     BYTE const c = dt[val].byte;
@@ -486,19 +486,19 @@ HUF_decodeSymbolX1(BIT_DStream_t* Dstream, const HUF_DEltX1* dt, const U32 dtLog
     return c;
 }
 
-#define HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr) \ 
-    *ptr++ = HUF_decodeSymbolX1(DStreamPtr, dt, dtLog) 
+#define HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr) \
+    *ptr++ = HUF_decodeSymbolX1(DStreamPtr, dt, dtLog)
 
-#define HUF_DECODE_SYMBOLX1_1(ptr, DStreamPtr)  \ 
+#define HUF_DECODE_SYMBOLX1_1(ptr, DStreamPtr)  \
     if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \
-        HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr) 
+        HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)
 
-#define HUF_DECODE_SYMBOLX1_2(ptr, DStreamPtr) \ 
+#define HUF_DECODE_SYMBOLX1_2(ptr, DStreamPtr) \
     if (MEM_64bits()) \
-        HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr) 
+        HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)
 
 HINT_INLINE size_t
-HUF_decodeStreamX1(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX1* const dt, const U32 dtLog) 
+HUF_decodeStreamX1(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX1* const dt, const U32 dtLog)
 {
     BYTE* const pStart = p;
 
@@ -517,17 +517,17 @@ HUF_decodeStreamX1(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, cons
     /* [0-3] symbols remaining */
     if (MEM_32bits())
         while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd))
-            HUF_DECODE_SYMBOLX1_0(p, bitDPtr); 
+            HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
 
     /* no more data to retrieve from bitstream, no need to reload */
     while (p < pEnd)
-        HUF_DECODE_SYMBOLX1_0(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
 
     return pEnd-pStart;
 }
 
 FORCE_INLINE_TEMPLATE size_t
-HUF_decompress1X1_usingDTable_internal_body( 
+HUF_decompress1X1_usingDTable_internal_body(
           void* dst,  size_t dstSize,
     const void* cSrc, size_t cSrcSize,
     const HUF_DTable* DTable)
@@ -535,14 +535,14 @@ HUF_decompress1X1_usingDTable_internal_body(
     BYTE* op = (BYTE*)dst;
     BYTE* const oend = op + dstSize;
     const void* dtPtr = DTable + 1;
-    const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr; 
+    const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;
     BIT_DStream_t bitD;
     DTableDesc const dtd = HUF_getDTableDesc(DTable);
     U32 const dtLog = dtd.tableLog;
 
     CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );
 
-    HUF_decodeStreamX1(op, &bitD, oend, dt, dtLog); 
+    HUF_decodeStreamX1(op, &bitD, oend, dt, dtLog);
 
     if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
 
@@ -550,7 +550,7 @@ HUF_decompress1X1_usingDTable_internal_body(
 }
 
 FORCE_INLINE_TEMPLATE size_t
-HUF_decompress4X1_usingDTable_internal_body( 
+HUF_decompress4X1_usingDTable_internal_body(
           void* dst,  size_t dstSize,
     const void* cSrc, size_t cSrcSize,
     const HUF_DTable* DTable)
@@ -563,7 +563,7 @@ HUF_decompress4X1_usingDTable_internal_body(
         BYTE* const oend = ostart + dstSize;
         BYTE* const olimit = oend - 3;
         const void* const dtPtr = DTable + 1;
-        const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr; 
+        const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;
 
         /* Init */
         BIT_DStream_t bitD1;
@@ -632,10 +632,10 @@ HUF_decompress4X1_usingDTable_internal_body(
         /* note : op4 supposed already verified within main loop */
 
         /* finish bitStreams one by one */
-        HUF_decodeStreamX1(op1, &bitD1, opStart2, dt, dtLog); 
-        HUF_decodeStreamX1(op2, &bitD2, opStart3, dt, dtLog); 
-        HUF_decodeStreamX1(op3, &bitD3, opStart4, dt, dtLog); 
-        HUF_decodeStreamX1(op4, &bitD4, oend,     dt, dtLog); 
+        HUF_decodeStreamX1(op1, &bitD1, opStart2, dt, dtLog);
+        HUF_decodeStreamX1(op2, &bitD2, opStart3, dt, dtLog);
+        HUF_decodeStreamX1(op3, &bitD3, opStart4, dt, dtLog);
+        HUF_decodeStreamX1(op4, &bitD4, oend,     dt, dtLog);
 
         /* check */
         { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
@@ -725,7 +725,7 @@ typedef size_t (*HUF_decompress_usingDTable_t)(void *dst, size_t dstSize,
                                                size_t cSrcSize,
                                                const HUF_DTable *DTable);
 
-HUF_DGEN(HUF_decompress1X1_usingDTable_internal) 
+HUF_DGEN(HUF_decompress1X1_usingDTable_internal)
 
 static size_t HUF_decompress4X1_usingDTable_internal(void* dst, size_t dstSize, void const* cSrc,
                     size_t cSrcSize, HUF_DTable const* DTable, int bmi2)
@@ -750,42 +750,42 @@ static size_t HUF_decompress4X1_usingDTable_internal(void* dst, size_t dstSize,
 }
 
 
-size_t HUF_decompress1X1_usingDTable( 
+size_t HUF_decompress1X1_usingDTable(
           void* dst,  size_t dstSize,
     const void* cSrc, size_t cSrcSize,
     const HUF_DTable* DTable)
 {
     DTableDesc dtd = HUF_getDTableDesc(DTable);
     if (dtd.tableType != 0) return ERROR(GENERIC);
-    return HUF_decompress1X1_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); 
+    return HUF_decompress1X1_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
 }
 
-size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize, 
+size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
                                    const void* cSrc, size_t cSrcSize,
                                    void* workSpace, size_t wkspSize)
 {
     const BYTE* ip = (const BYTE*) cSrc;
 
-    size_t const hSize = HUF_readDTableX1_wksp(DCtx, cSrc, cSrcSize, workSpace, wkspSize); 
+    size_t const hSize = HUF_readDTableX1_wksp(DCtx, cSrc, cSrcSize, workSpace, wkspSize);
     if (HUF_isError(hSize)) return hSize;
     if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
     ip += hSize; cSrcSize -= hSize;
 
-    return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0); 
+    return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0);
 }
 
 
-size_t HUF_decompress4X1_usingDTable( 
+size_t HUF_decompress4X1_usingDTable(
           void* dst,  size_t dstSize,
     const void* cSrc, size_t cSrcSize,
     const HUF_DTable* DTable)
 {
     DTableDesc dtd = HUF_getDTableDesc(DTable);
     if (dtd.tableType != 0) return ERROR(GENERIC);
-    return HUF_decompress4X1_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); 
+    return HUF_decompress4X1_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
 }
 
-static size_t HUF_decompress4X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, 
+static size_t HUF_decompress4X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
                                    const void* cSrc, size_t cSrcSize,
                                    void* workSpace, size_t wkspSize, int bmi2)
 {
@@ -796,30 +796,30 @@ static size_t HUF_decompress4X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size
     if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
     ip += hSize; cSrcSize -= hSize;
 
-    return HUF_decompress4X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2); 
+    return HUF_decompress4X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
 }
 
-size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, 
+size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
                                    const void* cSrc, size_t cSrcSize,
                                    void* workSpace, size_t wkspSize)
 {
-    return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, 0); 
+    return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, 0);
 }
 
 
-#endif /* HUF_FORCE_DECOMPRESS_X2 */ 
+#endif /* HUF_FORCE_DECOMPRESS_X2 */
+
+
+#ifndef HUF_FORCE_DECOMPRESS_X1
 
- 
-#ifndef HUF_FORCE_DECOMPRESS_X1 
- 
 /* *************************/
 /* double-symbols decoding */
 /* *************************/
- 
-typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX2;  /* double-symbols decoding */ 
+
+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX2;  /* double-symbols decoding */
 typedef struct { BYTE symbol; } sortedSymbol_t;
-typedef U32 rankValCol_t[HUF_TABLELOG_MAX + 1]; 
-typedef rankValCol_t rankVal_t[HUF_TABLELOG_MAX]; 
+typedef U32 rankValCol_t[HUF_TABLELOG_MAX + 1];
+typedef rankValCol_t rankVal_t[HUF_TABLELOG_MAX];
 
 /**
  * Constructs a HUF_DEltX2 in a U32.
@@ -839,13 +839,13 @@ static U32 HUF_buildDEltX2U32(U32 symbol, U32 nbBits, U32 baseSeq, int level)
         return (seq << 16) + (nbBits << 8) + (U32)level;
     }
 }
- 
+
 /**
  * Constructs a HUF_DEltX2.
  */
 static HUF_DEltX2 HUF_buildDEltX2(U32 symbol, U32 nbBits, U32 baseSeq, int level)
 {
-    HUF_DEltX2 DElt; 
+    HUF_DEltX2 DElt;
     U32 const val = HUF_buildDEltX2U32(symbol, nbBits, baseSeq, level);
     DEBUG_STATIC_ASSERT(sizeof(DElt) == sizeof(val));
     ZSTD_memcpy(&DElt, &val, sizeof(val));
@@ -987,7 +987,7 @@ static void HUF_fillDTableX2Level2(HUF_DEltX2* DTable, U32 targetLog, const U32
     }
 }
 
-static void HUF_fillDTableX2(HUF_DEltX2* DTable, const U32 targetLog, 
+static void HUF_fillDTableX2(HUF_DEltX2* DTable, const U32 targetLog,
                            const sortedSymbol_t* sortedList,
                            const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
                            const U32 nbBitsBaseline)
@@ -1042,9 +1042,9 @@ typedef struct {
     U32 calleeWksp[HUF_READ_STATS_WORKSPACE_SIZE_U32];
 } HUF_ReadDTableX2_Workspace;
 
-size_t HUF_readDTableX2_wksp(HUF_DTable* DTable, 
-                       const void* src, size_t srcSize, 
-                             void* workSpace, size_t wkspSize) 
+size_t HUF_readDTableX2_wksp(HUF_DTable* DTable,
+                       const void* src, size_t srcSize,
+                             void* workSpace, size_t wkspSize)
 {
     return HUF_readDTableX2_wksp_bmi2(DTable, src, srcSize, workSpace, wkspSize, /* bmi2 */ 0);
 }
@@ -1058,7 +1058,7 @@ size_t HUF_readDTableX2_wksp_bmi2(HUF_DTable* DTable,
     U32 maxTableLog = dtd.maxTableLog;
     size_t iSize;
     void* dtPtr = DTable+1;   /* force compiler to avoid strict-aliasing */
-    HUF_DEltX2* const dt = (HUF_DEltX2*)dtPtr; 
+    HUF_DEltX2* const dt = (HUF_DEltX2*)dtPtr;
     U32 *rankStart;
 
     HUF_ReadDTableX2_Workspace* const wksp = (HUF_ReadDTableX2_Workspace*)workSpace;
@@ -1069,7 +1069,7 @@ size_t HUF_readDTableX2_wksp_bmi2(HUF_DTable* DTable,
     ZSTD_memset(wksp->rankStats, 0, sizeof(wksp->rankStats));
     ZSTD_memset(wksp->rankStart0, 0, sizeof(wksp->rankStart0));
 
-    DEBUG_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(HUF_DTable));   /* if compiler fails here, assertion is wrong */ 
+    DEBUG_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(HUF_DTable));   /* if compiler fails here, assertion is wrong */
     if (maxTableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
     /* ZSTD_memset(weightList, 0, sizeof(weightList)); */  /* is not necessary, even though some analyzer complain ... */
 
@@ -1123,7 +1123,7 @@ size_t HUF_readDTableX2_wksp_bmi2(HUF_DTable* DTable,
                     rankValPtr[w] = rankVal0[w] >> consumed;
     }   }   }   }
 
-    HUF_fillDTableX2(dt, maxTableLog, 
+    HUF_fillDTableX2(dt, maxTableLog,
                    wksp->sortedSymbol,
                    wksp->rankStart0, wksp->rankVal, maxW,
                    tableLog+1);
@@ -1135,51 +1135,51 @@ size_t HUF_readDTableX2_wksp_bmi2(HUF_DTable* DTable,
 }
 
 
-FORCE_INLINE_TEMPLATE U32 
-HUF_decodeSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog) 
-{ 
-    size_t const val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+FORCE_INLINE_TEMPLATE U32
+HUF_decodeSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
+{
+    size_t const val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
     ZSTD_memcpy(op, &dt[val].sequence, 2);
-    BIT_skipBits(DStream, dt[val].nbBits); 
-    return dt[val].length; 
-} 
- 
-FORCE_INLINE_TEMPLATE U32 
-HUF_decodeLastSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog) 
-{ 
-    size_t const val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    BIT_skipBits(DStream, dt[val].nbBits);
+    return dt[val].length;
+}
+
+FORCE_INLINE_TEMPLATE U32
+HUF_decodeLastSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
+{
+    size_t const val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
     ZSTD_memcpy(op, &dt[val].sequence, 1);
     if (dt[val].length==1) {
         BIT_skipBits(DStream, dt[val].nbBits);
     } else {
-        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) { 
-            BIT_skipBits(DStream, dt[val].nbBits); 
-            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8)) 
-                /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */ 
-                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8); 
+        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {
+            BIT_skipBits(DStream, dt[val].nbBits);
+            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
+                /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
+                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);
         }
     }
-    return 1; 
-} 
- 
-#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \ 
-    ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog) 
- 
-#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \ 
-    if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \ 
-        ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog) 
- 
-#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \ 
-    if (MEM_64bits()) \ 
-        ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog) 
- 
-HINT_INLINE size_t 
-HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, 
-                const HUF_DEltX2* const dt, const U32 dtLog) 
-{ 
-    BYTE* const pStart = p; 
- 
-    /* up to 8 symbols at a time */ 
+    return 1;
+}
+
+#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
+    ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
+
+#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
+    if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \
+        ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
+
+#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
+    if (MEM_64bits()) \
+        ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
+
+HINT_INLINE size_t
+HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd,
+                const HUF_DEltX2* const dt, const U32 dtLog)
+{
+    BYTE* const pStart = p;
+
+    /* up to 8 symbols at a time */
     if ((size_t)(pEnd - p) >= sizeof(bitDPtr->bitContainer)) {
         if (dtLog <= 11 && MEM_64bits()) {
             /* up to 10 symbols at a time */
@@ -1201,97 +1201,97 @@ HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd,
         }
     } else {
         BIT_reloadDStream(bitDPtr);
-    } 
- 
-    /* closer to end : up to 2 symbols at a time */ 
+    }
+
+    /* closer to end : up to 2 symbols at a time */
     if ((size_t)(pEnd - p) >= 2) {
         while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p <= pEnd-2))
             HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
- 
+
         while (p <= pEnd-2)
             HUF_DECODE_SYMBOLX2_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
     }
- 
-    if (p < pEnd) 
-        p += HUF_decodeLastSymbolX2(p, bitDPtr, dt, dtLog); 
- 
-    return p-pStart; 
-} 
- 
-FORCE_INLINE_TEMPLATE size_t 
-HUF_decompress1X2_usingDTable_internal_body( 
+
+    if (p < pEnd)
+        p += HUF_decodeLastSymbolX2(p, bitDPtr, dt, dtLog);
+
+    return p-pStart;
+}
+
+FORCE_INLINE_TEMPLATE size_t
+HUF_decompress1X2_usingDTable_internal_body(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUF_DTable* DTable)
+{
+    BIT_DStream_t bitD;
+
+    /* Init */
+    CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );
+
+    /* decode */
+    {   BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
+        const void* const dtPtr = DTable+1;   /* force compiler to not use strict-aliasing */
+        const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;
+        DTableDesc const dtd = HUF_getDTableDesc(DTable);
+        HUF_decodeStreamX2(ostart, &bitD, oend, dt, dtd.tableLog);
+    }
+
+    /* check */
+    if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
+
+    /* decoded size */
+    return dstSize;
+}
+FORCE_INLINE_TEMPLATE size_t
+HUF_decompress4X2_usingDTable_internal_body(
           void* dst,  size_t dstSize,
     const void* cSrc, size_t cSrcSize,
     const HUF_DTable* DTable)
 {
-    BIT_DStream_t bitD; 
- 
-    /* Init */ 
-    CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) ); 
- 
-    /* decode */ 
-    {   BYTE* const ostart = (BYTE*) dst; 
-        BYTE* const oend = ostart + dstSize; 
-        const void* const dtPtr = DTable+1;   /* force compiler to not use strict-aliasing */ 
-        const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr; 
-        DTableDesc const dtd = HUF_getDTableDesc(DTable); 
-        HUF_decodeStreamX2(ostart, &bitD, oend, dt, dtd.tableLog); 
-    } 
- 
-    /* check */ 
-    if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected); 
- 
-    /* decoded size */ 
-    return dstSize; 
-} 
-FORCE_INLINE_TEMPLATE size_t 
-HUF_decompress4X2_usingDTable_internal_body( 
-          void* dst,  size_t dstSize, 
-    const void* cSrc, size_t cSrcSize, 
-    const HUF_DTable* DTable) 
-{ 
-    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */ 
- 
-    {   const BYTE* const istart = (const BYTE*) cSrc; 
-        BYTE* const ostart = (BYTE*) dst; 
-        BYTE* const oend = ostart + dstSize; 
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
+
+    {   const BYTE* const istart = (const BYTE*) cSrc;
+        BYTE* const ostart = (BYTE*) dst;
+        BYTE* const oend = ostart + dstSize;
         BYTE* const olimit = oend - (sizeof(size_t)-1);
-        const void* const dtPtr = DTable+1; 
-        const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr; 
- 
-        /* Init */ 
-        BIT_DStream_t bitD1; 
-        BIT_DStream_t bitD2; 
-        BIT_DStream_t bitD3; 
-        BIT_DStream_t bitD4; 
-        size_t const length1 = MEM_readLE16(istart); 
-        size_t const length2 = MEM_readLE16(istart+2); 
-        size_t const length3 = MEM_readLE16(istart+4); 
-        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6); 
-        const BYTE* const istart1 = istart + 6;  /* jumpTable */ 
-        const BYTE* const istart2 = istart1 + length1; 
-        const BYTE* const istart3 = istart2 + length2; 
-        const BYTE* const istart4 = istart3 + length3; 
-        size_t const segmentSize = (dstSize+3) / 4; 
-        BYTE* const opStart2 = ostart + segmentSize; 
-        BYTE* const opStart3 = opStart2 + segmentSize; 
-        BYTE* const opStart4 = opStart3 + segmentSize; 
-        BYTE* op1 = ostart; 
-        BYTE* op2 = opStart2; 
-        BYTE* op3 = opStart3; 
-        BYTE* op4 = opStart4; 
+        const void* const dtPtr = DTable+1;
+        const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;
+
+        /* Init */
+        BIT_DStream_t bitD1;
+        BIT_DStream_t bitD2;
+        BIT_DStream_t bitD3;
+        BIT_DStream_t bitD4;
+        size_t const length1 = MEM_readLE16(istart);
+        size_t const length2 = MEM_readLE16(istart+2);
+        size_t const length3 = MEM_readLE16(istart+4);
+        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */
+        const BYTE* const istart2 = istart1 + length1;
+        const BYTE* const istart3 = istart2 + length2;
+        const BYTE* const istart4 = istart3 + length3;
+        size_t const segmentSize = (dstSize+3) / 4;
+        BYTE* const opStart2 = ostart + segmentSize;
+        BYTE* const opStart3 = opStart2 + segmentSize;
+        BYTE* const opStart4 = opStart3 + segmentSize;
+        BYTE* op1 = ostart;
+        BYTE* op2 = opStart2;
+        BYTE* op3 = opStart3;
+        BYTE* op4 = opStart4;
         U32 endSignal = 1;
-        DTableDesc const dtd = HUF_getDTableDesc(DTable); 
-        U32 const dtLog = dtd.tableLog; 
- 
-        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */ 
+        DTableDesc const dtd = HUF_getDTableDesc(DTable);
+        U32 const dtLog = dtd.tableLog;
+
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
         if (opStart4 > oend) return ERROR(corruption_detected);      /* overflow */
-        CHECK_F( BIT_initDStream(&bitD1, istart1, length1) ); 
-        CHECK_F( BIT_initDStream(&bitD2, istart2, length2) ); 
-        CHECK_F( BIT_initDStream(&bitD3, istart3, length3) ); 
-        CHECK_F( BIT_initDStream(&bitD4, istart4, length4) ); 
- 
-        /* 16-32 symbols per loop (4-8 symbols per stream) */ 
+        CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );
+        CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );
+        CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );
+        CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );
+
+        /* 16-32 symbols per loop (4-8 symbols per stream) */
         if ((size_t)(oend - op4) >= sizeof(size_t)) {
             for ( ; (endSignal) & (op4 < olimit); ) {
 #if defined(__clang__) && (defined(__x86_64__) || defined(__i386__))
@@ -1339,29 +1339,29 @@ HUF_decompress4X2_usingDTable_internal_body(
                         & (BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished));
 #endif
             }
-        } 
- 
-        /* check corruption */ 
-        if (op1 > opStart2) return ERROR(corruption_detected); 
-        if (op2 > opStart3) return ERROR(corruption_detected); 
-        if (op3 > opStart4) return ERROR(corruption_detected); 
-        /* note : op4 already verified within main loop */ 
- 
-        /* finish bitStreams one by one */ 
-        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog); 
-        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog); 
-        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog); 
-        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog); 
- 
-        /* check */ 
-        { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4); 
-          if (!endCheck) return ERROR(corruption_detected); } 
- 
-        /* decoded size */ 
-        return dstSize; 
-    } 
-} 
- 
+        }
+
+        /* check corruption */
+        if (op1 > opStart2) return ERROR(corruption_detected);
+        if (op2 > opStart3) return ERROR(corruption_detected);
+        if (op3 > opStart4) return ERROR(corruption_detected);
+        /* note : op4 already verified within main loop */
+
+        /* finish bitStreams one by one */
+        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
+        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
+        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
+        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
+
+        /* check */
+        { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
+          if (!endCheck) return ERROR(corruption_detected); }
+
+        /* decoded size */
+        return dstSize;
+    }
+}
+
 #if HUF_NEED_BMI2_FUNCTION
 static BMI2_TARGET_ATTRIBUTE
 size_t HUF_decompress4X2_usingDTable_internal_bmi2(void* dst, size_t dstSize, void const* cSrc,
@@ -1454,91 +1454,91 @@ static size_t HUF_decompress4X2_usingDTable_internal(void* dst, size_t dstSize,
 #endif
 }
 
-HUF_DGEN(HUF_decompress1X2_usingDTable_internal) 
- 
-size_t HUF_decompress1X2_usingDTable( 
-          void* dst,  size_t dstSize, 
-    const void* cSrc, size_t cSrcSize, 
-    const HUF_DTable* DTable) 
-{ 
+HUF_DGEN(HUF_decompress1X2_usingDTable_internal)
+
+size_t HUF_decompress1X2_usingDTable(
+          void* dst,  size_t dstSize,
+    const void* cSrc, size_t cSrcSize,
+    const HUF_DTable* DTable)
+{
     DTableDesc dtd = HUF_getDTableDesc(DTable);
     if (dtd.tableType != 1) return ERROR(GENERIC);
-    return HUF_decompress1X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); 
+    return HUF_decompress1X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
 }
 
-size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize, 
+size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
                                    const void* cSrc, size_t cSrcSize,
                                    void* workSpace, size_t wkspSize)
 {
     const BYTE* ip = (const BYTE*) cSrc;
 
-    size_t const hSize = HUF_readDTableX2_wksp(DCtx, cSrc, cSrcSize, 
+    size_t const hSize = HUF_readDTableX2_wksp(DCtx, cSrc, cSrcSize,
                                                workSpace, wkspSize);
     if (HUF_isError(hSize)) return hSize;
     if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
     ip += hSize; cSrcSize -= hSize;
 
-    return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0); 
+    return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0);
 }
 
 
-size_t HUF_decompress4X2_usingDTable( 
+size_t HUF_decompress4X2_usingDTable(
           void* dst,  size_t dstSize,
     const void* cSrc, size_t cSrcSize,
     const HUF_DTable* DTable)
 {
     DTableDesc dtd = HUF_getDTableDesc(DTable);
     if (dtd.tableType != 1) return ERROR(GENERIC);
-    return HUF_decompress4X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); 
+    return HUF_decompress4X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
 }
 
-static size_t HUF_decompress4X2_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, 
+static size_t HUF_decompress4X2_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
                                    const void* cSrc, size_t cSrcSize,
                                    void* workSpace, size_t wkspSize, int bmi2)
 {
     const BYTE* ip = (const BYTE*) cSrc;
 
-    size_t hSize = HUF_readDTableX2_wksp(dctx, cSrc, cSrcSize, 
+    size_t hSize = HUF_readDTableX2_wksp(dctx, cSrc, cSrcSize,
                                          workSpace, wkspSize);
     if (HUF_isError(hSize)) return hSize;
     if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
     ip += hSize; cSrcSize -= hSize;
 
-    return HUF_decompress4X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2); 
+    return HUF_decompress4X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
 }
 
-size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, 
+size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
                                    const void* cSrc, size_t cSrcSize,
                                    void* workSpace, size_t wkspSize)
 {
-    return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, /* bmi2 */ 0); 
+    return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, /* bmi2 */ 0);
 }
 
 
-#endif /* HUF_FORCE_DECOMPRESS_X1 */ 
+#endif /* HUF_FORCE_DECOMPRESS_X1 */
+
 
+/* ***********************************/
+/* Universal decompression selectors */
+/* ***********************************/
 
-/* ***********************************/ 
-/* Universal decompression selectors */ 
-/* ***********************************/ 
- 
 size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize,
                                     const void* cSrc, size_t cSrcSize,
                                     const HUF_DTable* DTable)
 {
     DTableDesc const dtd = HUF_getDTableDesc(DTable);
-#if defined(HUF_FORCE_DECOMPRESS_X1) 
-    (void)dtd; 
-    assert(dtd.tableType == 0); 
-    return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); 
-#elif defined(HUF_FORCE_DECOMPRESS_X2) 
-    (void)dtd; 
-    assert(dtd.tableType == 1); 
-    return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); 
-#else 
-    return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) : 
-                           HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); 
-#endif 
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+    (void)dtd;
+    assert(dtd.tableType == 0);
+    return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+    (void)dtd;
+    assert(dtd.tableType == 1);
+    return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+#else
+    return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
+                           HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+#endif
 }
 
 size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize,
@@ -1546,22 +1546,22 @@ size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize,
                                     const HUF_DTable* DTable)
 {
     DTableDesc const dtd = HUF_getDTableDesc(DTable);
-#if defined(HUF_FORCE_DECOMPRESS_X1) 
-    (void)dtd; 
-    assert(dtd.tableType == 0); 
-    return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); 
-#elif defined(HUF_FORCE_DECOMPRESS_X2) 
-    (void)dtd; 
-    assert(dtd.tableType == 1); 
-    return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); 
-#else 
-    return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) : 
-                           HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0); 
-#endif 
-}
-
-
-#if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2) 
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+    (void)dtd;
+    assert(dtd.tableType == 0);
+    return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+    (void)dtd;
+    assert(dtd.tableType == 1);
+    return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+#else
+    return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
+                           HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
+#endif
+}
+
+
+#if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
 typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
 static const algo_time_t algoTime[16 /* Quantization */][2 /* single, double */] =
 {
@@ -1583,26 +1583,26 @@ static const algo_time_t algoTime[16 /* Quantization */][2 /* single, double */]
     {{1377,185}, {1731,202}},   /* Q ==14 : 87-93% */
     {{1412,185}, {1695,202}},   /* Q ==15 : 93-99% */
 };
-#endif 
+#endif
 
 /** HUF_selectDecoder() :
  *  Tells which decoder is likely to decode faster,
  *  based on a set of pre-computed metrics.
- * @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 . 
+ * @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 .
  *  Assumption : 0 < dstSize <= 128 KB */
 U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)
 {
     assert(dstSize > 0);
-    assert(dstSize <= 128*1024); 
-#if defined(HUF_FORCE_DECOMPRESS_X1) 
-    (void)dstSize; 
-    (void)cSrcSize; 
-    return 0; 
-#elif defined(HUF_FORCE_DECOMPRESS_X2) 
-    (void)dstSize; 
-    (void)cSrcSize; 
-    return 1; 
-#else 
+    assert(dstSize <= 128*1024);
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+    (void)dstSize;
+    (void)cSrcSize;
+    return 0;
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+    (void)dstSize;
+    (void)cSrcSize;
+    return 1;
+#else
     /* decoder timing evaluation */
     {   U32 const Q = (cSrcSize >= dstSize) ? 15 : (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 */
         U32 const D256 = (U32)(dstSize >> 8);
@@ -1610,9 +1610,9 @@ U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)
         U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256);
         DTime1 += DTime1 >> 5;  /* small advantage to algorithm using less memory, to reduce cache eviction */
         return DTime1 < DTime0;
-    } 
-#endif 
-} 
+    }
+#endif
+}
 
 
 size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst,
@@ -1625,19 +1625,19 @@ size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst,
     if (cSrcSize == 0) return ERROR(corruption_detected);
 
     {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
-#if defined(HUF_FORCE_DECOMPRESS_X1) 
-        (void)algoNb; 
-        assert(algoNb == 0); 
-        return HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize); 
-#elif defined(HUF_FORCE_DECOMPRESS_X2) 
-        (void)algoNb; 
-        assert(algoNb == 1); 
-        return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize); 
-#else 
-        return algoNb ? HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, 
-                            cSrcSize, workSpace, wkspSize): 
-                        HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize); 
-#endif 
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+        (void)algoNb;
+        assert(algoNb == 0);
+        return HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+        (void)algoNb;
+        assert(algoNb == 1);
+        return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
+#else
+        return algoNb ? HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
+                            cSrcSize, workSpace, wkspSize):
+                        HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
+#endif
     }
 }
 
@@ -1652,22 +1652,22 @@ size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
     if (cSrcSize == 1) { ZSTD_memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
 
     {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
-#if defined(HUF_FORCE_DECOMPRESS_X1) 
-        (void)algoNb; 
-        assert(algoNb == 0); 
-        return HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc, 
-                                cSrcSize, workSpace, wkspSize); 
-#elif defined(HUF_FORCE_DECOMPRESS_X2) 
-        (void)algoNb; 
-        assert(algoNb == 1); 
-        return HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc, 
-                                cSrcSize, workSpace, wkspSize); 
-#else 
-        return algoNb ? HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc, 
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+        (void)algoNb;
+        assert(algoNb == 0);
+        return HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
+                                cSrcSize, workSpace, wkspSize);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+        (void)algoNb;
+        assert(algoNb == 1);
+        return HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
+                                cSrcSize, workSpace, wkspSize);
+#else
+        return algoNb ? HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
                                 cSrcSize, workSpace, wkspSize):
-                        HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc, 
+                        HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
                                 cSrcSize, workSpace, wkspSize);
-#endif 
+#endif
     }
 }
 
@@ -1675,22 +1675,22 @@ size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
 size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
 {
     DTableDesc const dtd = HUF_getDTableDesc(DTable);
-#if defined(HUF_FORCE_DECOMPRESS_X1) 
-    (void)dtd; 
-    assert(dtd.tableType == 0); 
-    return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2); 
-#elif defined(HUF_FORCE_DECOMPRESS_X2) 
-    (void)dtd; 
-    assert(dtd.tableType == 1); 
-    return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2); 
-#else 
-    return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) : 
-                           HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2); 
-#endif 
-}
-
-#ifndef HUF_FORCE_DECOMPRESS_X2 
-size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2) 
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+    (void)dtd;
+    assert(dtd.tableType == 0);
+    return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+    (void)dtd;
+    assert(dtd.tableType == 1);
+    return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
+#else
+    return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) :
+                           HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
+#endif
+}
+
+#ifndef HUF_FORCE_DECOMPRESS_X2
+size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2)
 {
     const BYTE* ip = (const BYTE*) cSrc;
 
@@ -1699,25 +1699,25 @@ size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstS
     if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
     ip += hSize; cSrcSize -= hSize;
 
-    return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2); 
+    return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
 }
-#endif 
+#endif
 
 size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
 {
     DTableDesc const dtd = HUF_getDTableDesc(DTable);
-#if defined(HUF_FORCE_DECOMPRESS_X1) 
-    (void)dtd; 
-    assert(dtd.tableType == 0); 
-    return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2); 
-#elif defined(HUF_FORCE_DECOMPRESS_X2) 
-    (void)dtd; 
-    assert(dtd.tableType == 1); 
-    return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2); 
-#else 
-    return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) : 
-                           HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2); 
-#endif 
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+    (void)dtd;
+    assert(dtd.tableType == 0);
+    return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+    (void)dtd;
+    assert(dtd.tableType == 1);
+    return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
+#else
+    return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) :
+                           HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
+#endif
 }
 
 size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2)
@@ -1727,18 +1727,18 @@ size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t ds
     if (cSrcSize == 0) return ERROR(corruption_detected);
 
     {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
-#if defined(HUF_FORCE_DECOMPRESS_X1) 
-        (void)algoNb; 
-        assert(algoNb == 0); 
-        return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2); 
-#elif defined(HUF_FORCE_DECOMPRESS_X2) 
-        (void)algoNb; 
-        assert(algoNb == 1); 
-        return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2); 
-#else 
-        return algoNb ? HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2) : 
-                        HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2); 
-#endif 
+#if defined(HUF_FORCE_DECOMPRESS_X1)
+        (void)algoNb;
+        assert(algoNb == 0);
+        return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
+#elif defined(HUF_FORCE_DECOMPRESS_X2)
+        (void)algoNb;
+        assert(algoNb == 1);
+        return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
+#else
+        return algoNb ? HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2) :
+                        HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
+#endif
     }
 }
 
diff --git a/contrib/libs/zstd/lib/decompress/zstd_ddict.c b/contrib/libs/zstd/lib/decompress/zstd_ddict.c
index c3e4c14cba..ce335477b3 100644
--- a/contrib/libs/zstd/lib/decompress/zstd_ddict.c
+++ b/contrib/libs/zstd/lib/decompress/zstd_ddict.c
@@ -1,244 +1,244 @@
-/* 
+/*
  * Copyright (c) Yann Collet, Facebook, Inc.
- * All rights reserved. 
- * 
- * This source code is licensed under both the BSD-style license (found in the 
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found 
- * in the COPYING file in the root directory of this source tree). 
- * You may select, at your option, one of the above-listed licenses. 
- */ 
- 
-/* zstd_ddict.c : 
- * concentrates all logic that needs to know the internals of ZSTD_DDict object */ 
- 
-/*-******************************************************* 
-*  Dependencies 
-*********************************************************/ 
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+/* zstd_ddict.c :
+ * concentrates all logic that needs to know the internals of ZSTD_DDict object */
+
+/*-*******************************************************
+*  Dependencies
+*********************************************************/
 #include "../common/zstd_deps.h"   /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */
 #include "../common/cpu.h"         /* bmi2 */
 #include "../common/mem.h"         /* low level memory routines */
-#define FSE_STATIC_LINKING_ONLY 
+#define FSE_STATIC_LINKING_ONLY
 #include "../common/fse.h"
-#define HUF_STATIC_LINKING_ONLY 
+#define HUF_STATIC_LINKING_ONLY
 #include "../common/huf.h"
-#include "zstd_decompress_internal.h" 
-#include "zstd_ddict.h" 
- 
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1) 
+#include "zstd_decompress_internal.h"
+#include "zstd_ddict.h"
+
+#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
 #  include "../legacy/zstd_legacy.h"
-#endif 
- 
- 
- 
-/*-******************************************************* 
-*  Types 
-*********************************************************/ 
-struct ZSTD_DDict_s { 
-    void* dictBuffer; 
-    const void* dictContent; 
-    size_t dictSize; 
-    ZSTD_entropyDTables_t entropy; 
-    U32 dictID; 
-    U32 entropyPresent; 
-    ZSTD_customMem cMem; 
-};  /* typedef'd to ZSTD_DDict within "zstd.h" */ 
- 
-const void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict) 
-{ 
-    assert(ddict != NULL); 
-    return ddict->dictContent; 
-} 
- 
-size_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict) 
-{ 
-    assert(ddict != NULL); 
-    return ddict->dictSize; 
-} 
- 
-void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict) 
-{ 
-    DEBUGLOG(4, "ZSTD_copyDDictParameters"); 
-    assert(dctx != NULL); 
-    assert(ddict != NULL); 
-    dctx->dictID = ddict->dictID; 
-    dctx->prefixStart = ddict->dictContent; 
-    dctx->virtualStart = ddict->dictContent; 
-    dctx->dictEnd = (const BYTE*)ddict->dictContent + ddict->dictSize; 
-    dctx->previousDstEnd = dctx->dictEnd; 
+#endif
+
+
+
+/*-*******************************************************
+*  Types
+*********************************************************/
+struct ZSTD_DDict_s {
+    void* dictBuffer;
+    const void* dictContent;
+    size_t dictSize;
+    ZSTD_entropyDTables_t entropy;
+    U32 dictID;
+    U32 entropyPresent;
+    ZSTD_customMem cMem;
+};  /* typedef'd to ZSTD_DDict within "zstd.h" */
+
+const void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict)
+{
+    assert(ddict != NULL);
+    return ddict->dictContent;
+}
+
+size_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict)
+{
+    assert(ddict != NULL);
+    return ddict->dictSize;
+}
+
+void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
+{
+    DEBUGLOG(4, "ZSTD_copyDDictParameters");
+    assert(dctx != NULL);
+    assert(ddict != NULL);
+    dctx->dictID = ddict->dictID;
+    dctx->prefixStart = ddict->dictContent;
+    dctx->virtualStart = ddict->dictContent;
+    dctx->dictEnd = (const BYTE*)ddict->dictContent + ddict->dictSize;
+    dctx->previousDstEnd = dctx->dictEnd;
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     dctx->dictContentBeginForFuzzing = dctx->prefixStart;
     dctx->dictContentEndForFuzzing = dctx->previousDstEnd;
 #endif
-    if (ddict->entropyPresent) { 
-        dctx->litEntropy = 1; 
-        dctx->fseEntropy = 1; 
-        dctx->LLTptr = ddict->entropy.LLTable; 
-        dctx->MLTptr = ddict->entropy.MLTable; 
-        dctx->OFTptr = ddict->entropy.OFTable; 
-        dctx->HUFptr = ddict->entropy.hufTable; 
-        dctx->entropy.rep[0] = ddict->entropy.rep[0]; 
-        dctx->entropy.rep[1] = ddict->entropy.rep[1]; 
-        dctx->entropy.rep[2] = ddict->entropy.rep[2]; 
-    } else { 
-        dctx->litEntropy = 0; 
-        dctx->fseEntropy = 0; 
-    } 
-} 
- 
- 
-static size_t 
-ZSTD_loadEntropy_intoDDict(ZSTD_DDict* ddict, 
-                           ZSTD_dictContentType_e dictContentType) 
-{ 
-    ddict->dictID = 0; 
-    ddict->entropyPresent = 0; 
-    if (dictContentType == ZSTD_dct_rawContent) return 0; 
- 
-    if (ddict->dictSize < 8) { 
-        if (dictContentType == ZSTD_dct_fullDict) 
-            return ERROR(dictionary_corrupted);   /* only accept specified dictionaries */ 
-        return 0;   /* pure content mode */ 
-    } 
-    {   U32 const magic = MEM_readLE32(ddict->dictContent); 
-        if (magic != ZSTD_MAGIC_DICTIONARY) { 
-            if (dictContentType == ZSTD_dct_fullDict) 
-                return ERROR(dictionary_corrupted);   /* only accept specified dictionaries */ 
-            return 0;   /* pure content mode */ 
-        } 
-    } 
-    ddict->dictID = MEM_readLE32((const char*)ddict->dictContent + ZSTD_FRAMEIDSIZE); 
- 
-    /* load entropy tables */ 
-    RETURN_ERROR_IF(ZSTD_isError(ZSTD_loadDEntropy( 
-            &ddict->entropy, ddict->dictContent, ddict->dictSize)), 
+    if (ddict->entropyPresent) {
+        dctx->litEntropy = 1;
+        dctx->fseEntropy = 1;
+        dctx->LLTptr = ddict->entropy.LLTable;
+        dctx->MLTptr = ddict->entropy.MLTable;
+        dctx->OFTptr = ddict->entropy.OFTable;
+        dctx->HUFptr = ddict->entropy.hufTable;
+        dctx->entropy.rep[0] = ddict->entropy.rep[0];
+        dctx->entropy.rep[1] = ddict->entropy.rep[1];
+        dctx->entropy.rep[2] = ddict->entropy.rep[2];
+    } else {
+        dctx->litEntropy = 0;
+        dctx->fseEntropy = 0;
+    }
+}
+
+
+static size_t
+ZSTD_loadEntropy_intoDDict(ZSTD_DDict* ddict,
+                           ZSTD_dictContentType_e dictContentType)
+{
+    ddict->dictID = 0;
+    ddict->entropyPresent = 0;
+    if (dictContentType == ZSTD_dct_rawContent) return 0;
+
+    if (ddict->dictSize < 8) {
+        if (dictContentType == ZSTD_dct_fullDict)
+            return ERROR(dictionary_corrupted);   /* only accept specified dictionaries */
+        return 0;   /* pure content mode */
+    }
+    {   U32 const magic = MEM_readLE32(ddict->dictContent);
+        if (magic != ZSTD_MAGIC_DICTIONARY) {
+            if (dictContentType == ZSTD_dct_fullDict)
+                return ERROR(dictionary_corrupted);   /* only accept specified dictionaries */
+            return 0;   /* pure content mode */
+        }
+    }
+    ddict->dictID = MEM_readLE32((const char*)ddict->dictContent + ZSTD_FRAMEIDSIZE);
+
+    /* load entropy tables */
+    RETURN_ERROR_IF(ZSTD_isError(ZSTD_loadDEntropy(
+            &ddict->entropy, ddict->dictContent, ddict->dictSize)),
         dictionary_corrupted, "");
-    ddict->entropyPresent = 1; 
-    return 0; 
-} 
- 
- 
-static size_t ZSTD_initDDict_internal(ZSTD_DDict* ddict, 
-                                      const void* dict, size_t dictSize, 
-                                      ZSTD_dictLoadMethod_e dictLoadMethod, 
-                                      ZSTD_dictContentType_e dictContentType) 
-{ 
-    if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dict) || (!dictSize)) { 
-        ddict->dictBuffer = NULL; 
-        ddict->dictContent = dict; 
-        if (!dict) dictSize = 0; 
-    } else { 
+    ddict->entropyPresent = 1;
+    return 0;
+}
+
+
+static size_t ZSTD_initDDict_internal(ZSTD_DDict* ddict,
+                                      const void* dict, size_t dictSize,
+                                      ZSTD_dictLoadMethod_e dictLoadMethod,
+                                      ZSTD_dictContentType_e dictContentType)
+{
+    if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dict) || (!dictSize)) {
+        ddict->dictBuffer = NULL;
+        ddict->dictContent = dict;
+        if (!dict) dictSize = 0;
+    } else {
         void* const internalBuffer = ZSTD_customMalloc(dictSize, ddict->cMem);
-        ddict->dictBuffer = internalBuffer; 
-        ddict->dictContent = internalBuffer; 
-        if (!internalBuffer) return ERROR(memory_allocation); 
+        ddict->dictBuffer = internalBuffer;
+        ddict->dictContent = internalBuffer;
+        if (!internalBuffer) return ERROR(memory_allocation);
         ZSTD_memcpy(internalBuffer, dict, dictSize);
-    } 
-    ddict->dictSize = dictSize; 
-    ddict->entropy.hufTable[0] = (HUF_DTable)((HufLog)*0x1000001);  /* cover both little and big endian */ 
- 
-    /* parse dictionary content */ 
+    }
+    ddict->dictSize = dictSize;
+    ddict->entropy.hufTable[0] = (HUF_DTable)((HufLog)*0x1000001);  /* cover both little and big endian */
+
+    /* parse dictionary content */
     FORWARD_IF_ERROR( ZSTD_loadEntropy_intoDDict(ddict, dictContentType) , "");
- 
-    return 0; 
-} 
- 
-ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize, 
-                                      ZSTD_dictLoadMethod_e dictLoadMethod, 
-                                      ZSTD_dictContentType_e dictContentType, 
-                                      ZSTD_customMem customMem) 
-{ 
+
+    return 0;
+}
+
+ZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize,
+                                      ZSTD_dictLoadMethod_e dictLoadMethod,
+                                      ZSTD_dictContentType_e dictContentType,
+                                      ZSTD_customMem customMem)
+{
     if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;
- 
+
     {   ZSTD_DDict* const ddict = (ZSTD_DDict*) ZSTD_customMalloc(sizeof(ZSTD_DDict), customMem);
-        if (ddict == NULL) return NULL; 
-        ddict->cMem = customMem; 
-        {   size_t const initResult = ZSTD_initDDict_internal(ddict, 
-                                            dict, dictSize, 
-                                            dictLoadMethod, dictContentType); 
-            if (ZSTD_isError(initResult)) { 
-                ZSTD_freeDDict(ddict); 
-                return NULL; 
-        }   } 
-        return ddict; 
-    } 
-} 
- 
-/*! ZSTD_createDDict() : 
-*   Create a digested dictionary, to start decompression without startup delay. 
-*   `dict` content is copied inside DDict. 
-*   Consequently, `dict` can be released after `ZSTD_DDict` creation */ 
-ZSTD_DDict* ZSTD_createDDict(const void* dict, size_t dictSize) 
-{ 
-    ZSTD_customMem const allocator = { NULL, NULL, NULL }; 
-    return ZSTD_createDDict_advanced(dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto, allocator); 
-} 
- 
-/*! ZSTD_createDDict_byReference() : 
- *  Create a digested dictionary, to start decompression without startup delay. 
- *  Dictionary content is simply referenced, it will be accessed during decompression. 
- *  Warning : dictBuffer must outlive DDict (DDict must be freed before dictBuffer) */ 
-ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize) 
-{ 
-    ZSTD_customMem const allocator = { NULL, NULL, NULL }; 
-    return ZSTD_createDDict_advanced(dictBuffer, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, allocator); 
-} 
- 
- 
-const ZSTD_DDict* ZSTD_initStaticDDict( 
-                                void* sBuffer, size_t sBufferSize, 
-                                const void* dict, size_t dictSize, 
-                                ZSTD_dictLoadMethod_e dictLoadMethod, 
-                                ZSTD_dictContentType_e dictContentType) 
-{ 
-    size_t const neededSpace = sizeof(ZSTD_DDict) 
-                             + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize); 
-    ZSTD_DDict* const ddict = (ZSTD_DDict*)sBuffer; 
-    assert(sBuffer != NULL); 
-    assert(dict != NULL); 
-    if ((size_t)sBuffer & 7) return NULL;   /* 8-aligned */ 
-    if (sBufferSize < neededSpace) return NULL; 
-    if (dictLoadMethod == ZSTD_dlm_byCopy) { 
+        if (ddict == NULL) return NULL;
+        ddict->cMem = customMem;
+        {   size_t const initResult = ZSTD_initDDict_internal(ddict,
+                                            dict, dictSize,
+                                            dictLoadMethod, dictContentType);
+            if (ZSTD_isError(initResult)) {
+                ZSTD_freeDDict(ddict);
+                return NULL;
+        }   }
+        return ddict;
+    }
+}
+
+/*! ZSTD_createDDict() :
+*   Create a digested dictionary, to start decompression without startup delay.
+*   `dict` content is copied inside DDict.
+*   Consequently, `dict` can be released after `ZSTD_DDict` creation */
+ZSTD_DDict* ZSTD_createDDict(const void* dict, size_t dictSize)
+{
+    ZSTD_customMem const allocator = { NULL, NULL, NULL };
+    return ZSTD_createDDict_advanced(dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto, allocator);
+}
+
+/*! ZSTD_createDDict_byReference() :
+ *  Create a digested dictionary, to start decompression without startup delay.
+ *  Dictionary content is simply referenced, it will be accessed during decompression.
+ *  Warning : dictBuffer must outlive DDict (DDict must be freed before dictBuffer) */
+ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize)
+{
+    ZSTD_customMem const allocator = { NULL, NULL, NULL };
+    return ZSTD_createDDict_advanced(dictBuffer, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, allocator);
+}
+
+
+const ZSTD_DDict* ZSTD_initStaticDDict(
+                                void* sBuffer, size_t sBufferSize,
+                                const void* dict, size_t dictSize,
+                                ZSTD_dictLoadMethod_e dictLoadMethod,
+                                ZSTD_dictContentType_e dictContentType)
+{
+    size_t const neededSpace = sizeof(ZSTD_DDict)
+                             + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
+    ZSTD_DDict* const ddict = (ZSTD_DDict*)sBuffer;
+    assert(sBuffer != NULL);
+    assert(dict != NULL);
+    if ((size_t)sBuffer & 7) return NULL;   /* 8-aligned */
+    if (sBufferSize < neededSpace) return NULL;
+    if (dictLoadMethod == ZSTD_dlm_byCopy) {
         ZSTD_memcpy(ddict+1, dict, dictSize);  /* local copy */
-        dict = ddict+1; 
-    } 
-    if (ZSTD_isError( ZSTD_initDDict_internal(ddict, 
-                                              dict, dictSize, 
-                                              ZSTD_dlm_byRef, dictContentType) )) 
-        return NULL; 
-    return ddict; 
-} 
- 
- 
-size_t ZSTD_freeDDict(ZSTD_DDict* ddict) 
-{ 
-    if (ddict==NULL) return 0;   /* support free on NULL */ 
-    {   ZSTD_customMem const cMem = ddict->cMem; 
+        dict = ddict+1;
+    }
+    if (ZSTD_isError( ZSTD_initDDict_internal(ddict,
+                                              dict, dictSize,
+                                              ZSTD_dlm_byRef, dictContentType) ))
+        return NULL;
+    return ddict;
+}
+
+
+size_t ZSTD_freeDDict(ZSTD_DDict* ddict)
+{
+    if (ddict==NULL) return 0;   /* support free on NULL */
+    {   ZSTD_customMem const cMem = ddict->cMem;
         ZSTD_customFree(ddict->dictBuffer, cMem);
         ZSTD_customFree(ddict, cMem);
-        return 0; 
-    } 
-} 
- 
-/*! ZSTD_estimateDDictSize() : 
- *  Estimate amount of memory that will be needed to create a dictionary for decompression. 
- *  Note : dictionary created by reference using ZSTD_dlm_byRef are smaller */ 
-size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod) 
-{ 
-    return sizeof(ZSTD_DDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize); 
-} 
- 
-size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict) 
-{ 
-    if (ddict==NULL) return 0;   /* support sizeof on NULL */ 
-    return sizeof(*ddict) + (ddict->dictBuffer ? ddict->dictSize : 0) ; 
-} 
- 
-/*! ZSTD_getDictID_fromDDict() : 
- *  Provides the dictID of the dictionary loaded into `ddict`. 
- *  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty. 
- *  Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */ 
-unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict) 
-{ 
-    if (ddict==NULL) return 0; 
-    return ZSTD_getDictID_fromDict(ddict->dictContent, ddict->dictSize); 
-} 
+        return 0;
+    }
+}
+
+/*! ZSTD_estimateDDictSize() :
+ *  Estimate amount of memory that will be needed to create a dictionary for decompression.
+ *  Note : dictionary created by reference using ZSTD_dlm_byRef are smaller */
+size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod)
+{
+    return sizeof(ZSTD_DDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);
+}
+
+size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict)
+{
+    if (ddict==NULL) return 0;   /* support sizeof on NULL */
+    return sizeof(*ddict) + (ddict->dictBuffer ? ddict->dictSize : 0) ;
+}
+
+/*! ZSTD_getDictID_fromDDict() :
+ *  Provides the dictID of the dictionary loaded into `ddict`.
+ *  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
+ *  Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */
+unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict)
+{
+    if (ddict==NULL) return 0;
+    return ZSTD_getDictID_fromDict(ddict->dictContent, ddict->dictSize);
+}
diff --git a/contrib/libs/zstd/lib/decompress/zstd_ddict.h b/contrib/libs/zstd/lib/decompress/zstd_ddict.h
index 962688cac6..bd03268b50 100644
--- a/contrib/libs/zstd/lib/decompress/zstd_ddict.h
+++ b/contrib/libs/zstd/lib/decompress/zstd_ddict.h
@@ -1,44 +1,44 @@
-/* 
+/*
  * Copyright (c) Yann Collet, Facebook, Inc.
- * All rights reserved. 
- * 
- * This source code is licensed under both the BSD-style license (found in the 
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found 
- * in the COPYING file in the root directory of this source tree). 
- * You may select, at your option, one of the above-listed licenses. 
- */ 
- 
- 
-#ifndef ZSTD_DDICT_H 
-#define ZSTD_DDICT_H 
- 
-/*-******************************************************* 
- *  Dependencies 
- *********************************************************/ 
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+#ifndef ZSTD_DDICT_H
+#define ZSTD_DDICT_H
+
+/*-*******************************************************
+ *  Dependencies
+ *********************************************************/
 #include "../common/zstd_deps.h"   /* size_t */
 #include "../zstd.h"     /* ZSTD_DDict, and several public functions */
- 
- 
-/*-******************************************************* 
- *  Interface 
- *********************************************************/ 
- 
-/* note: several prototypes are already published in `zstd.h` : 
- * ZSTD_createDDict() 
- * ZSTD_createDDict_byReference() 
- * ZSTD_createDDict_advanced() 
- * ZSTD_freeDDict() 
- * ZSTD_initStaticDDict() 
- * ZSTD_sizeof_DDict() 
- * ZSTD_estimateDDictSize() 
- * ZSTD_getDictID_fromDict() 
- */ 
- 
-const void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict); 
-size_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict); 
- 
-void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict); 
- 
- 
- 
-#endif /* ZSTD_DDICT_H */ 
+
+
+/*-*******************************************************
+ *  Interface
+ *********************************************************/
+
+/* note: several prototypes are already published in `zstd.h` :
+ * ZSTD_createDDict()
+ * ZSTD_createDDict_byReference()
+ * ZSTD_createDDict_advanced()
+ * ZSTD_freeDDict()
+ * ZSTD_initStaticDDict()
+ * ZSTD_sizeof_DDict()
+ * ZSTD_estimateDDictSize()
+ * ZSTD_getDictID_fromDict()
+ */
+
+const void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict);
+size_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict);
+
+void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
+
+
+
+#endif /* ZSTD_DDICT_H */
diff --git a/contrib/libs/zstd/lib/decompress/zstd_decompress.c b/contrib/libs/zstd/lib/decompress/zstd_decompress.c
index 296fa189d3..b8bbefd538 100644
--- a/contrib/libs/zstd/lib/decompress/zstd_decompress.c
+++ b/contrib/libs/zstd/lib/decompress/zstd_decompress.c
@@ -37,21 +37,21 @@
  *  It's possible to set a different limit using ZSTD_DCtx_setMaxWindowSize().
  */
 #ifndef ZSTD_MAXWINDOWSIZE_DEFAULT
-#  define ZSTD_MAXWINDOWSIZE_DEFAULT (((U32)1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT) + 1) 
+#  define ZSTD_MAXWINDOWSIZE_DEFAULT (((U32)1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT) + 1)
 #endif
 
-/*! 
- *  NO_FORWARD_PROGRESS_MAX : 
- *  maximum allowed nb of calls to ZSTD_decompressStream() 
- *  without any forward progress 
- *  (defined as: no byte read from input, and no byte flushed to output) 
- *  before triggering an error. 
- */ 
-#ifndef ZSTD_NO_FORWARD_PROGRESS_MAX 
-#  define ZSTD_NO_FORWARD_PROGRESS_MAX 16 
-#endif 
-
- 
+/*!
+ *  NO_FORWARD_PROGRESS_MAX :
+ *  maximum allowed nb of calls to ZSTD_decompressStream()
+ *  without any forward progress
+ *  (defined as: no byte read from input, and no byte flushed to output)
+ *  before triggering an error.
+ */
+#ifndef ZSTD_NO_FORWARD_PROGRESS_MAX
+#  define ZSTD_NO_FORWARD_PROGRESS_MAX 16
+#endif
+
+
 /*-*******************************************************
 *  Dependencies
 *********************************************************/
@@ -63,9 +63,9 @@
 #include "../common/huf.h"
 #include <contrib/libs/xxhash/xxhash.h> /* XXH64_reset, XXH64_update, XXH64_digest, XXH64 */
 #include "../common/zstd_internal.h"  /* blockProperties_t */
-#include "zstd_decompress_internal.h"   /* ZSTD_DCtx */ 
-#include "zstd_ddict.h"  /* ZSTD_DDictDictContent */ 
-#include "zstd_decompress_block.h"   /* ZSTD_decompressBlock_internal */ 
+#include "zstd_decompress_internal.h"   /* ZSTD_DCtx */
+#include "zstd_ddict.h"  /* ZSTD_DDictDictContent */
+#include "zstd_decompress_block.h"   /* ZSTD_decompressBlock_internal */
 
 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
 #  include "../legacy/zstd_legacy.h"
@@ -250,18 +250,18 @@ static void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx)
     dctx->staticSize  = 0;
     dctx->ddict       = NULL;
     dctx->ddictLocal  = NULL;
-    dctx->dictEnd     = NULL; 
-    dctx->ddictIsCold = 0; 
-    dctx->dictUses = ZSTD_dont_use; 
+    dctx->dictEnd     = NULL;
+    dctx->ddictIsCold = 0;
+    dctx->dictUses = ZSTD_dont_use;
     dctx->inBuff      = NULL;
     dctx->inBuffSize  = 0;
     dctx->outBuffSize = 0;
     dctx->streamStage = zdss_init;
 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
-    dctx->legacyContext = NULL; 
-    dctx->previousLegacyVersion = 0; 
+    dctx->legacyContext = NULL;
+    dctx->previousLegacyVersion = 0;
 #endif
-    dctx->noForwardProgress = 0; 
+    dctx->noForwardProgress = 0;
     dctx->oversizedDuration = 0;
 #if DYNAMIC_BMI2
     dctx->bmi2 = ZSTD_cpuSupportsBmi2();
@@ -308,20 +308,20 @@ ZSTD_DCtx* ZSTD_createDCtx(void)
     return ZSTD_createDCtx_internal(ZSTD_defaultCMem);
 }
 
-static void ZSTD_clearDict(ZSTD_DCtx* dctx) 
-{ 
-    ZSTD_freeDDict(dctx->ddictLocal); 
-    dctx->ddictLocal = NULL; 
-    dctx->ddict = NULL; 
-    dctx->dictUses = ZSTD_dont_use; 
-} 
- 
+static void ZSTD_clearDict(ZSTD_DCtx* dctx)
+{
+    ZSTD_freeDDict(dctx->ddictLocal);
+    dctx->ddictLocal = NULL;
+    dctx->ddict = NULL;
+    dctx->dictUses = ZSTD_dont_use;
+}
+
 size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
 {
     if (dctx==NULL) return 0;   /* support free on NULL */
-    RETURN_ERROR_IF(dctx->staticSize, memory_allocation, "not compatible with static DCtx"); 
+    RETURN_ERROR_IF(dctx->staticSize, memory_allocation, "not compatible with static DCtx");
     {   ZSTD_customMem const cMem = dctx->customMem;
-        ZSTD_clearDict(dctx); 
+        ZSTD_clearDict(dctx);
         ZSTD_customFree(dctx->inBuff, cMem);
         dctx->inBuff = NULL;
 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
@@ -379,10 +379,10 @@ static void ZSTD_DCtx_selectFrameDDict(ZSTD_DCtx* dctx) {
  *  Note 3 : Skippable Frame Identifiers are considered valid. */
 unsigned ZSTD_isFrame(const void* buffer, size_t size)
 {
-    if (size < ZSTD_FRAMEIDSIZE) return 0; 
+    if (size < ZSTD_FRAMEIDSIZE) return 0;
     {   U32 const magic = MEM_readLE32(buffer);
         if (magic == ZSTD_MAGICNUMBER) return 1;
-        if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1; 
+        if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1;
     }
 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
     if (ZSTD_isLegacy(buffer, size)) return 1;
@@ -425,37 +425,37 @@ static size_t ZSTD_frameHeaderSize_internal(const void* src, size_t srcSize, ZST
 
 /** ZSTD_frameHeaderSize() :
  *  srcSize must be >= ZSTD_frameHeaderSize_prefix.
- * @return : size of the Frame Header, 
- *           or an error code (if srcSize is too small) */ 
+ * @return : size of the Frame Header,
+ *           or an error code (if srcSize is too small) */
 size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize)
 {
     return ZSTD_frameHeaderSize_internal(src, srcSize, ZSTD_f_zstd1);
 }
 
 
-/** ZSTD_getFrameHeader_advanced() : 
+/** ZSTD_getFrameHeader_advanced() :
  *  decode Frame Header, or require larger `srcSize`.
  *  note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless
  * @return : 0, `zfhPtr` is correctly filled,
  *          >0, `srcSize` is too small, value is wanted `srcSize` amount,
  *           or an error code, which can be tested using ZSTD_isError() */
-size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format) 
+size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format)
 {
     const BYTE* ip = (const BYTE*)src;
     size_t const minInputSize = ZSTD_startingInputLength(format);
 
     ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr));   /* not strictly necessary, but static analyzer do not understand that zfhPtr is only going to be read only if return value is zero, since they are 2 different signals */
     if (srcSize < minInputSize) return minInputSize;
-    RETURN_ERROR_IF(src==NULL, GENERIC, "invalid parameter"); 
+    RETURN_ERROR_IF(src==NULL, GENERIC, "invalid parameter");
 
     if ( (format != ZSTD_f_zstd1_magicless)
       && (MEM_readLE32(src) != ZSTD_MAGICNUMBER) ) {
-        if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { 
+        if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
             /* skippable frame */
-            if (srcSize < ZSTD_SKIPPABLEHEADERSIZE) 
-                return ZSTD_SKIPPABLEHEADERSIZE; /* magic number + frame length */ 
+            if (srcSize < ZSTD_SKIPPABLEHEADERSIZE)
+                return ZSTD_SKIPPABLEHEADERSIZE; /* magic number + frame length */
             ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr));
-            zfhPtr->frameContentSize = MEM_readLE32((const char *)src + ZSTD_FRAMEIDSIZE); 
+            zfhPtr->frameContentSize = MEM_readLE32((const char *)src + ZSTD_FRAMEIDSIZE);
             zfhPtr->frameType = ZSTD_skippableFrame;
             return 0;
         }
@@ -477,8 +477,8 @@ size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, s
         U64 windowSize = 0;
         U32 dictID = 0;
         U64 frameContentSize = ZSTD_CONTENTSIZE_UNKNOWN;
-        RETURN_ERROR_IF((fhdByte & 0x08) != 0, frameParameter_unsupported, 
-                        "reserved bits, must be zero"); 
+        RETURN_ERROR_IF((fhdByte & 0x08) != 0, frameParameter_unsupported,
+                        "reserved bits, must be zero");
 
         if (!singleSegment) {
             BYTE const wlByte = ip[pos++];
@@ -527,7 +527,7 @@ size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, s
  *           or an error code, which can be tested using ZSTD_isError() */
 size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize)
 {
-    return ZSTD_getFrameHeader_advanced(zfhPtr, src, srcSize, ZSTD_f_zstd1); 
+    return ZSTD_getFrameHeader_advanced(zfhPtr, src, srcSize, ZSTD_f_zstd1);
 }
 
 /** ZSTD_getFrameContentSize() :
@@ -553,23 +553,23 @@ unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize)
     }   }
 }
 
-static size_t readSkippableFrameSize(void const* src, size_t srcSize) 
-{ 
-    size_t const skippableHeaderSize = ZSTD_SKIPPABLEHEADERSIZE; 
-    U32 sizeU32; 
- 
+static size_t readSkippableFrameSize(void const* src, size_t srcSize)
+{
+    size_t const skippableHeaderSize = ZSTD_SKIPPABLEHEADERSIZE;
+    U32 sizeU32;
+
     RETURN_ERROR_IF(srcSize < ZSTD_SKIPPABLEHEADERSIZE, srcSize_wrong, "");
- 
-    sizeU32 = MEM_readLE32((BYTE const*)src + ZSTD_FRAMEIDSIZE); 
-    RETURN_ERROR_IF((U32)(sizeU32 + ZSTD_SKIPPABLEHEADERSIZE) < sizeU32, 
+
+    sizeU32 = MEM_readLE32((BYTE const*)src + ZSTD_FRAMEIDSIZE);
+    RETURN_ERROR_IF((U32)(sizeU32 + ZSTD_SKIPPABLEHEADERSIZE) < sizeU32,
                     frameParameter_unsupported, "");
     {
         size_t const skippableSize = skippableHeaderSize + sizeU32;
         RETURN_ERROR_IF(skippableSize > srcSize, srcSize_wrong, "");
         return skippableSize;
     }
-} 
- 
+}
+
 /*! ZSTD_readSkippableFrame() :
  * Retrieves a zstd skippable frame containing data given by src, and writes it to dst buffer.
  *
@@ -613,8 +613,8 @@ unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize)
     while (srcSize >= ZSTD_startingInputLength(ZSTD_f_zstd1)) {
         U32 const magicNumber = MEM_readLE32(src);
 
-        if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { 
-            size_t const skippableSize = readSkippableFrameSize(src, srcSize); 
+        if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
+            size_t const skippableSize = readSkippableFrameSize(src, srcSize);
             if (ZSTD_isError(skippableSize)) {
                 return ZSTD_CONTENTSIZE_ERROR;
             }
@@ -648,9 +648,9 @@ unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize)
 }
 
 /** ZSTD_getDecompressedSize() :
- *  compatible with legacy mode 
- * @return : decompressed size if known, 0 otherwise 
-             note : 0 can mean any of the following : 
+ *  compatible with legacy mode
+ * @return : decompressed size if known, 0 otherwise
+             note : 0 can mean any of the following :
                    - frame content is empty
                    - decompressed size field is not present in frame header
                    - frame header unknown / not supported
@@ -664,150 +664,150 @@ unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize)
 
 
 /** ZSTD_decodeFrameHeader() :
- * `headerSize` must be the size provided by ZSTD_frameHeaderSize(). 
+ * `headerSize` must be the size provided by ZSTD_frameHeaderSize().
  * If multiple DDict references are enabled, also will choose the correct DDict to use.
- * @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */ 
+ * @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */
 static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t headerSize)
 {
-    size_t const result = ZSTD_getFrameHeader_advanced(&(dctx->fParams), src, headerSize, dctx->format); 
+    size_t const result = ZSTD_getFrameHeader_advanced(&(dctx->fParams), src, headerSize, dctx->format);
     if (ZSTD_isError(result)) return result;    /* invalid header */
-    RETURN_ERROR_IF(result>0, srcSize_wrong, "headerSize too small"); 
+    RETURN_ERROR_IF(result>0, srcSize_wrong, "headerSize too small");
 
     /* Reference DDict requested by frame if dctx references multiple ddicts */
     if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts && dctx->ddictSet) {
         ZSTD_DCtx_selectFrameDDict(dctx);
     }
 
-#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION 
-    /* Skip the dictID check in fuzzing mode, because it makes the search 
-     * harder. 
-     */ 
-    RETURN_ERROR_IF(dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID), 
+#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+    /* Skip the dictID check in fuzzing mode, because it makes the search
+     * harder.
+     */
+    RETURN_ERROR_IF(dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID),
                     dictionary_wrong, "");
-#endif 
+#endif
     dctx->validateChecksum = (dctx->fParams.checksumFlag && !dctx->forceIgnoreChecksum) ? 1 : 0;
     if (dctx->validateChecksum) XXH64_reset(&dctx->xxhState, 0);
     dctx->processedCSize += headerSize;
     return 0;
 }
 
-static ZSTD_frameSizeInfo ZSTD_errorFrameSizeInfo(size_t ret) 
+static ZSTD_frameSizeInfo ZSTD_errorFrameSizeInfo(size_t ret)
 {
-    ZSTD_frameSizeInfo frameSizeInfo; 
-    frameSizeInfo.compressedSize = ret; 
-    frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR; 
-    return frameSizeInfo; 
+    ZSTD_frameSizeInfo frameSizeInfo;
+    frameSizeInfo.compressedSize = ret;
+    frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;
+    return frameSizeInfo;
 }
 
-static ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo(const void* src, size_t srcSize) 
+static ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo(const void* src, size_t srcSize)
 {
-    ZSTD_frameSizeInfo frameSizeInfo; 
+    ZSTD_frameSizeInfo frameSizeInfo;
     ZSTD_memset(&frameSizeInfo, 0, sizeof(ZSTD_frameSizeInfo));
 
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1) 
-    if (ZSTD_isLegacy(src, srcSize)) 
-        return ZSTD_findFrameSizeInfoLegacy(src, srcSize); 
-#endif 
+#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
+    if (ZSTD_isLegacy(src, srcSize))
+        return ZSTD_findFrameSizeInfoLegacy(src, srcSize);
+#endif
 
-    if ((srcSize >= ZSTD_SKIPPABLEHEADERSIZE) 
-        && (MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { 
-        frameSizeInfo.compressedSize = readSkippableFrameSize(src, srcSize); 
+    if ((srcSize >= ZSTD_SKIPPABLEHEADERSIZE)
+        && (MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
+        frameSizeInfo.compressedSize = readSkippableFrameSize(src, srcSize);
         assert(ZSTD_isError(frameSizeInfo.compressedSize) ||
                frameSizeInfo.compressedSize <= srcSize);
-        return frameSizeInfo; 
-    } else { 
-        const BYTE* ip = (const BYTE*)src; 
-        const BYTE* const ipstart = ip; 
-        size_t remainingSize = srcSize; 
-        size_t nbBlocks = 0; 
-        ZSTD_frameHeader zfh; 
-
-        /* Extract Frame Header */ 
-        {   size_t const ret = ZSTD_getFrameHeader(&zfh, src, srcSize); 
-            if (ZSTD_isError(ret)) 
-                return ZSTD_errorFrameSizeInfo(ret); 
-            if (ret > 0) 
-                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong)); 
+        return frameSizeInfo;
+    } else {
+        const BYTE* ip = (const BYTE*)src;
+        const BYTE* const ipstart = ip;
+        size_t remainingSize = srcSize;
+        size_t nbBlocks = 0;
+        ZSTD_frameHeader zfh;
+
+        /* Extract Frame Header */
+        {   size_t const ret = ZSTD_getFrameHeader(&zfh, src, srcSize);
+            if (ZSTD_isError(ret))
+                return ZSTD_errorFrameSizeInfo(ret);
+            if (ret > 0)
+                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
         }
 
-        ip += zfh.headerSize; 
-        remainingSize -= zfh.headerSize; 
+        ip += zfh.headerSize;
+        remainingSize -= zfh.headerSize;
 
-        /* Iterate over each block */ 
-        while (1) { 
-            blockProperties_t blockProperties; 
-            size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties); 
-            if (ZSTD_isError(cBlockSize)) 
-                return ZSTD_errorFrameSizeInfo(cBlockSize); 
+        /* Iterate over each block */
+        while (1) {
+            blockProperties_t blockProperties;
+            size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties);
+            if (ZSTD_isError(cBlockSize))
+                return ZSTD_errorFrameSizeInfo(cBlockSize);
 
-            if (ZSTD_blockHeaderSize + cBlockSize > remainingSize) 
-                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong)); 
+            if (ZSTD_blockHeaderSize + cBlockSize > remainingSize)
+                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
 
-            ip += ZSTD_blockHeaderSize + cBlockSize; 
-            remainingSize -= ZSTD_blockHeaderSize + cBlockSize; 
-            nbBlocks++; 
+            ip += ZSTD_blockHeaderSize + cBlockSize;
+            remainingSize -= ZSTD_blockHeaderSize + cBlockSize;
+            nbBlocks++;
 
-            if (blockProperties.lastBlock) break; 
+            if (blockProperties.lastBlock) break;
         }
 
-        /* Final frame content checksum */ 
-        if (zfh.checksumFlag) { 
-            if (remainingSize < 4) 
-                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong)); 
-            ip += 4; 
+        /* Final frame content checksum */
+        if (zfh.checksumFlag) {
+            if (remainingSize < 4)
+                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
+            ip += 4;
         }
 
         frameSizeInfo.compressedSize = (size_t)(ip - ipstart);
-        frameSizeInfo.decompressedBound = (zfh.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) 
-                                        ? zfh.frameContentSize 
-                                        : nbBlocks * zfh.blockSizeMax; 
-        return frameSizeInfo; 
+        frameSizeInfo.decompressedBound = (zfh.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN)
+                                        ? zfh.frameContentSize
+                                        : nbBlocks * zfh.blockSizeMax;
+        return frameSizeInfo;
     }
 }
 
-/** ZSTD_findFrameCompressedSize() : 
- *  compatible with legacy mode 
- *  `src` must point to the start of a ZSTD frame, ZSTD legacy frame, or skippable frame 
- *  `srcSize` must be at least as large as the frame contained 
- *  @return : the compressed size of the frame starting at `src` */ 
-size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize) 
+/** ZSTD_findFrameCompressedSize() :
+ *  compatible with legacy mode
+ *  `src` must point to the start of a ZSTD frame, ZSTD legacy frame, or skippable frame
+ *  `srcSize` must be at least as large as the frame contained
+ *  @return : the compressed size of the frame starting at `src` */
+size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize)
 {
-    ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize); 
-    return frameSizeInfo.compressedSize; 
+    ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize);
+    return frameSizeInfo.compressedSize;
 }
 
-/** ZSTD_decompressBound() : 
- *  compatible with legacy mode 
- *  `src` must point to the start of a ZSTD frame or a skippeable frame 
- *  `srcSize` must be at least as large as the frame contained 
- *  @return : the maximum decompressed size of the compressed source 
+/** ZSTD_decompressBound() :
+ *  compatible with legacy mode
+ *  `src` must point to the start of a ZSTD frame or a skippeable frame
+ *  `srcSize` must be at least as large as the frame contained
+ *  @return : the maximum decompressed size of the compressed source
  */
-unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize) 
-{
-    unsigned long long bound = 0; 
-    /* Iterate over each frame */ 
-    while (srcSize > 0) { 
-        ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize); 
-        size_t const compressedSize = frameSizeInfo.compressedSize; 
-        unsigned long long const decompressedBound = frameSizeInfo.decompressedBound; 
-        if (ZSTD_isError(compressedSize) || decompressedBound == ZSTD_CONTENTSIZE_ERROR) 
-            return ZSTD_CONTENTSIZE_ERROR; 
+unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize)
+{
+    unsigned long long bound = 0;
+    /* Iterate over each frame */
+    while (srcSize > 0) {
+        ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize);
+        size_t const compressedSize = frameSizeInfo.compressedSize;
+        unsigned long long const decompressedBound = frameSizeInfo.decompressedBound;
+        if (ZSTD_isError(compressedSize) || decompressedBound == ZSTD_CONTENTSIZE_ERROR)
+            return ZSTD_CONTENTSIZE_ERROR;
         assert(srcSize >= compressedSize);
-        src = (const BYTE*)src + compressedSize; 
-        srcSize -= compressedSize; 
-        bound += decompressedBound; 
+        src = (const BYTE*)src + compressedSize;
+        srcSize -= compressedSize;
+        bound += decompressedBound;
     }
-    return bound; 
+    return bound;
 }
 
 
-/*-************************************************************* 
- *   Frame decoding 
- ***************************************************************/ 
+/*-*************************************************************
+ *   Frame decoding
+ ***************************************************************/
 
 /** ZSTD_insertBlock() :
  *  insert `src` block into `dctx` history. Useful to track uncompressed blocks. */
-size_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize) 
+size_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize)
 {
     DEBUGLOG(5, "ZSTD_insertBlock: %u bytes", (unsigned)blockSize);
     ZSTD_checkContinuity(dctx, blockStart, blockSize);
@@ -816,30 +816,30 @@ size_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSiz
 }
 
 
-static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity, 
-                          const void* src, size_t srcSize) 
+static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,
+                          const void* src, size_t srcSize)
 {
-    DEBUGLOG(5, "ZSTD_copyRawBlock"); 
+    DEBUGLOG(5, "ZSTD_copyRawBlock");
     RETURN_ERROR_IF(srcSize > dstCapacity, dstSize_tooSmall, "");
-    if (dst == NULL) { 
-        if (srcSize == 0) return 0; 
+    if (dst == NULL) {
+        if (srcSize == 0) return 0;
         RETURN_ERROR(dstBuffer_null, "");
-    } 
+    }
     ZSTD_memcpy(dst, src, srcSize);
-    return srcSize; 
+    return srcSize;
 }
 
-static size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity, 
-                               BYTE b, 
-                               size_t regenSize) 
+static size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity,
+                               BYTE b,
+                               size_t regenSize)
 {
     RETURN_ERROR_IF(regenSize > dstCapacity, dstSize_tooSmall, "");
-    if (dst == NULL) { 
-        if (regenSize == 0) return 0; 
+    if (dst == NULL) {
+        if (regenSize == 0) return 0;
         RETURN_ERROR(dstBuffer_null, "");
     }
     ZSTD_memset(dst, b, regenSize);
-    return regenSize; 
+    return regenSize;
 }
 
 static void ZSTD_DCtx_trace_end(ZSTD_DCtx const* dctx, U64 uncompressedSize, U64 compressedSize, unsigned streaming)
@@ -867,12 +867,12 @@ static void ZSTD_DCtx_trace_end(ZSTD_DCtx const* dctx, U64 uncompressedSize, U64
     (void)streaming;
 #endif
 }
- 
+
 
 /*! ZSTD_decompressFrame() :
- * @dctx must be properly initialized 
- *  will update *srcPtr and *srcSizePtr, 
- *  to make *srcPtr progress by one frame. */ 
+ * @dctx must be properly initialized
+ *  will update *srcPtr and *srcSizePtr,
+ *  to make *srcPtr progress by one frame. */
 static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
                                    void* dst, size_t dstCapacity,
                              const void** srcPtr, size_t *srcSizePtr)
@@ -882,12 +882,12 @@ static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
     BYTE* const ostart = (BYTE*)dst;
     BYTE* const oend = dstCapacity != 0 ? ostart + dstCapacity : ostart;
     BYTE* op = ostart;
-    size_t remainingSrcSize = *srcSizePtr; 
+    size_t remainingSrcSize = *srcSizePtr;
+
+    DEBUGLOG(4, "ZSTD_decompressFrame (srcSize:%i)", (int)*srcSizePtr);
 
-    DEBUGLOG(4, "ZSTD_decompressFrame (srcSize:%i)", (int)*srcSizePtr); 
- 
     /* check */
-    RETURN_ERROR_IF( 
+    RETURN_ERROR_IF(
         remainingSrcSize < ZSTD_FRAMEHEADERSIZE_MIN(dctx->format)+ZSTD_blockHeaderSize,
         srcSize_wrong, "");
 
@@ -895,21 +895,21 @@ static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
     {   size_t const frameHeaderSize = ZSTD_frameHeaderSize_internal(
                 ip, ZSTD_FRAMEHEADERSIZE_PREFIX(dctx->format), dctx->format);
         if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;
-        RETURN_ERROR_IF(remainingSrcSize < frameHeaderSize+ZSTD_blockHeaderSize, 
+        RETURN_ERROR_IF(remainingSrcSize < frameHeaderSize+ZSTD_blockHeaderSize,
                         srcSize_wrong, "");
         FORWARD_IF_ERROR( ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize) , "");
-        ip += frameHeaderSize; remainingSrcSize -= frameHeaderSize; 
+        ip += frameHeaderSize; remainingSrcSize -= frameHeaderSize;
     }
 
     /* Loop on each block */
     while (1) {
         size_t decodedSize;
         blockProperties_t blockProperties;
-        size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSrcSize, &blockProperties); 
+        size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSrcSize, &blockProperties);
         if (ZSTD_isError(cBlockSize)) return cBlockSize;
 
         ip += ZSTD_blockHeaderSize;
-        remainingSrcSize -= ZSTD_blockHeaderSize; 
+        remainingSrcSize -= ZSTD_blockHeaderSize;
         RETURN_ERROR_IF(cBlockSize > remainingSrcSize, srcSize_wrong, "");
 
         switch(blockProperties.blockType)
@@ -935,14 +935,14 @@ static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
             op += decodedSize;
         assert(ip != NULL);
         ip += cBlockSize;
-        remainingSrcSize -= cBlockSize; 
+        remainingSrcSize -= cBlockSize;
         if (blockProperties.lastBlock) break;
     }
 
     if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) {
-        RETURN_ERROR_IF((U64)(op-ostart) != dctx->fParams.frameContentSize, 
+        RETURN_ERROR_IF((U64)(op-ostart) != dctx->fParams.frameContentSize,
                         corruption_detected, "");
-    } 
+    }
     if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */
         RETURN_ERROR_IF(remainingSrcSize<4, checksum_wrong, "");
         if (!dctx->forceIgnoreChecksum) {
@@ -952,12 +952,12 @@ static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
             RETURN_ERROR_IF(checkRead != checkCalc, checksum_wrong, "");
         }
         ip += 4;
-        remainingSrcSize -= 4; 
+        remainingSrcSize -= 4;
     }
     ZSTD_DCtx_trace_end(dctx, (U64)(op-ostart), (U64)(ip-istart), /* streaming */ 0);
     /* Allow caller to get size read */
     *srcPtr = ip;
-    *srcSizePtr = remainingSrcSize; 
+    *srcSizePtr = remainingSrcSize;
     return (size_t)(op-ostart);
 }
 
@@ -968,14 +968,14 @@ static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
                                   const ZSTD_DDict* ddict)
 {
     void* const dststart = dst;
-    int moreThan1Frame = 0; 
- 
-    DEBUGLOG(5, "ZSTD_decompressMultiFrame"); 
+    int moreThan1Frame = 0;
+
+    DEBUGLOG(5, "ZSTD_decompressMultiFrame");
     assert(dict==NULL || ddict==NULL);  /* either dict or ddict set, not both */
 
     if (ddict) {
-        dict = ZSTD_DDict_dictContent(ddict); 
-        dictSize = ZSTD_DDict_dictSize(ddict); 
+        dict = ZSTD_DDict_dictContent(ddict);
+        dictSize = ZSTD_DDict_dictSize(ddict);
     }
 
     while (srcSize >= ZSTD_startingInputLength(dctx->format)) {
@@ -985,11 +985,11 @@ static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
             size_t decodedSize;
             size_t const frameSize = ZSTD_findFrameCompressedSizeLegacy(src, srcSize);
             if (ZSTD_isError(frameSize)) return frameSize;
-            RETURN_ERROR_IF(dctx->staticSize, memory_allocation, 
-                "legacy support is not compatible with static dctx"); 
+            RETURN_ERROR_IF(dctx->staticSize, memory_allocation,
+                "legacy support is not compatible with static dctx");
 
             decodedSize = ZSTD_decompressLegacy(dst, dstCapacity, src, frameSize, dict, dictSize);
-            if (ZSTD_isError(decodedSize)) return decodedSize; 
+            if (ZSTD_isError(decodedSize)) return decodedSize;
 
             assert(decodedSize <= dstCapacity);
             dst = (BYTE*)dst + decodedSize;
@@ -1002,18 +1002,18 @@ static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
         }
 #endif
 
-        {   U32 const magicNumber = MEM_readLE32(src); 
-            DEBUGLOG(4, "reading magic number %08X (expecting %08X)", 
-                        (unsigned)magicNumber, ZSTD_MAGICNUMBER); 
-            if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { 
-                size_t const skippableSize = readSkippableFrameSize(src, srcSize); 
+        {   U32 const magicNumber = MEM_readLE32(src);
+            DEBUGLOG(4, "reading magic number %08X (expecting %08X)",
+                        (unsigned)magicNumber, ZSTD_MAGICNUMBER);
+            if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
+                size_t const skippableSize = readSkippableFrameSize(src, srcSize);
                 FORWARD_IF_ERROR(skippableSize, "readSkippableFrameSize failed");
                 assert(skippableSize <= srcSize);
 
                 src = (const BYTE *)src + skippableSize;
                 srcSize -= skippableSize;
                 continue;
-        }   } 
+        }   }
 
         if (ddict) {
             /* we were called from ZSTD_decompress_usingDDict */
@@ -1027,10 +1027,10 @@ static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
 
         {   const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity,
                                                     &src, &srcSize);
-            RETURN_ERROR_IF( 
-                (ZSTD_getErrorCode(res) == ZSTD_error_prefix_unknown) 
-             && (moreThan1Frame==1), 
-                srcSize_wrong, 
+            RETURN_ERROR_IF(
+                (ZSTD_getErrorCode(res) == ZSTD_error_prefix_unknown)
+             && (moreThan1Frame==1),
+                srcSize_wrong,
                 "At least one frame successfully completed, "
                 "but following bytes are garbage: "
                 "it's more likely to be a srcSize error, "
@@ -1039,15 +1039,15 @@ static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
                 "happening right at the place where we expect zstd magic bytes. "
                 "But this is _much_ less likely than a srcSize field error.");
             if (ZSTD_isError(res)) return res;
-            assert(res <= dstCapacity); 
+            assert(res <= dstCapacity);
             if (res != 0)
                 dst = (BYTE*)dst + res;
             dstCapacity -= res;
         }
-        moreThan1Frame = 1; 
+        moreThan1Frame = 1;
     }  /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */
 
-    RETURN_ERROR_IF(srcSize, srcSize_wrong, "input not entirely consumed"); 
+    RETURN_ERROR_IF(srcSize, srcSize_wrong, "input not entirely consumed");
 
     return (size_t)((BYTE*)dst - (BYTE*)dststart);
 }
@@ -1061,26 +1061,26 @@ size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
 }
 
 
-static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx) 
-{ 
-    switch (dctx->dictUses) { 
-    default: 
-        assert(0 /* Impossible */); 
+static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx)
+{
+    switch (dctx->dictUses) {
+    default:
+        assert(0 /* Impossible */);
         ZSTD_FALLTHROUGH;
-    case ZSTD_dont_use: 
-        ZSTD_clearDict(dctx); 
-        return NULL; 
-    case ZSTD_use_indefinitely: 
-        return dctx->ddict; 
-    case ZSTD_use_once: 
-        dctx->dictUses = ZSTD_dont_use; 
-        return dctx->ddict; 
-    } 
-} 
- 
+    case ZSTD_dont_use:
+        ZSTD_clearDict(dctx);
+        return NULL;
+    case ZSTD_use_indefinitely:
+        return dctx->ddict;
+    case ZSTD_use_once:
+        dctx->dictUses = ZSTD_dont_use;
+        return dctx->ddict;
+    }
+}
+
 size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
 {
-    return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ZSTD_getDDict(dctx)); 
+    return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ZSTD_getDDict(dctx));
 }
 
 
@@ -1095,7 +1095,7 @@ size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t sr
     return regenSize;
 #else   /* stack mode */
     ZSTD_DCtx dctx;
-    ZSTD_initDCtx_internal(&dctx); 
+    ZSTD_initDCtx_internal(&dctx);
     return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
 #endif
 }
@@ -1158,7 +1158,7 @@ static int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skip
  *            or an error code, which can be tested using ZSTD_isError() */
 size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
 {
-    DEBUGLOG(5, "ZSTD_decompressContinue (srcSize:%u)", (unsigned)srcSize); 
+    DEBUGLOG(5, "ZSTD_decompressContinue (srcSize:%u)", (unsigned)srcSize);
     /* Sanity check */
     RETURN_ERROR_IF(srcSize != ZSTD_nextSrcSizeToDecompressWithInputSize(dctx, srcSize), srcSize_wrong, "not allowed");
     ZSTD_checkContinuity(dctx, dst, dstCapacity);
@@ -1170,10 +1170,10 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, c
     case ZSTDds_getFrameHeaderSize :
         assert(src != NULL);
         if (dctx->format == ZSTD_f_zstd1) {  /* allows header */
-            assert(srcSize >= ZSTD_FRAMEIDSIZE);  /* to read skippable magic number */ 
-            if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {        /* skippable frame */ 
+            assert(srcSize >= ZSTD_FRAMEIDSIZE);  /* to read skippable magic number */
+            if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {        /* skippable frame */
                 ZSTD_memcpy(dctx->headerBuffer, src, srcSize);
-                dctx->expected = ZSTD_SKIPPABLEHEADERSIZE - srcSize;  /* remaining to load to get full skippable frame header */ 
+                dctx->expected = ZSTD_SKIPPABLEHEADERSIZE - srcSize;  /* remaining to load to get full skippable frame header */
                 dctx->stage = ZSTDds_decodeSkippableHeader;
                 return 0;
         }   }
@@ -1239,7 +1239,7 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, c
                 dctx->expected -= rSize;
                 break;
             case bt_rle :
-                rSize = ZSTD_setRleBlock(dst, dstCapacity, *(const BYTE*)src, dctx->rleSize); 
+                rSize = ZSTD_setRleBlock(dst, dstCapacity, *(const BYTE*)src, dctx->rleSize);
                 dctx->expected = 0;  /* Streaming not supported */
                 break;
             case bt_reserved :   /* should never happen */
@@ -1248,7 +1248,7 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, c
             }
             FORWARD_IF_ERROR(rSize, "");
             RETURN_ERROR_IF(rSize > dctx->fParams.blockSizeMax, corruption_detected, "Decompressed Block Size Exceeds Maximum");
-            DEBUGLOG(5, "ZSTD_decompressContinue: decoded size from block : %u", (unsigned)rSize); 
+            DEBUGLOG(5, "ZSTD_decompressContinue: decoded size from block : %u", (unsigned)rSize);
             dctx->decodedSize += rSize;
             if (dctx->validateChecksum) XXH64_update(&dctx->xxhState, dst, rSize);
             dctx->previousDstEnd = (char*)dst + rSize;
@@ -1259,10 +1259,10 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, c
             }
 
             if (dctx->stage == ZSTDds_decompressLastBlock) {   /* end of frame */
-                DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (unsigned)dctx->decodedSize); 
-                RETURN_ERROR_IF( 
-                    dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN 
-                 && dctx->decodedSize != dctx->fParams.frameContentSize, 
+                DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (unsigned)dctx->decodedSize);
+                RETURN_ERROR_IF(
+                    dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
+                 && dctx->decodedSize != dctx->fParams.frameContentSize,
                     corruption_detected, "");
                 if (dctx->fParams.checksumFlag) {  /* another round for frame checksum */
                     dctx->expected = 4;
@@ -1296,9 +1296,9 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, c
 
     case ZSTDds_decodeSkippableHeader:
         assert(src != NULL);
-        assert(srcSize <= ZSTD_SKIPPABLEHEADERSIZE); 
+        assert(srcSize <= ZSTD_SKIPPABLEHEADERSIZE);
         ZSTD_memcpy(dctx->headerBuffer + (ZSTD_SKIPPABLEHEADERSIZE - srcSize), src, srcSize);   /* complete skippable header */
-        dctx->expected = MEM_readLE32(dctx->headerBuffer + ZSTD_FRAMEIDSIZE);   /* note : dctx->expected can grow seriously large, beyond local buffer size */ 
+        dctx->expected = MEM_readLE32(dctx->headerBuffer + ZSTD_FRAMEIDSIZE);   /* note : dctx->expected can grow seriously large, beyond local buffer size */
         dctx->stage = ZSTDds_skipFrame;
         return 0;
 
@@ -1308,7 +1308,7 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, c
         return 0;
 
     default:
-        assert(0);   /* impossible */ 
+        assert(0);   /* impossible */
         RETURN_ERROR(GENERIC, "impossible to reach");   /* some compiler require default to do something */
     }
 }
@@ -1317,8 +1317,8 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, c
 static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
 {
     dctx->dictEnd = dctx->previousDstEnd;
-    dctx->virtualStart = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart)); 
-    dctx->prefixStart = dict; 
+    dctx->virtualStart = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
+    dctx->prefixStart = dict;
     dctx->previousDstEnd = (const char*)dict + dictSize;
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     dctx->dictContentBeginForFuzzing = dctx->prefixStart;
@@ -1327,46 +1327,46 @@ static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dict
     return 0;
 }
 
-/*! ZSTD_loadDEntropy() : 
- *  dict : must point at beginning of a valid zstd dictionary. 
+/*! ZSTD_loadDEntropy() :
+ *  dict : must point at beginning of a valid zstd dictionary.
  * @return : size of entropy tables read */
-size_t 
-ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy, 
-                  const void* const dict, size_t const dictSize) 
+size_t
+ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
+                  const void* const dict, size_t const dictSize)
 {
     const BYTE* dictPtr = (const BYTE*)dict;
     const BYTE* const dictEnd = dictPtr + dictSize;
 
     RETURN_ERROR_IF(dictSize <= 8, dictionary_corrupted, "dict is too small");
-    assert(MEM_readLE32(dict) == ZSTD_MAGIC_DICTIONARY);   /* dict must be valid */ 
+    assert(MEM_readLE32(dict) == ZSTD_MAGIC_DICTIONARY);   /* dict must be valid */
     dictPtr += 8;   /* skip header = magic + dictID */
 
-    ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, OFTable) == offsetof(ZSTD_entropyDTables_t, LLTable) + sizeof(entropy->LLTable)); 
-    ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, MLTable) == offsetof(ZSTD_entropyDTables_t, OFTable) + sizeof(entropy->OFTable)); 
-    ZSTD_STATIC_ASSERT(sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable) >= HUF_DECOMPRESS_WORKSPACE_SIZE); 
-    {   void* const workspace = &entropy->LLTable;   /* use fse tables as temporary workspace; implies fse tables are grouped together */ 
-        size_t const workspaceSize = sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable); 
-#ifdef HUF_FORCE_DECOMPRESS_X1 
-        /* in minimal huffman, we always use X1 variants */ 
-        size_t const hSize = HUF_readDTableX1_wksp(entropy->hufTable, 
-                                                dictPtr, dictEnd - dictPtr, 
-                                                workspace, workspaceSize); 
-#else 
-        size_t const hSize = HUF_readDTableX2_wksp(entropy->hufTable, 
+    ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, OFTable) == offsetof(ZSTD_entropyDTables_t, LLTable) + sizeof(entropy->LLTable));
+    ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, MLTable) == offsetof(ZSTD_entropyDTables_t, OFTable) + sizeof(entropy->OFTable));
+    ZSTD_STATIC_ASSERT(sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable) >= HUF_DECOMPRESS_WORKSPACE_SIZE);
+    {   void* const workspace = &entropy->LLTable;   /* use fse tables as temporary workspace; implies fse tables are grouped together */
+        size_t const workspaceSize = sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable);
+#ifdef HUF_FORCE_DECOMPRESS_X1
+        /* in minimal huffman, we always use X1 variants */
+        size_t const hSize = HUF_readDTableX1_wksp(entropy->hufTable,
+                                                dictPtr, dictEnd - dictPtr,
+                                                workspace, workspaceSize);
+#else
+        size_t const hSize = HUF_readDTableX2_wksp(entropy->hufTable,
                                                 dictPtr, (size_t)(dictEnd - dictPtr),
-                                                workspace, workspaceSize); 
-#endif 
+                                                workspace, workspaceSize);
+#endif
         RETURN_ERROR_IF(HUF_isError(hSize), dictionary_corrupted, "");
         dictPtr += hSize;
     }
 
     {   short offcodeNCount[MaxOff+1];
-        unsigned offcodeMaxValue = MaxOff, offcodeLog; 
+        unsigned offcodeMaxValue = MaxOff, offcodeLog;
         size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, (size_t)(dictEnd-dictPtr));
         RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted, "");
         RETURN_ERROR_IF(offcodeMaxValue > MaxOff, dictionary_corrupted, "");
         RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted, "");
-        ZSTD_buildFSETable( entropy->OFTable, 
+        ZSTD_buildFSETable( entropy->OFTable,
                             offcodeNCount, offcodeMaxValue,
                             OF_base, OF_bits,
                             offcodeLog,
@@ -1381,7 +1381,7 @@ ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
         RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted, "");
         RETURN_ERROR_IF(matchlengthMaxValue > MaxML, dictionary_corrupted, "");
         RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted, "");
-        ZSTD_buildFSETable( entropy->MLTable, 
+        ZSTD_buildFSETable( entropy->MLTable,
                             matchlengthNCount, matchlengthMaxValue,
                             ML_base, ML_bits,
                             matchlengthLog,
@@ -1396,7 +1396,7 @@ ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
         RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted, "");
         RETURN_ERROR_IF(litlengthMaxValue > MaxLL, dictionary_corrupted, "");
         RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted, "");
-        ZSTD_buildFSETable( entropy->LLTable, 
+        ZSTD_buildFSETable( entropy->LLTable,
                             litlengthNCount, litlengthMaxValue,
                             LL_base, LL_bits,
                             litlengthLog,
@@ -1425,10 +1425,10 @@ static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict
         if (magic != ZSTD_MAGIC_DICTIONARY) {
             return ZSTD_refDictContent(dctx, dict, dictSize);   /* pure content mode */
     }   }
-    dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE); 
+    dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
 
     /* load entropy tables */
-    {   size_t const eSize = ZSTD_loadDEntropy(&dctx->entropy, dict, dictSize); 
+    {   size_t const eSize = ZSTD_loadDEntropy(&dctx->entropy, dict, dictSize);
         RETURN_ERROR_IF(ZSTD_isError(eSize), dictionary_corrupted, "");
         dict = (const char*)dict + eSize;
         dictSize -= eSize;
@@ -1450,8 +1450,8 @@ size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx)
     dctx->processedCSize = 0;
     dctx->decodedSize = 0;
     dctx->previousDstEnd = NULL;
-    dctx->prefixStart = NULL; 
-    dctx->virtualStart = NULL; 
+    dctx->prefixStart = NULL;
+    dctx->virtualStart = NULL;
     dctx->dictEnd = NULL;
     dctx->entropy.hufTable[0] = (HUF_DTable)((HufLog)*0x1000001);  /* cover both little and big endian */
     dctx->litEntropy = dctx->fseEntropy = 0;
@@ -1470,8 +1470,8 @@ size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t
 {
     FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
     if (dict && dictSize)
-        RETURN_ERROR_IF( 
-            ZSTD_isError(ZSTD_decompress_insertDictionary(dctx, dict, dictSize)), 
+        RETURN_ERROR_IF(
+            ZSTD_isError(ZSTD_decompress_insertDictionary(dctx, dict, dictSize)),
             dictionary_corrupted, "");
     return 0;
 }
@@ -1479,21 +1479,21 @@ size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t
 
 /* ======   ZSTD_DDict   ====== */
 
-size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict) 
-{
-    DEBUGLOG(4, "ZSTD_decompressBegin_usingDDict"); 
-    assert(dctx != NULL); 
-    if (ddict) { 
-        const char* const dictStart = (const char*)ZSTD_DDict_dictContent(ddict); 
-        size_t const dictSize = ZSTD_DDict_dictSize(ddict); 
-        const void* const dictEnd = dictStart + dictSize; 
-        dctx->ddictIsCold = (dctx->dictEnd != dictEnd); 
-        DEBUGLOG(4, "DDict is %s", 
-                    dctx->ddictIsCold ? "~cold~" : "hot!"); 
+size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
+{
+    DEBUGLOG(4, "ZSTD_decompressBegin_usingDDict");
+    assert(dctx != NULL);
+    if (ddict) {
+        const char* const dictStart = (const char*)ZSTD_DDict_dictContent(ddict);
+        size_t const dictSize = ZSTD_DDict_dictSize(ddict);
+        const void* const dictEnd = dictStart + dictSize;
+        dctx->ddictIsCold = (dctx->dictEnd != dictEnd);
+        DEBUGLOG(4, "DDict is %s",
+                    dctx->ddictIsCold ? "~cold~" : "hot!");
     }
     FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
-    if (ddict) {   /* NULL ddict is equivalent to no dictionary */ 
-        ZSTD_copyDDictParameters(dctx, ddict); 
+    if (ddict) {   /* NULL ddict is equivalent to no dictionary */
+        ZSTD_copyDDictParameters(dctx, ddict);
     }
     return 0;
 }
@@ -1506,11 +1506,11 @@ unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize)
 {
     if (dictSize < 8) return 0;
     if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) return 0;
-    return MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE); 
+    return MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
 }
 
 /*! ZSTD_getDictID_fromFrame() :
- *  Provides the dictID required to decompress frame stored within `src`. 
+ *  Provides the dictID required to decompress frame stored within `src`.
  *  If @return == 0, the dictID could not be decoded.
  *  This could for one of the following reasons :
  *  - The frame does not require a dictionary (most common case).
@@ -1572,23 +1572,23 @@ size_t ZSTD_freeDStream(ZSTD_DStream* zds)
 }
 
 
-/* ***  Initialization  *** */ 
+/* ***  Initialization  *** */
 
 size_t ZSTD_DStreamInSize(void)  { return ZSTD_BLOCKSIZE_MAX + ZSTD_blockHeaderSize; }
 size_t ZSTD_DStreamOutSize(void) { return ZSTD_BLOCKSIZE_MAX; }
 
-size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx, 
-                                   const void* dict, size_t dictSize, 
-                                         ZSTD_dictLoadMethod_e dictLoadMethod, 
-                                         ZSTD_dictContentType_e dictContentType) 
+size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx,
+                                   const void* dict, size_t dictSize,
+                                         ZSTD_dictLoadMethod_e dictLoadMethod,
+                                         ZSTD_dictContentType_e dictContentType)
 {
     RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
-    ZSTD_clearDict(dctx); 
+    ZSTD_clearDict(dctx);
     if (dict && dictSize != 0) {
         dctx->ddictLocal = ZSTD_createDDict_advanced(dict, dictSize, dictLoadMethod, dictContentType, dctx->customMem);
         RETURN_ERROR_IF(dctx->ddictLocal == NULL, memory_allocation, "NULL pointer!");
-        dctx->ddict = dctx->ddictLocal; 
-        dctx->dictUses = ZSTD_use_indefinitely; 
+        dctx->ddict = dctx->ddictLocal;
+        dctx->dictUses = ZSTD_use_indefinitely;
     }
     return 0;
 }
@@ -1606,8 +1606,8 @@ size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSi
 size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)
 {
     FORWARD_IF_ERROR(ZSTD_DCtx_loadDictionary_advanced(dctx, prefix, prefixSize, ZSTD_dlm_byRef, dictContentType), "");
-    dctx->dictUses = ZSTD_use_once; 
-    return 0; 
+    dctx->dictUses = ZSTD_use_once;
+    return 0;
 }
 
 size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize)
@@ -1631,7 +1631,7 @@ size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t di
 size_t ZSTD_initDStream(ZSTD_DStream* zds)
 {
     DEBUGLOG(4, "ZSTD_initDStream");
-    return ZSTD_initDStream_usingDDict(zds, NULL); 
+    return ZSTD_initDStream_usingDDict(zds, NULL);
 }
 
 /* ZSTD_initDStream_usingDDict() :
@@ -1653,14 +1653,14 @@ size_t ZSTD_resetDStream(ZSTD_DStream* dctx)
     return ZSTD_startingInputLength(dctx->format);
 }
 
- 
-size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict) 
+
+size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
 {
     RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
-    ZSTD_clearDict(dctx); 
-    if (ddict) { 
-        dctx->ddict = ddict; 
-        dctx->dictUses = ZSTD_use_indefinitely; 
+    ZSTD_clearDict(dctx);
+    if (ddict) {
+        dctx->ddict = ddict;
+        dctx->dictUses = ZSTD_use_indefinitely;
         if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts) {
             if (dctx->ddictSet == NULL) {
                 dctx->ddictSet = ZSTD_createDDictHashSet(dctx->customMem);
@@ -1675,14 +1675,14 @@ size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
     return 0;
 }
 
-/* ZSTD_DCtx_setMaxWindowSize() : 
- * note : no direct equivalence in ZSTD_DCtx_setParameter, 
- * since this version sets windowSize, and the other sets windowLog */ 
+/* ZSTD_DCtx_setMaxWindowSize() :
+ * note : no direct equivalence in ZSTD_DCtx_setParameter,
+ * since this version sets windowSize, and the other sets windowLog */
 size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize)
 {
-    ZSTD_bounds const bounds = ZSTD_dParam_getBounds(ZSTD_d_windowLogMax); 
-    size_t const min = (size_t)1 << bounds.lowerBound; 
-    size_t const max = (size_t)1 << bounds.upperBound; 
+    ZSTD_bounds const bounds = ZSTD_dParam_getBounds(ZSTD_d_windowLogMax);
+    size_t const min = (size_t)1 << bounds.lowerBound;
+    size_t const max = (size_t)1 << bounds.upperBound;
     RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
     RETURN_ERROR_IF(maxWindowSize < min, parameter_outOfBound, "");
     RETURN_ERROR_IF(maxWindowSize > max, parameter_outOfBound, "");
@@ -1693,21 +1693,21 @@ size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize)
 size_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format)
 {
     return ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, (int)format);
-} 
- 
-ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam) 
-{ 
-    ZSTD_bounds bounds = { 0, 0, 0 }; 
-    switch(dParam) { 
-        case ZSTD_d_windowLogMax: 
-            bounds.lowerBound = ZSTD_WINDOWLOG_ABSOLUTEMIN; 
-            bounds.upperBound = ZSTD_WINDOWLOG_MAX; 
-            return bounds; 
-        case ZSTD_d_format: 
-            bounds.lowerBound = (int)ZSTD_f_zstd1; 
-            bounds.upperBound = (int)ZSTD_f_zstd1_magicless; 
-            ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless); 
-            return bounds; 
+}
+
+ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam)
+{
+    ZSTD_bounds bounds = { 0, 0, 0 };
+    switch(dParam) {
+        case ZSTD_d_windowLogMax:
+            bounds.lowerBound = ZSTD_WINDOWLOG_ABSOLUTEMIN;
+            bounds.upperBound = ZSTD_WINDOWLOG_MAX;
+            return bounds;
+        case ZSTD_d_format:
+            bounds.lowerBound = (int)ZSTD_f_zstd1;
+            bounds.upperBound = (int)ZSTD_f_zstd1_magicless;
+            ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);
+            return bounds;
         case ZSTD_d_stableOutBuffer:
             bounds.lowerBound = (int)ZSTD_bm_buffered;
             bounds.upperBound = (int)ZSTD_bm_stable;
@@ -1720,28 +1720,28 @@ ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam)
             bounds.lowerBound = (int)ZSTD_rmd_refSingleDDict;
             bounds.upperBound = (int)ZSTD_rmd_refMultipleDDicts;
             return bounds;
-        default:; 
-    } 
-    bounds.error = ERROR(parameter_unsupported); 
-    return bounds; 
-} 
- 
-/* ZSTD_dParam_withinBounds: 
- * @return 1 if value is within dParam bounds, 
- * 0 otherwise */ 
-static int ZSTD_dParam_withinBounds(ZSTD_dParameter dParam, int value) 
-{ 
-    ZSTD_bounds const bounds = ZSTD_dParam_getBounds(dParam); 
-    if (ZSTD_isError(bounds.error)) return 0; 
-    if (value < bounds.lowerBound) return 0; 
-    if (value > bounds.upperBound) return 0; 
-    return 1; 
-} 
- 
-#define CHECK_DBOUNDS(p,v) {                \ 
+        default:;
+    }
+    bounds.error = ERROR(parameter_unsupported);
+    return bounds;
+}
+
+/* ZSTD_dParam_withinBounds:
+ * @return 1 if value is within dParam bounds,
+ * 0 otherwise */
+static int ZSTD_dParam_withinBounds(ZSTD_dParameter dParam, int value)
+{
+    ZSTD_bounds const bounds = ZSTD_dParam_getBounds(dParam);
+    if (ZSTD_isError(bounds.error)) return 0;
+    if (value < bounds.lowerBound) return 0;
+    if (value > bounds.upperBound) return 0;
+    return 1;
+}
+
+#define CHECK_DBOUNDS(p,v) {                \
     RETURN_ERROR_IF(!ZSTD_dParam_withinBounds(p, v), parameter_outOfBound, ""); \
-} 
- 
+}
+
 size_t ZSTD_DCtx_getParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int* value)
 {
     switch (param) {
@@ -1765,19 +1765,19 @@ size_t ZSTD_DCtx_getParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int* value
     RETURN_ERROR(parameter_unsupported, "");
 }
 
-size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter dParam, int value) 
-{ 
+size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter dParam, int value)
+{
     RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
-    switch(dParam) { 
-        case ZSTD_d_windowLogMax: 
-            if (value == 0) value = ZSTD_WINDOWLOG_LIMIT_DEFAULT; 
-            CHECK_DBOUNDS(ZSTD_d_windowLogMax, value); 
-            dctx->maxWindowSize = ((size_t)1) << value; 
-            return 0; 
-        case ZSTD_d_format: 
-            CHECK_DBOUNDS(ZSTD_d_format, value); 
-            dctx->format = (ZSTD_format_e)value; 
-            return 0; 
+    switch(dParam) {
+        case ZSTD_d_windowLogMax:
+            if (value == 0) value = ZSTD_WINDOWLOG_LIMIT_DEFAULT;
+            CHECK_DBOUNDS(ZSTD_d_windowLogMax, value);
+            dctx->maxWindowSize = ((size_t)1) << value;
+            return 0;
+        case ZSTD_d_format:
+            CHECK_DBOUNDS(ZSTD_d_format, value);
+            dctx->format = (ZSTD_format_e)value;
+            return 0;
         case ZSTD_d_stableOutBuffer:
             CHECK_DBOUNDS(ZSTD_d_stableOutBuffer, value);
             dctx->outBufferMode = (ZSTD_bufferMode_e)value;
@@ -1793,24 +1793,24 @@ size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter dParam, int value
             }
             dctx->refMultipleDDicts = (ZSTD_refMultipleDDicts_e)value;
             return 0;
-        default:; 
-    } 
+        default:;
+    }
     RETURN_ERROR(parameter_unsupported, "");
-} 
- 
-size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset) 
-{ 
-    if ( (reset == ZSTD_reset_session_only) 
-      || (reset == ZSTD_reset_session_and_parameters) ) { 
-        dctx->streamStage = zdss_init; 
-        dctx->noForwardProgress = 0; 
-    } 
-    if ( (reset == ZSTD_reset_parameters) 
-      || (reset == ZSTD_reset_session_and_parameters) ) { 
+}
+
+size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset)
+{
+    if ( (reset == ZSTD_reset_session_only)
+      || (reset == ZSTD_reset_session_and_parameters) ) {
+        dctx->streamStage = zdss_init;
+        dctx->noForwardProgress = 0;
+    }
+    if ( (reset == ZSTD_reset_parameters)
+      || (reset == ZSTD_reset_session_and_parameters) ) {
         RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
-        ZSTD_clearDict(dctx); 
+        ZSTD_clearDict(dctx);
         ZSTD_DCtx_resetParameters(dctx);
-    } 
+    }
     return 0;
 }
 
@@ -1827,7 +1827,7 @@ size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long
     unsigned long long const neededRBSize = windowSize + blockSize + ZSTD_BLOCKSIZE_MAX + (WILDCOPY_OVERLENGTH * 2);
     unsigned long long const neededSize = MIN(frameContentSize, neededRBSize);
     size_t const minRBSize = (size_t) neededSize;
-    RETURN_ERROR_IF((unsigned long long)minRBSize != neededSize, 
+    RETURN_ERROR_IF((unsigned long long)minRBSize != neededSize,
                     frameParameter_windowTooLarge, "");
     return minRBSize;
 }
@@ -1842,12 +1842,12 @@ size_t ZSTD_estimateDStreamSize(size_t windowSize)
 
 size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize)
 {
-    U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX;   /* note : should be user-selectable, but requires an additional parameter (or a dctx) */ 
+    U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX;   /* note : should be user-selectable, but requires an additional parameter (or a dctx) */
     ZSTD_frameHeader zfh;
     size_t const err = ZSTD_getFrameHeader(&zfh, src, srcSize);
     if (ZSTD_isError(err)) return err;
     RETURN_ERROR_IF(err>0, srcSize_wrong, "");
-    RETURN_ERROR_IF(zfh.windowSize > windowSizeMax, 
+    RETURN_ERROR_IF(zfh.windowSize > windowSizeMax,
                     frameParameter_windowTooLarge, "");
     return ZSTD_estimateDStreamSize((size_t)zfh.windowSize);
 }
@@ -1938,16 +1938,16 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
     U32 someMoreWork = 1;
 
     DEBUGLOG(5, "ZSTD_decompressStream");
-    RETURN_ERROR_IF( 
-        input->pos > input->size, 
-        srcSize_wrong, 
-        "forbidden. in: pos: %u   vs size: %u", 
-        (U32)input->pos, (U32)input->size); 
-    RETURN_ERROR_IF( 
-        output->pos > output->size, 
-        dstSize_tooSmall, 
-        "forbidden. out: pos: %u   vs size: %u", 
-        (U32)output->pos, (U32)output->size); 
+    RETURN_ERROR_IF(
+        input->pos > input->size,
+        srcSize_wrong,
+        "forbidden. in: pos: %u   vs size: %u",
+        (U32)input->pos, (U32)input->size);
+    RETURN_ERROR_IF(
+        output->pos > output->size,
+        dstSize_tooSmall,
+        "forbidden. out: pos: %u   vs size: %u",
+        (U32)output->pos, (U32)output->size);
     DEBUGLOG(5, "input size : %u", (U32)(input->size - input->pos));
     FORWARD_IF_ERROR(ZSTD_checkOutBuffer(zds, output), "");
 
@@ -1956,12 +1956,12 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
         {
         case zdss_init :
             DEBUGLOG(5, "stage zdss_init => transparent reset ");
-            zds->streamStage = zdss_loadHeader; 
-            zds->lhSize = zds->inPos = zds->outStart = zds->outEnd = 0; 
+            zds->streamStage = zdss_loadHeader;
+            zds->lhSize = zds->inPos = zds->outStart = zds->outEnd = 0;
 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
-            zds->legacyVersion = 0; 
+            zds->legacyVersion = 0;
 #endif
-            zds->hostageByte = 0; 
+            zds->hostageByte = 0;
             zds->expectedOutBuffer = *output;
             ZSTD_FALLTHROUGH;
 
@@ -1969,14 +1969,14 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
             DEBUGLOG(5, "stage zdss_loadHeader (srcSize : %u)", (U32)(iend - ip));
 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
             if (zds->legacyVersion) {
-                RETURN_ERROR_IF(zds->staticSize, memory_allocation, 
-                    "legacy support is incompatible with static dctx"); 
+                RETURN_ERROR_IF(zds->staticSize, memory_allocation,
+                    "legacy support is incompatible with static dctx");
                 {   size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, zds->legacyVersion, output, input);
                     if (hint==0) zds->streamStage = zdss_init;
                     return hint;
             }   }
 #endif
-            {   size_t const hSize = ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format); 
+            {   size_t const hSize = ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format);
                 if (zds->refMultipleDDicts && zds->ddictSet) {
                     ZSTD_DCtx_selectFrameDDict(zds);
                 }
@@ -1985,13 +1985,13 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
                     U32 const legacyVersion = ZSTD_isLegacy(istart, iend-istart);
                     if (legacyVersion) {
-                        ZSTD_DDict const* const ddict = ZSTD_getDDict(zds); 
-                        const void* const dict = ddict ? ZSTD_DDict_dictContent(ddict) : NULL; 
-                        size_t const dictSize = ddict ? ZSTD_DDict_dictSize(ddict) : 0; 
+                        ZSTD_DDict const* const ddict = ZSTD_getDDict(zds);
+                        const void* const dict = ddict ? ZSTD_DDict_dictContent(ddict) : NULL;
+                        size_t const dictSize = ddict ? ZSTD_DDict_dictSize(ddict) : 0;
                         DEBUGLOG(5, "ZSTD_decompressStream: detected legacy version v0.%u", legacyVersion);
-                        RETURN_ERROR_IF(zds->staticSize, memory_allocation, 
-                            "legacy support is incompatible with static dctx"); 
-                        FORWARD_IF_ERROR(ZSTD_initLegacyStream(&zds->legacyContext, 
+                        RETURN_ERROR_IF(zds->staticSize, memory_allocation,
+                            "legacy support is incompatible with static dctx");
+                        FORWARD_IF_ERROR(ZSTD_initLegacyStream(&zds->legacyContext,
                                     zds->previousLegacyVersion, legacyVersion,
                                     dict, dictSize), "");
                         zds->legacyVersion = zds->previousLegacyVersion = legacyVersion;
@@ -2049,8 +2049,8 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
             DEBUGLOG(4, "Consume header");
             FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(zds, ZSTD_getDDict(zds)), "");
 
-            if ((MEM_readLE32(zds->headerBuffer) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {  /* skippable frame */ 
-                zds->expected = MEM_readLE32(zds->headerBuffer + ZSTD_FRAMEIDSIZE); 
+            if ((MEM_readLE32(zds->headerBuffer) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {  /* skippable frame */
+                zds->expected = MEM_readLE32(zds->headerBuffer + ZSTD_FRAMEIDSIZE);
                 zds->stage = ZSTDds_skipFrame;
             } else {
                 FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(zds, zds->headerBuffer, zds->lhSize), "");
@@ -2063,7 +2063,7 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
                         (U32)(zds->fParams.windowSize >>10),
                         (U32)(zds->maxWindowSize >> 10) );
             zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN);
-            RETURN_ERROR_IF(zds->fParams.windowSize > zds->maxWindowSize, 
+            RETURN_ERROR_IF(zds->fParams.windowSize > zds->maxWindowSize,
                             frameParameter_windowTooLarge, "");
 
             /* Adapt buffer sizes to frame header instructions */
@@ -2132,9 +2132,9 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
                 if (isSkipFrame) {
                     loadedSize = MIN(toLoad, (size_t)(iend-ip));
                 } else {
-                    RETURN_ERROR_IF(toLoad > zds->inBuffSize - zds->inPos, 
-                                    corruption_detected, 
-                                    "should never happen"); 
+                    RETURN_ERROR_IF(toLoad > zds->inBuffSize - zds->inPos,
+                                    corruption_detected,
+                                    "should never happen");
                     loadedSize = ZSTD_limitCopy(zds->inBuff + zds->inPos, toLoad, ip, (size_t)(iend-ip));
                 }
                 ip += loadedSize;
@@ -2167,28 +2167,28 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
             someMoreWork = 0;
             break;
 
-        default: 
-            assert(0);    /* impossible */ 
+        default:
+            assert(0);    /* impossible */
             RETURN_ERROR(GENERIC, "impossible to reach");   /* some compiler require default to do something */
     }   }
 
     /* result */
-    input->pos = (size_t)(ip - (const char*)(input->src)); 
-    output->pos = (size_t)(op - (char*)(output->dst)); 
+    input->pos = (size_t)(ip - (const char*)(input->src));
+    output->pos = (size_t)(op - (char*)(output->dst));
 
     /* Update the expected output buffer for ZSTD_obm_stable. */
     zds->expectedOutBuffer = *output;
 
-    if ((ip==istart) && (op==ostart)) {  /* no forward progress */ 
-        zds->noForwardProgress ++; 
-        if (zds->noForwardProgress >= ZSTD_NO_FORWARD_PROGRESS_MAX) { 
+    if ((ip==istart) && (op==ostart)) {  /* no forward progress */
+        zds->noForwardProgress ++;
+        if (zds->noForwardProgress >= ZSTD_NO_FORWARD_PROGRESS_MAX) {
             RETURN_ERROR_IF(op==oend, dstSize_tooSmall, "");
             RETURN_ERROR_IF(ip==iend, srcSize_wrong, "");
-            assert(0); 
-        } 
-    } else { 
-        zds->noForwardProgress = 0; 
-    } 
+            assert(0);
+        }
+    } else {
+        zds->noForwardProgress = 0;
+    }
     {   size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zds);
         if (!nextSrcSizeHint) {   /* frame fully decoded */
             if (zds->outEnd == zds->outStart) {  /* output fully flushed */
@@ -2215,7 +2215,7 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
     }
 }
 
-size_t ZSTD_decompressStream_simpleArgs ( 
+size_t ZSTD_decompressStream_simpleArgs (
                             ZSTD_DCtx* dctx,
                             void* dst, size_t dstCapacity, size_t* dstPos,
                       const void* src, size_t srcSize, size_t* srcPos)
@@ -2223,7 +2223,7 @@ size_t ZSTD_decompressStream_simpleArgs (
     ZSTD_outBuffer output = { dst, dstCapacity, *dstPos };
     ZSTD_inBuffer  input  = { src, srcSize, *srcPos };
     /* ZSTD_compress_generic() will check validity of dstPos and srcPos */
-    size_t const cErr = ZSTD_decompressStream(dctx, &output, &input); 
+    size_t const cErr = ZSTD_decompressStream(dctx, &output, &input);
     *dstPos = output.pos;
     *srcPos = input.pos;
     return cErr;
diff --git a/contrib/libs/zstd/lib/decompress/zstd_decompress_block.c b/contrib/libs/zstd/lib/decompress/zstd_decompress_block.c
index 85a01473b1..2e44d30d2f 100644
--- a/contrib/libs/zstd/lib/decompress/zstd_decompress_block.c
+++ b/contrib/libs/zstd/lib/decompress/zstd_decompress_block.c
@@ -1,74 +1,74 @@
-/* 
+/*
  * Copyright (c) Yann Collet, Facebook, Inc.
- * All rights reserved. 
- * 
- * This source code is licensed under both the BSD-style license (found in the 
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found 
- * in the COPYING file in the root directory of this source tree). 
- * You may select, at your option, one of the above-listed licenses. 
- */ 
- 
-/* zstd_decompress_block : 
- * this module takes care of decompressing _compressed_ block */ 
- 
-/*-******************************************************* 
-*  Dependencies 
-*********************************************************/ 
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+/* zstd_decompress_block :
+ * this module takes care of decompressing _compressed_ block */
+
+/*-*******************************************************
+*  Dependencies
+*********************************************************/
 #include "../common/zstd_deps.h"   /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */
 #include "../common/compiler.h"    /* prefetch */
 #include "../common/cpu.h"         /* bmi2 */
 #include "../common/mem.h"         /* low level memory routines */
-#define FSE_STATIC_LINKING_ONLY 
+#define FSE_STATIC_LINKING_ONLY
 #include "../common/fse.h"
-#define HUF_STATIC_LINKING_ONLY 
+#define HUF_STATIC_LINKING_ONLY
 #include "../common/huf.h"
 #include "../common/zstd_internal.h"
-#include "zstd_decompress_internal.h"   /* ZSTD_DCtx */ 
-#include "zstd_ddict.h"  /* ZSTD_DDictDictContent */ 
-#include "zstd_decompress_block.h" 
- 
-/*_******************************************************* 
-*  Macros 
-**********************************************************/ 
- 
-/* These two optional macros force the use one way or another of the two 
- * ZSTD_decompressSequences implementations. You can't force in both directions 
- * at the same time. 
- */ 
-#if defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \ 
-    defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG) 
-#error "Cannot force the use of the short and the long ZSTD_decompressSequences variants!" 
-#endif 
- 
- 
-/*_******************************************************* 
-*  Memory operations 
-**********************************************************/ 
+#include "zstd_decompress_internal.h"   /* ZSTD_DCtx */
+#include "zstd_ddict.h"  /* ZSTD_DDictDictContent */
+#include "zstd_decompress_block.h"
+
+/*_*******************************************************
+*  Macros
+**********************************************************/
+
+/* These two optional macros force the use one way or another of the two
+ * ZSTD_decompressSequences implementations. You can't force in both directions
+ * at the same time.
+ */
+#if defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
+    defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
+#error "Cannot force the use of the short and the long ZSTD_decompressSequences variants!"
+#endif
+
+
+/*_*******************************************************
+*  Memory operations
+**********************************************************/
 static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); }
- 
- 
-/*-************************************************************* 
- *   Block decoding 
- ***************************************************************/ 
- 
-/*! ZSTD_getcBlockSize() : 
- *  Provides the size of compressed block from block header `src` */ 
-size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, 
-                          blockProperties_t* bpPtr) 
-{ 
+
+
+/*-*************************************************************
+ *   Block decoding
+ ***************************************************************/
+
+/*! ZSTD_getcBlockSize() :
+ *  Provides the size of compressed block from block header `src` */
+size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
+                          blockProperties_t* bpPtr)
+{
     RETURN_ERROR_IF(srcSize < ZSTD_blockHeaderSize, srcSize_wrong, "");
- 
-    {   U32 const cBlockHeader = MEM_readLE24(src); 
-        U32 const cSize = cBlockHeader >> 3; 
-        bpPtr->lastBlock = cBlockHeader & 1; 
-        bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3); 
-        bpPtr->origSize = cSize;   /* only useful for RLE */ 
-        if (bpPtr->blockType == bt_rle) return 1; 
+
+    {   U32 const cBlockHeader = MEM_readLE24(src);
+        U32 const cSize = cBlockHeader >> 3;
+        bpPtr->lastBlock = cBlockHeader & 1;
+        bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3);
+        bpPtr->origSize = cSize;   /* only useful for RLE */
+        if (bpPtr->blockType == bt_rle) return 1;
         RETURN_ERROR_IF(bpPtr->blockType == bt_reserved, corruption_detected, "");
-        return cSize; 
-    } 
-} 
- 
+        return cSize;
+    }
+}
+
 /* Allocate buffer for literals, either overlapping current dst, or split between dst and litExtraBuffer, or stored entirely within litExtraBuffer */
 static void ZSTD_allocateLiteralsBuffer(ZSTD_DCtx* dctx, void* const dst, const size_t dstCapacity, const size_t litSize,
     const streaming_operation streaming, const size_t expectedWriteSize, const unsigned splitImmediately)
@@ -103,107 +103,107 @@ static void ZSTD_allocateLiteralsBuffer(ZSTD_DCtx* dctx, void* const dst, const
         dctx->litBufferLocation = ZSTD_not_in_dst;
     }
 }
- 
-/* Hidden declaration for fullbench */ 
-size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx, 
+
+/* Hidden declaration for fullbench */
+size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
                           const void* src, size_t srcSize,
                           void* dst, size_t dstCapacity, const streaming_operation streaming);
-/*! ZSTD_decodeLiteralsBlock() : 
+/*! ZSTD_decodeLiteralsBlock() :
  * Where it is possible to do so without being stomped by the output during decompression, the literals block will be stored
  * in the dstBuffer.  If there is room to do so, it will be stored in full in the excess dst space after where the current
  * block will be output.  Otherwise it will be stored at the end of the current dst blockspace, with a small portion being
  * stored in dctx->litExtraBuffer to help keep it "ahead" of the current output write.
  *
- * @return : nb of bytes read from src (< srcSize ) 
- *  note : symbol not declared but exposed for fullbench */ 
-size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx, 
+ * @return : nb of bytes read from src (< srcSize )
+ *  note : symbol not declared but exposed for fullbench */
+size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
                           const void* src, size_t srcSize,   /* note : srcSize < BLOCKSIZE */
                           void* dst, size_t dstCapacity, const streaming_operation streaming)
-{ 
+{
     DEBUGLOG(5, "ZSTD_decodeLiteralsBlock");
     RETURN_ERROR_IF(srcSize < MIN_CBLOCK_SIZE, corruption_detected, "");
- 
-    {   const BYTE* const istart = (const BYTE*) src; 
-        symbolEncodingType_e const litEncType = (symbolEncodingType_e)(istart[0] & 3); 
- 
-        switch(litEncType) 
-        { 
-        case set_repeat: 
+
+    {   const BYTE* const istart = (const BYTE*) src;
+        symbolEncodingType_e const litEncType = (symbolEncodingType_e)(istart[0] & 3);
+
+        switch(litEncType)
+        {
+        case set_repeat:
             DEBUGLOG(5, "set_repeat flag : re-using stats from previous compressed literals block");
             RETURN_ERROR_IF(dctx->litEntropy==0, dictionary_corrupted, "");
             ZSTD_FALLTHROUGH;
- 
-        case set_compressed: 
-            RETURN_ERROR_IF(srcSize < 5, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3"); 
-            {   size_t lhSize, litSize, litCSize; 
-                U32 singleStream=0; 
-                U32 const lhlCode = (istart[0] >> 2) & 3; 
-                U32 const lhc = MEM_readLE32(istart); 
-                size_t hufSuccess; 
+
+        case set_compressed:
+            RETURN_ERROR_IF(srcSize < 5, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 3");
+            {   size_t lhSize, litSize, litCSize;
+                U32 singleStream=0;
+                U32 const lhlCode = (istart[0] >> 2) & 3;
+                U32 const lhc = MEM_readLE32(istart);
+                size_t hufSuccess;
                 size_t expectedWriteSize = MIN(ZSTD_BLOCKSIZE_MAX, dstCapacity);
-                switch(lhlCode) 
-                { 
-                case 0: case 1: default:   /* note : default is impossible, since lhlCode into [0..3] */ 
-                    /* 2 - 2 - 10 - 10 */ 
-                    singleStream = !lhlCode; 
-                    lhSize = 3; 
-                    litSize  = (lhc >> 4) & 0x3FF; 
-                    litCSize = (lhc >> 14) & 0x3FF; 
-                    break; 
-                case 2: 
-                    /* 2 - 2 - 14 - 14 */ 
-                    lhSize = 4; 
-                    litSize  = (lhc >> 4) & 0x3FFF; 
-                    litCSize = lhc >> 18; 
-                    break; 
-                case 3: 
-                    /* 2 - 2 - 18 - 18 */ 
-                    lhSize = 5; 
-                    litSize  = (lhc >> 4) & 0x3FFFF; 
+                switch(lhlCode)
+                {
+                case 0: case 1: default:   /* note : default is impossible, since lhlCode into [0..3] */
+                    /* 2 - 2 - 10 - 10 */
+                    singleStream = !lhlCode;
+                    lhSize = 3;
+                    litSize  = (lhc >> 4) & 0x3FF;
+                    litCSize = (lhc >> 14) & 0x3FF;
+                    break;
+                case 2:
+                    /* 2 - 2 - 14 - 14 */
+                    lhSize = 4;
+                    litSize  = (lhc >> 4) & 0x3FFF;
+                    litCSize = lhc >> 18;
+                    break;
+                case 3:
+                    /* 2 - 2 - 18 - 18 */
+                    lhSize = 5;
+                    litSize  = (lhc >> 4) & 0x3FFFF;
                     litCSize = (lhc >> 22) + ((size_t)istart[4] << 10);
-                    break; 
-                } 
+                    break;
+                }
                 RETURN_ERROR_IF(litSize > 0 && dst == NULL, dstSize_tooSmall, "NULL not handled");
                 RETURN_ERROR_IF(litSize > ZSTD_BLOCKSIZE_MAX, corruption_detected, "");
                 RETURN_ERROR_IF(litCSize + lhSize > srcSize, corruption_detected, "");
                 RETURN_ERROR_IF(expectedWriteSize < litSize , dstSize_tooSmall, "");
                 ZSTD_allocateLiteralsBuffer(dctx, dst, dstCapacity, litSize, streaming, expectedWriteSize, 0);
- 
-                /* prefetch huffman table if cold */ 
-                if (dctx->ddictIsCold && (litSize > 768 /* heuristic */)) { 
-                    PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable)); 
-                } 
- 
-                if (litEncType==set_repeat) { 
-                    if (singleStream) { 
-                        hufSuccess = HUF_decompress1X_usingDTable_bmi2( 
-                            dctx->litBuffer, litSize, istart+lhSize, litCSize, 
+
+                /* prefetch huffman table if cold */
+                if (dctx->ddictIsCold && (litSize > 768 /* heuristic */)) {
+                    PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable));
+                }
+
+                if (litEncType==set_repeat) {
+                    if (singleStream) {
+                        hufSuccess = HUF_decompress1X_usingDTable_bmi2(
+                            dctx->litBuffer, litSize, istart+lhSize, litCSize,
                             dctx->HUFptr, ZSTD_DCtx_get_bmi2(dctx));
-                    } else { 
-                        hufSuccess = HUF_decompress4X_usingDTable_bmi2( 
-                            dctx->litBuffer, litSize, istart+lhSize, litCSize, 
+                    } else {
+                        hufSuccess = HUF_decompress4X_usingDTable_bmi2(
+                            dctx->litBuffer, litSize, istart+lhSize, litCSize,
                             dctx->HUFptr, ZSTD_DCtx_get_bmi2(dctx));
-                    } 
-                } else { 
-                    if (singleStream) { 
-#if defined(HUF_FORCE_DECOMPRESS_X2) 
-                        hufSuccess = HUF_decompress1X_DCtx_wksp( 
-                            dctx->entropy.hufTable, dctx->litBuffer, litSize, 
-                            istart+lhSize, litCSize, dctx->workspace, 
-                            sizeof(dctx->workspace)); 
-#else 
-                        hufSuccess = HUF_decompress1X1_DCtx_wksp_bmi2( 
-                            dctx->entropy.hufTable, dctx->litBuffer, litSize, 
-                            istart+lhSize, litCSize, dctx->workspace, 
+                    }
+                } else {
+                    if (singleStream) {
+#if defined(HUF_FORCE_DECOMPRESS_X2)
+                        hufSuccess = HUF_decompress1X_DCtx_wksp(
+                            dctx->entropy.hufTable, dctx->litBuffer, litSize,
+                            istart+lhSize, litCSize, dctx->workspace,
+                            sizeof(dctx->workspace));
+#else
+                        hufSuccess = HUF_decompress1X1_DCtx_wksp_bmi2(
+                            dctx->entropy.hufTable, dctx->litBuffer, litSize,
+                            istart+lhSize, litCSize, dctx->workspace,
                             sizeof(dctx->workspace), ZSTD_DCtx_get_bmi2(dctx));
-#endif 
-                    } else { 
-                        hufSuccess = HUF_decompress4X_hufOnly_wksp_bmi2( 
-                            dctx->entropy.hufTable, dctx->litBuffer, litSize, 
-                            istart+lhSize, litCSize, dctx->workspace, 
+#endif
+                    } else {
+                        hufSuccess = HUF_decompress4X_hufOnly_wksp_bmi2(
+                            dctx->entropy.hufTable, dctx->litBuffer, litSize,
+                            istart+lhSize, litCSize, dctx->workspace,
                             sizeof(dctx->workspace), ZSTD_DCtx_get_bmi2(dctx));
-                    } 
-                } 
+                    }
+                }
                 if (dctx->litBufferLocation == ZSTD_split)
                 {
                     ZSTD_memcpy(dctx->litExtraBuffer, dctx->litBufferEnd - ZSTD_LITBUFFEREXTRASIZE, ZSTD_LITBUFFEREXTRASIZE);
@@ -211,40 +211,40 @@ size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
                     dctx->litBuffer += ZSTD_LITBUFFEREXTRASIZE - WILDCOPY_OVERLENGTH;
                     dctx->litBufferEnd -= WILDCOPY_OVERLENGTH;
                 }
- 
+
                 RETURN_ERROR_IF(HUF_isError(hufSuccess), corruption_detected, "");
- 
-                dctx->litPtr = dctx->litBuffer; 
-                dctx->litSize = litSize; 
-                dctx->litEntropy = 1; 
-                if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable; 
-                return litCSize + lhSize; 
-            } 
- 
-        case set_basic: 
-            {   size_t litSize, lhSize; 
-                U32 const lhlCode = ((istart[0]) >> 2) & 3; 
+
+                dctx->litPtr = dctx->litBuffer;
+                dctx->litSize = litSize;
+                dctx->litEntropy = 1;
+                if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable;
+                return litCSize + lhSize;
+            }
+
+        case set_basic:
+            {   size_t litSize, lhSize;
+                U32 const lhlCode = ((istart[0]) >> 2) & 3;
                 size_t expectedWriteSize = MIN(ZSTD_BLOCKSIZE_MAX, dstCapacity);
-                switch(lhlCode) 
-                { 
-                case 0: case 2: default:   /* note : default is impossible, since lhlCode into [0..3] */ 
-                    lhSize = 1; 
-                    litSize = istart[0] >> 3; 
-                    break; 
-                case 1: 
-                    lhSize = 2; 
-                    litSize = MEM_readLE16(istart) >> 4; 
-                    break; 
-                case 3: 
-                    lhSize = 3; 
-                    litSize = MEM_readLE24(istart) >> 4; 
-                    break; 
-                } 
- 
+                switch(lhlCode)
+                {
+                case 0: case 2: default:   /* note : default is impossible, since lhlCode into [0..3] */
+                    lhSize = 1;
+                    litSize = istart[0] >> 3;
+                    break;
+                case 1:
+                    lhSize = 2;
+                    litSize = MEM_readLE16(istart) >> 4;
+                    break;
+                case 3:
+                    lhSize = 3;
+                    litSize = MEM_readLE24(istart) >> 4;
+                    break;
+                }
+
                 RETURN_ERROR_IF(litSize > 0 && dst == NULL, dstSize_tooSmall, "NULL not handled");
                 RETURN_ERROR_IF(expectedWriteSize < litSize, dstSize_tooSmall, "");
                 ZSTD_allocateLiteralsBuffer(dctx, dst, dstCapacity, litSize, streaming, expectedWriteSize, 1);
-                if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) {  /* risk reading beyond src buffer with wildcopy */ 
+                if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) {  /* risk reading beyond src buffer with wildcopy */
                     RETURN_ERROR_IF(litSize+lhSize > srcSize, corruption_detected, "");
                     if (dctx->litBufferLocation == ZSTD_split)
                     {
@@ -255,38 +255,38 @@ size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
                     {
                         ZSTD_memcpy(dctx->litBuffer, istart + lhSize, litSize);
                     }
-                    dctx->litPtr = dctx->litBuffer; 
-                    dctx->litSize = litSize; 
-                    return lhSize+litSize; 
-                } 
-                /* direct reference into compressed stream */ 
-                dctx->litPtr = istart+lhSize; 
-                dctx->litSize = litSize; 
+                    dctx->litPtr = dctx->litBuffer;
+                    dctx->litSize = litSize;
+                    return lhSize+litSize;
+                }
+                /* direct reference into compressed stream */
+                dctx->litPtr = istart+lhSize;
+                dctx->litSize = litSize;
                 dctx->litBufferEnd = dctx->litPtr + litSize;
                 dctx->litBufferLocation = ZSTD_not_in_dst;
-                return lhSize+litSize; 
-            } 
- 
-        case set_rle: 
-            {   U32 const lhlCode = ((istart[0]) >> 2) & 3; 
-                size_t litSize, lhSize; 
+                return lhSize+litSize;
+            }
+
+        case set_rle:
+            {   U32 const lhlCode = ((istart[0]) >> 2) & 3;
+                size_t litSize, lhSize;
                 size_t expectedWriteSize = MIN(ZSTD_BLOCKSIZE_MAX, dstCapacity);
-                switch(lhlCode) 
-                { 
-                case 0: case 2: default:   /* note : default is impossible, since lhlCode into [0..3] */ 
-                    lhSize = 1; 
-                    litSize = istart[0] >> 3; 
-                    break; 
-                case 1: 
-                    lhSize = 2; 
-                    litSize = MEM_readLE16(istart) >> 4; 
-                    break; 
-                case 3: 
-                    lhSize = 3; 
-                    litSize = MEM_readLE24(istart) >> 4; 
-                    RETURN_ERROR_IF(srcSize<4, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4"); 
-                    break; 
-                } 
+                switch(lhlCode)
+                {
+                case 0: case 2: default:   /* note : default is impossible, since lhlCode into [0..3] */
+                    lhSize = 1;
+                    litSize = istart[0] >> 3;
+                    break;
+                case 1:
+                    lhSize = 2;
+                    litSize = MEM_readLE16(istart) >> 4;
+                    break;
+                case 3:
+                    lhSize = 3;
+                    litSize = MEM_readLE24(istart) >> 4;
+                    RETURN_ERROR_IF(srcSize<4, corruption_detected, "srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4");
+                    break;
+                }
                 RETURN_ERROR_IF(litSize > 0 && dst == NULL, dstSize_tooSmall, "NULL not handled");
                 RETURN_ERROR_IF(litSize > ZSTD_BLOCKSIZE_MAX, corruption_detected, "");
                 RETURN_ERROR_IF(expectedWriteSize < litSize, dstSize_tooSmall, "");
@@ -300,185 +300,185 @@ size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
                 {
                     ZSTD_memset(dctx->litBuffer, istart[lhSize], litSize);
                 }
-                dctx->litPtr = dctx->litBuffer; 
-                dctx->litSize = litSize; 
-                return lhSize+1; 
-            } 
-        default: 
-            RETURN_ERROR(corruption_detected, "impossible"); 
-        } 
-    } 
-} 
- 
-/* Default FSE distribution tables. 
- * These are pre-calculated FSE decoding tables using default distributions as defined in specification : 
+                dctx->litPtr = dctx->litBuffer;
+                dctx->litSize = litSize;
+                return lhSize+1;
+            }
+        default:
+            RETURN_ERROR(corruption_detected, "impossible");
+        }
+    }
+}
+
+/* Default FSE distribution tables.
+ * These are pre-calculated FSE decoding tables using default distributions as defined in specification :
  * https://github.com/facebook/zstd/blob/release/doc/zstd_compression_format.md#default-distributions
- * They were generated programmatically with following method : 
- * - start from default distributions, present in /lib/common/zstd_internal.h 
- * - generate tables normally, using ZSTD_buildFSETable() 
- * - printout the content of tables 
- * - pretify output, report below, test with fuzzer to ensure it's correct */ 
- 
-/* Default FSE distribution table for Literal Lengths */ 
-static const ZSTD_seqSymbol LL_defaultDTable[(1<<LL_DEFAULTNORMLOG)+1] = { 
-     {  1,  1,  1, LL_DEFAULTNORMLOG},  /* header : fastMode, tableLog */ 
-     /* nextState, nbAddBits, nbBits, baseVal */ 
-     {  0,  0,  4,    0},  { 16,  0,  4,    0}, 
-     { 32,  0,  5,    1},  {  0,  0,  5,    3}, 
-     {  0,  0,  5,    4},  {  0,  0,  5,    6}, 
-     {  0,  0,  5,    7},  {  0,  0,  5,    9}, 
-     {  0,  0,  5,   10},  {  0,  0,  5,   12}, 
-     {  0,  0,  6,   14},  {  0,  1,  5,   16}, 
-     {  0,  1,  5,   20},  {  0,  1,  5,   22}, 
-     {  0,  2,  5,   28},  {  0,  3,  5,   32}, 
-     {  0,  4,  5,   48},  { 32,  6,  5,   64}, 
-     {  0,  7,  5,  128},  {  0,  8,  6,  256}, 
-     {  0, 10,  6, 1024},  {  0, 12,  6, 4096}, 
-     { 32,  0,  4,    0},  {  0,  0,  4,    1}, 
-     {  0,  0,  5,    2},  { 32,  0,  5,    4}, 
-     {  0,  0,  5,    5},  { 32,  0,  5,    7}, 
-     {  0,  0,  5,    8},  { 32,  0,  5,   10}, 
-     {  0,  0,  5,   11},  {  0,  0,  6,   13}, 
-     { 32,  1,  5,   16},  {  0,  1,  5,   18}, 
-     { 32,  1,  5,   22},  {  0,  2,  5,   24}, 
-     { 32,  3,  5,   32},  {  0,  3,  5,   40}, 
-     {  0,  6,  4,   64},  { 16,  6,  4,   64}, 
-     { 32,  7,  5,  128},  {  0,  9,  6,  512}, 
-     {  0, 11,  6, 2048},  { 48,  0,  4,    0}, 
-     { 16,  0,  4,    1},  { 32,  0,  5,    2}, 
-     { 32,  0,  5,    3},  { 32,  0,  5,    5}, 
-     { 32,  0,  5,    6},  { 32,  0,  5,    8}, 
-     { 32,  0,  5,    9},  { 32,  0,  5,   11}, 
-     { 32,  0,  5,   12},  {  0,  0,  6,   15}, 
-     { 32,  1,  5,   18},  { 32,  1,  5,   20}, 
-     { 32,  2,  5,   24},  { 32,  2,  5,   28}, 
-     { 32,  3,  5,   40},  { 32,  4,  5,   48}, 
-     {  0, 16,  6,65536},  {  0, 15,  6,32768}, 
-     {  0, 14,  6,16384},  {  0, 13,  6, 8192}, 
-};   /* LL_defaultDTable */ 
- 
-/* Default FSE distribution table for Offset Codes */ 
-static const ZSTD_seqSymbol OF_defaultDTable[(1<<OF_DEFAULTNORMLOG)+1] = { 
-    {  1,  1,  1, OF_DEFAULTNORMLOG},  /* header : fastMode, tableLog */ 
-    /* nextState, nbAddBits, nbBits, baseVal */ 
-    {  0,  0,  5,    0},     {  0,  6,  4,   61}, 
-    {  0,  9,  5,  509},     {  0, 15,  5,32765}, 
-    {  0, 21,  5,2097149},   {  0,  3,  5,    5}, 
-    {  0,  7,  4,  125},     {  0, 12,  5, 4093}, 
-    {  0, 18,  5,262141},    {  0, 23,  5,8388605}, 
-    {  0,  5,  5,   29},     {  0,  8,  4,  253}, 
-    {  0, 14,  5,16381},     {  0, 20,  5,1048573}, 
-    {  0,  2,  5,    1},     { 16,  7,  4,  125}, 
-    {  0, 11,  5, 2045},     {  0, 17,  5,131069}, 
-    {  0, 22,  5,4194301},   {  0,  4,  5,   13}, 
-    { 16,  8,  4,  253},     {  0, 13,  5, 8189}, 
-    {  0, 19,  5,524285},    {  0,  1,  5,    1}, 
-    { 16,  6,  4,   61},     {  0, 10,  5, 1021}, 
-    {  0, 16,  5,65533},     {  0, 28,  5,268435453}, 
-    {  0, 27,  5,134217725}, {  0, 26,  5,67108861}, 
-    {  0, 25,  5,33554429},  {  0, 24,  5,16777213}, 
-};   /* OF_defaultDTable */ 
- 
- 
-/* Default FSE distribution table for Match Lengths */ 
-static const ZSTD_seqSymbol ML_defaultDTable[(1<<ML_DEFAULTNORMLOG)+1] = { 
-    {  1,  1,  1, ML_DEFAULTNORMLOG},  /* header : fastMode, tableLog */ 
-    /* nextState, nbAddBits, nbBits, baseVal */ 
-    {  0,  0,  6,    3},  {  0,  0,  4,    4}, 
-    { 32,  0,  5,    5},  {  0,  0,  5,    6}, 
-    {  0,  0,  5,    8},  {  0,  0,  5,    9}, 
-    {  0,  0,  5,   11},  {  0,  0,  6,   13}, 
-    {  0,  0,  6,   16},  {  0,  0,  6,   19}, 
-    {  0,  0,  6,   22},  {  0,  0,  6,   25}, 
-    {  0,  0,  6,   28},  {  0,  0,  6,   31}, 
-    {  0,  0,  6,   34},  {  0,  1,  6,   37}, 
-    {  0,  1,  6,   41},  {  0,  2,  6,   47}, 
-    {  0,  3,  6,   59},  {  0,  4,  6,   83}, 
-    {  0,  7,  6,  131},  {  0,  9,  6,  515}, 
-    { 16,  0,  4,    4},  {  0,  0,  4,    5}, 
-    { 32,  0,  5,    6},  {  0,  0,  5,    7}, 
-    { 32,  0,  5,    9},  {  0,  0,  5,   10}, 
-    {  0,  0,  6,   12},  {  0,  0,  6,   15}, 
-    {  0,  0,  6,   18},  {  0,  0,  6,   21}, 
-    {  0,  0,  6,   24},  {  0,  0,  6,   27}, 
-    {  0,  0,  6,   30},  {  0,  0,  6,   33}, 
-    {  0,  1,  6,   35},  {  0,  1,  6,   39}, 
-    {  0,  2,  6,   43},  {  0,  3,  6,   51}, 
-    {  0,  4,  6,   67},  {  0,  5,  6,   99}, 
-    {  0,  8,  6,  259},  { 32,  0,  4,    4}, 
-    { 48,  0,  4,    4},  { 16,  0,  4,    5}, 
-    { 32,  0,  5,    7},  { 32,  0,  5,    8}, 
-    { 32,  0,  5,   10},  { 32,  0,  5,   11}, 
-    {  0,  0,  6,   14},  {  0,  0,  6,   17}, 
-    {  0,  0,  6,   20},  {  0,  0,  6,   23}, 
-    {  0,  0,  6,   26},  {  0,  0,  6,   29}, 
-    {  0,  0,  6,   32},  {  0, 16,  6,65539}, 
-    {  0, 15,  6,32771},  {  0, 14,  6,16387}, 
-    {  0, 13,  6, 8195},  {  0, 12,  6, 4099}, 
-    {  0, 11,  6, 2051},  {  0, 10,  6, 1027}, 
-};   /* ML_defaultDTable */ 
- 
- 
+ * They were generated programmatically with following method :
+ * - start from default distributions, present in /lib/common/zstd_internal.h
+ * - generate tables normally, using ZSTD_buildFSETable()
+ * - printout the content of tables
+ * - pretify output, report below, test with fuzzer to ensure it's correct */
+
+/* Default FSE distribution table for Literal Lengths */
+static const ZSTD_seqSymbol LL_defaultDTable[(1<<LL_DEFAULTNORMLOG)+1] = {
+     {  1,  1,  1, LL_DEFAULTNORMLOG},  /* header : fastMode, tableLog */
+     /* nextState, nbAddBits, nbBits, baseVal */
+     {  0,  0,  4,    0},  { 16,  0,  4,    0},
+     { 32,  0,  5,    1},  {  0,  0,  5,    3},
+     {  0,  0,  5,    4},  {  0,  0,  5,    6},
+     {  0,  0,  5,    7},  {  0,  0,  5,    9},
+     {  0,  0,  5,   10},  {  0,  0,  5,   12},
+     {  0,  0,  6,   14},  {  0,  1,  5,   16},
+     {  0,  1,  5,   20},  {  0,  1,  5,   22},
+     {  0,  2,  5,   28},  {  0,  3,  5,   32},
+     {  0,  4,  5,   48},  { 32,  6,  5,   64},
+     {  0,  7,  5,  128},  {  0,  8,  6,  256},
+     {  0, 10,  6, 1024},  {  0, 12,  6, 4096},
+     { 32,  0,  4,    0},  {  0,  0,  4,    1},
+     {  0,  0,  5,    2},  { 32,  0,  5,    4},
+     {  0,  0,  5,    5},  { 32,  0,  5,    7},
+     {  0,  0,  5,    8},  { 32,  0,  5,   10},
+     {  0,  0,  5,   11},  {  0,  0,  6,   13},
+     { 32,  1,  5,   16},  {  0,  1,  5,   18},
+     { 32,  1,  5,   22},  {  0,  2,  5,   24},
+     { 32,  3,  5,   32},  {  0,  3,  5,   40},
+     {  0,  6,  4,   64},  { 16,  6,  4,   64},
+     { 32,  7,  5,  128},  {  0,  9,  6,  512},
+     {  0, 11,  6, 2048},  { 48,  0,  4,    0},
+     { 16,  0,  4,    1},  { 32,  0,  5,    2},
+     { 32,  0,  5,    3},  { 32,  0,  5,    5},
+     { 32,  0,  5,    6},  { 32,  0,  5,    8},
+     { 32,  0,  5,    9},  { 32,  0,  5,   11},
+     { 32,  0,  5,   12},  {  0,  0,  6,   15},
+     { 32,  1,  5,   18},  { 32,  1,  5,   20},
+     { 32,  2,  5,   24},  { 32,  2,  5,   28},
+     { 32,  3,  5,   40},  { 32,  4,  5,   48},
+     {  0, 16,  6,65536},  {  0, 15,  6,32768},
+     {  0, 14,  6,16384},  {  0, 13,  6, 8192},
+};   /* LL_defaultDTable */
+
+/* Default FSE distribution table for Offset Codes */
+static const ZSTD_seqSymbol OF_defaultDTable[(1<<OF_DEFAULTNORMLOG)+1] = {
+    {  1,  1,  1, OF_DEFAULTNORMLOG},  /* header : fastMode, tableLog */
+    /* nextState, nbAddBits, nbBits, baseVal */
+    {  0,  0,  5,    0},     {  0,  6,  4,   61},
+    {  0,  9,  5,  509},     {  0, 15,  5,32765},
+    {  0, 21,  5,2097149},   {  0,  3,  5,    5},
+    {  0,  7,  4,  125},     {  0, 12,  5, 4093},
+    {  0, 18,  5,262141},    {  0, 23,  5,8388605},
+    {  0,  5,  5,   29},     {  0,  8,  4,  253},
+    {  0, 14,  5,16381},     {  0, 20,  5,1048573},
+    {  0,  2,  5,    1},     { 16,  7,  4,  125},
+    {  0, 11,  5, 2045},     {  0, 17,  5,131069},
+    {  0, 22,  5,4194301},   {  0,  4,  5,   13},
+    { 16,  8,  4,  253},     {  0, 13,  5, 8189},
+    {  0, 19,  5,524285},    {  0,  1,  5,    1},
+    { 16,  6,  4,   61},     {  0, 10,  5, 1021},
+    {  0, 16,  5,65533},     {  0, 28,  5,268435453},
+    {  0, 27,  5,134217725}, {  0, 26,  5,67108861},
+    {  0, 25,  5,33554429},  {  0, 24,  5,16777213},
+};   /* OF_defaultDTable */
+
+
+/* Default FSE distribution table for Match Lengths */
+static const ZSTD_seqSymbol ML_defaultDTable[(1<<ML_DEFAULTNORMLOG)+1] = {
+    {  1,  1,  1, ML_DEFAULTNORMLOG},  /* header : fastMode, tableLog */
+    /* nextState, nbAddBits, nbBits, baseVal */
+    {  0,  0,  6,    3},  {  0,  0,  4,    4},
+    { 32,  0,  5,    5},  {  0,  0,  5,    6},
+    {  0,  0,  5,    8},  {  0,  0,  5,    9},
+    {  0,  0,  5,   11},  {  0,  0,  6,   13},
+    {  0,  0,  6,   16},  {  0,  0,  6,   19},
+    {  0,  0,  6,   22},  {  0,  0,  6,   25},
+    {  0,  0,  6,   28},  {  0,  0,  6,   31},
+    {  0,  0,  6,   34},  {  0,  1,  6,   37},
+    {  0,  1,  6,   41},  {  0,  2,  6,   47},
+    {  0,  3,  6,   59},  {  0,  4,  6,   83},
+    {  0,  7,  6,  131},  {  0,  9,  6,  515},
+    { 16,  0,  4,    4},  {  0,  0,  4,    5},
+    { 32,  0,  5,    6},  {  0,  0,  5,    7},
+    { 32,  0,  5,    9},  {  0,  0,  5,   10},
+    {  0,  0,  6,   12},  {  0,  0,  6,   15},
+    {  0,  0,  6,   18},  {  0,  0,  6,   21},
+    {  0,  0,  6,   24},  {  0,  0,  6,   27},
+    {  0,  0,  6,   30},  {  0,  0,  6,   33},
+    {  0,  1,  6,   35},  {  0,  1,  6,   39},
+    {  0,  2,  6,   43},  {  0,  3,  6,   51},
+    {  0,  4,  6,   67},  {  0,  5,  6,   99},
+    {  0,  8,  6,  259},  { 32,  0,  4,    4},
+    { 48,  0,  4,    4},  { 16,  0,  4,    5},
+    { 32,  0,  5,    7},  { 32,  0,  5,    8},
+    { 32,  0,  5,   10},  { 32,  0,  5,   11},
+    {  0,  0,  6,   14},  {  0,  0,  6,   17},
+    {  0,  0,  6,   20},  {  0,  0,  6,   23},
+    {  0,  0,  6,   26},  {  0,  0,  6,   29},
+    {  0,  0,  6,   32},  {  0, 16,  6,65539},
+    {  0, 15,  6,32771},  {  0, 14,  6,16387},
+    {  0, 13,  6, 8195},  {  0, 12,  6, 4099},
+    {  0, 11,  6, 2051},  {  0, 10,  6, 1027},
+};   /* ML_defaultDTable */
+
+
 static void ZSTD_buildSeqTable_rle(ZSTD_seqSymbol* dt, U32 baseValue, U8 nbAddBits)
-{ 
-    void* ptr = dt; 
-    ZSTD_seqSymbol_header* const DTableH = (ZSTD_seqSymbol_header*)ptr; 
-    ZSTD_seqSymbol* const cell = dt + 1; 
- 
-    DTableH->tableLog = 0; 
-    DTableH->fastMode = 0; 
- 
-    cell->nbBits = 0; 
-    cell->nextState = 0; 
-    assert(nbAddBits < 255); 
+{
+    void* ptr = dt;
+    ZSTD_seqSymbol_header* const DTableH = (ZSTD_seqSymbol_header*)ptr;
+    ZSTD_seqSymbol* const cell = dt + 1;
+
+    DTableH->tableLog = 0;
+    DTableH->fastMode = 0;
+
+    cell->nbBits = 0;
+    cell->nextState = 0;
+    assert(nbAddBits < 255);
     cell->nbAdditionalBits = nbAddBits;
-    cell->baseValue = baseValue; 
-} 
- 
- 
-/* ZSTD_buildFSETable() : 
- * generate FSE decoding table for one symbol (ll, ml or off) 
- * cannot fail if input is valid => 
- * all inputs are presumed validated at this stage */ 
+    cell->baseValue = baseValue;
+}
+
+
+/* ZSTD_buildFSETable() :
+ * generate FSE decoding table for one symbol (ll, ml or off)
+ * cannot fail if input is valid =>
+ * all inputs are presumed validated at this stage */
 FORCE_INLINE_TEMPLATE
 void ZSTD_buildFSETable_body(ZSTD_seqSymbol* dt,
-            const short* normalizedCounter, unsigned maxSymbolValue, 
+            const short* normalizedCounter, unsigned maxSymbolValue,
             const U32* baseValue, const U8* nbAdditionalBits,
             unsigned tableLog, void* wksp, size_t wkspSize)
-{ 
-    ZSTD_seqSymbol* const tableDecode = dt+1; 
-    U32 const maxSV1 = maxSymbolValue + 1; 
-    U32 const tableSize = 1 << tableLog; 
- 
+{
+    ZSTD_seqSymbol* const tableDecode = dt+1;
+    U32 const maxSV1 = maxSymbolValue + 1;
+    U32 const tableSize = 1 << tableLog;
+
     U16* symbolNext = (U16*)wksp;
     BYTE* spread = (BYTE*)(symbolNext + MaxSeq + 1);
     U32 highThreshold = tableSize - 1;
 
 
-    /* Sanity Checks */ 
-    assert(maxSymbolValue <= MaxSeq); 
-    assert(tableLog <= MaxFSELog); 
+    /* Sanity Checks */
+    assert(maxSymbolValue <= MaxSeq);
+    assert(tableLog <= MaxFSELog);
     assert(wkspSize >= ZSTD_BUILD_FSE_TABLE_WKSP_SIZE);
     (void)wkspSize;
-    /* Init, lay down lowprob symbols */ 
-    {   ZSTD_seqSymbol_header DTableH; 
-        DTableH.tableLog = tableLog; 
-        DTableH.fastMode = 1; 
-        {   S16 const largeLimit= (S16)(1 << (tableLog-1)); 
-            U32 s; 
-            for (s=0; s<maxSV1; s++) { 
-                if (normalizedCounter[s]==-1) { 
-                    tableDecode[highThreshold--].baseValue = s; 
-                    symbolNext[s] = 1; 
-                } else { 
-                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0; 
+    /* Init, lay down lowprob symbols */
+    {   ZSTD_seqSymbol_header DTableH;
+        DTableH.tableLog = tableLog;
+        DTableH.fastMode = 1;
+        {   S16 const largeLimit= (S16)(1 << (tableLog-1));
+            U32 s;
+            for (s=0; s<maxSV1; s++) {
+                if (normalizedCounter[s]==-1) {
+                    tableDecode[highThreshold--].baseValue = s;
+                    symbolNext[s] = 1;
+                } else {
+                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
                     assert(normalizedCounter[s]>=0);
                     symbolNext[s] = (U16)normalizedCounter[s];
-        }   }   } 
+        }   }   }
         ZSTD_memcpy(dt, &DTableH, sizeof(DTableH));
-    } 
- 
-    /* Spread symbols */ 
+    }
+
+    /* Spread symbols */
     assert(tableSize <= 512);
     /* Specialized symbol spreading for the case when there are
      * no low probability (-1 count) symbols. When compressing
@@ -532,34 +532,34 @@ void ZSTD_buildFSETable_body(ZSTD_seqSymbol* dt,
         }
     } else {
         U32 const tableMask = tableSize-1;
-        U32 const step = FSE_TABLESTEP(tableSize); 
-        U32 s, position = 0; 
-        for (s=0; s<maxSV1; s++) { 
-            int i; 
+        U32 const step = FSE_TABLESTEP(tableSize);
+        U32 s, position = 0;
+        for (s=0; s<maxSV1; s++) {
+            int i;
             int const n = normalizedCounter[s];
             for (i=0; i<n; i++) {
-                tableDecode[position].baseValue = s; 
-                position = (position + step) & tableMask; 
-                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */ 
-        }   } 
-        assert(position == 0); /* position must reach all cells once, otherwise normalizedCounter is incorrect */ 
-    } 
- 
-    /* Build Decoding table */ 
+                tableDecode[position].baseValue = s;
+                position = (position + step) & tableMask;
+                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
+        }   }
+        assert(position == 0); /* position must reach all cells once, otherwise normalizedCounter is incorrect */
+    }
+
+    /* Build Decoding table */
     {
         U32 u;
-        for (u=0; u<tableSize; u++) { 
-            U32 const symbol = tableDecode[u].baseValue; 
-            U32 const nextState = symbolNext[symbol]++; 
-            tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) ); 
-            tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize); 
-            assert(nbAdditionalBits[symbol] < 255); 
+        for (u=0; u<tableSize; u++) {
+            U32 const symbol = tableDecode[u].baseValue;
+            U32 const nextState = symbolNext[symbol]++;
+            tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) );
+            tableDecode[u].nextState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
+            assert(nbAdditionalBits[symbol] < 255);
             tableDecode[u].nbAdditionalBits = nbAdditionalBits[symbol];
-            tableDecode[u].baseValue = baseValue[symbol]; 
+            tableDecode[u].baseValue = baseValue[symbol];
         }
     }
-} 
- 
+}
+
 /* Avoids the FORCE_INLINE of the _body() function. */
 static void ZSTD_buildFSETable_body_default(ZSTD_seqSymbol* dt,
             const short* normalizedCounter, unsigned maxSymbolValue,
@@ -569,7 +569,7 @@ static void ZSTD_buildFSETable_body_default(ZSTD_seqSymbol* dt,
     ZSTD_buildFSETable_body(dt, normalizedCounter, maxSymbolValue,
             baseValue, nbAdditionalBits, tableLog, wksp, wkspSize);
 }
- 
+
 #if DYNAMIC_BMI2
 BMI2_TARGET_ATTRIBUTE static void ZSTD_buildFSETable_body_bmi2(ZSTD_seqSymbol* dt,
             const short* normalizedCounter, unsigned maxSymbolValue,
@@ -599,156 +599,156 @@ void ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
 }
 
 
-/*! ZSTD_buildSeqTable() : 
- * @return : nb bytes read from src, 
- *           or an error code if it fails */ 
-static size_t ZSTD_buildSeqTable(ZSTD_seqSymbol* DTableSpace, const ZSTD_seqSymbol** DTablePtr, 
-                                 symbolEncodingType_e type, unsigned max, U32 maxLog, 
-                                 const void* src, size_t srcSize, 
+/*! ZSTD_buildSeqTable() :
+ * @return : nb bytes read from src,
+ *           or an error code if it fails */
+static size_t ZSTD_buildSeqTable(ZSTD_seqSymbol* DTableSpace, const ZSTD_seqSymbol** DTablePtr,
+                                 symbolEncodingType_e type, unsigned max, U32 maxLog,
+                                 const void* src, size_t srcSize,
                                  const U32* baseValue, const U8* nbAdditionalBits,
-                                 const ZSTD_seqSymbol* defaultTable, U32 flagRepeatTable, 
+                                 const ZSTD_seqSymbol* defaultTable, U32 flagRepeatTable,
                                  int ddictIsCold, int nbSeq, U32* wksp, size_t wkspSize,
                                  int bmi2)
-{ 
-    switch(type) 
-    { 
-    case set_rle : 
+{
+    switch(type)
+    {
+    case set_rle :
         RETURN_ERROR_IF(!srcSize, srcSize_wrong, "");
         RETURN_ERROR_IF((*(const BYTE*)src) > max, corruption_detected, "");
-        {   U32 const symbol = *(const BYTE*)src; 
-            U32 const baseline = baseValue[symbol]; 
+        {   U32 const symbol = *(const BYTE*)src;
+            U32 const baseline = baseValue[symbol];
             U8 const nbBits = nbAdditionalBits[symbol];
-            ZSTD_buildSeqTable_rle(DTableSpace, baseline, nbBits); 
-        } 
-        *DTablePtr = DTableSpace; 
-        return 1; 
-    case set_basic : 
-        *DTablePtr = defaultTable; 
-        return 0; 
-    case set_repeat: 
+            ZSTD_buildSeqTable_rle(DTableSpace, baseline, nbBits);
+        }
+        *DTablePtr = DTableSpace;
+        return 1;
+    case set_basic :
+        *DTablePtr = defaultTable;
+        return 0;
+    case set_repeat:
         RETURN_ERROR_IF(!flagRepeatTable, corruption_detected, "");
-        /* prefetch FSE table if used */ 
-        if (ddictIsCold && (nbSeq > 24 /* heuristic */)) { 
-            const void* const pStart = *DTablePtr; 
-            size_t const pSize = sizeof(ZSTD_seqSymbol) * (SEQSYMBOL_TABLE_SIZE(maxLog)); 
-            PREFETCH_AREA(pStart, pSize); 
-        } 
-        return 0; 
-    case set_compressed : 
-        {   unsigned tableLog; 
-            S16 norm[MaxSeq+1]; 
-            size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize); 
+        /* prefetch FSE table if used */
+        if (ddictIsCold && (nbSeq > 24 /* heuristic */)) {
+            const void* const pStart = *DTablePtr;
+            size_t const pSize = sizeof(ZSTD_seqSymbol) * (SEQSYMBOL_TABLE_SIZE(maxLog));
+            PREFETCH_AREA(pStart, pSize);
+        }
+        return 0;
+    case set_compressed :
+        {   unsigned tableLog;
+            S16 norm[MaxSeq+1];
+            size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize);
             RETURN_ERROR_IF(FSE_isError(headerSize), corruption_detected, "");
             RETURN_ERROR_IF(tableLog > maxLog, corruption_detected, "");
             ZSTD_buildFSETable(DTableSpace, norm, max, baseValue, nbAdditionalBits, tableLog, wksp, wkspSize, bmi2);
-            *DTablePtr = DTableSpace; 
-            return headerSize; 
-        } 
-    default : 
-        assert(0); 
-        RETURN_ERROR(GENERIC, "impossible"); 
-    } 
-} 
- 
-size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr, 
-                             const void* src, size_t srcSize) 
-{ 
+            *DTablePtr = DTableSpace;
+            return headerSize;
+        }
+    default :
+        assert(0);
+        RETURN_ERROR(GENERIC, "impossible");
+    }
+}
+
+size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
+                             const void* src, size_t srcSize)
+{
     const BYTE* const istart = (const BYTE*)src;
-    const BYTE* const iend = istart + srcSize; 
-    const BYTE* ip = istart; 
-    int nbSeq; 
-    DEBUGLOG(5, "ZSTD_decodeSeqHeaders"); 
- 
-    /* check */ 
+    const BYTE* const iend = istart + srcSize;
+    const BYTE* ip = istart;
+    int nbSeq;
+    DEBUGLOG(5, "ZSTD_decodeSeqHeaders");
+
+    /* check */
     RETURN_ERROR_IF(srcSize < MIN_SEQUENCES_SIZE, srcSize_wrong, "");
- 
-    /* SeqHead */ 
-    nbSeq = *ip++; 
-    if (!nbSeq) { 
-        *nbSeqPtr=0; 
+
+    /* SeqHead */
+    nbSeq = *ip++;
+    if (!nbSeq) {
+        *nbSeqPtr=0;
         RETURN_ERROR_IF(srcSize != 1, srcSize_wrong, "");
-        return 1; 
-    } 
-    if (nbSeq > 0x7F) { 
-        if (nbSeq == 0xFF) { 
+        return 1;
+    }
+    if (nbSeq > 0x7F) {
+        if (nbSeq == 0xFF) {
             RETURN_ERROR_IF(ip+2 > iend, srcSize_wrong, "");
             nbSeq = MEM_readLE16(ip) + LONGNBSEQ;
             ip+=2;
-        } else { 
+        } else {
             RETURN_ERROR_IF(ip >= iend, srcSize_wrong, "");
-            nbSeq = ((nbSeq-0x80)<<8) + *ip++; 
-        } 
-    } 
-    *nbSeqPtr = nbSeq; 
- 
-    /* FSE table descriptors */ 
+            nbSeq = ((nbSeq-0x80)<<8) + *ip++;
+        }
+    }
+    *nbSeqPtr = nbSeq;
+
+    /* FSE table descriptors */
     RETURN_ERROR_IF(ip+1 > iend, srcSize_wrong, ""); /* minimum possible size: 1 byte for symbol encoding types */
-    {   symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6); 
-        symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3); 
-        symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3); 
-        ip++; 
- 
-        /* Build DTables */ 
-        {   size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr, 
-                                                      LLtype, MaxLL, LLFSELog, 
-                                                      ip, iend-ip, 
-                                                      LL_base, LL_bits, 
-                                                      LL_defaultDTable, dctx->fseEntropy, 
+    {   symbolEncodingType_e const LLtype = (symbolEncodingType_e)(*ip >> 6);
+        symbolEncodingType_e const OFtype = (symbolEncodingType_e)((*ip >> 4) & 3);
+        symbolEncodingType_e const MLtype = (symbolEncodingType_e)((*ip >> 2) & 3);
+        ip++;
+
+        /* Build DTables */
+        {   size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr,
+                                                      LLtype, MaxLL, LLFSELog,
+                                                      ip, iend-ip,
+                                                      LL_base, LL_bits,
+                                                      LL_defaultDTable, dctx->fseEntropy,
                                                       dctx->ddictIsCold, nbSeq,
                                                       dctx->workspace, sizeof(dctx->workspace),
                                                       ZSTD_DCtx_get_bmi2(dctx));
             RETURN_ERROR_IF(ZSTD_isError(llhSize), corruption_detected, "ZSTD_buildSeqTable failed");
-            ip += llhSize; 
-        } 
- 
-        {   size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr, 
-                                                      OFtype, MaxOff, OffFSELog, 
-                                                      ip, iend-ip, 
-                                                      OF_base, OF_bits, 
-                                                      OF_defaultDTable, dctx->fseEntropy, 
+            ip += llhSize;
+        }
+
+        {   size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr,
+                                                      OFtype, MaxOff, OffFSELog,
+                                                      ip, iend-ip,
+                                                      OF_base, OF_bits,
+                                                      OF_defaultDTable, dctx->fseEntropy,
                                                       dctx->ddictIsCold, nbSeq,
                                                       dctx->workspace, sizeof(dctx->workspace),
                                                       ZSTD_DCtx_get_bmi2(dctx));
             RETURN_ERROR_IF(ZSTD_isError(ofhSize), corruption_detected, "ZSTD_buildSeqTable failed");
-            ip += ofhSize; 
-        } 
- 
-        {   size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr, 
-                                                      MLtype, MaxML, MLFSELog, 
-                                                      ip, iend-ip, 
-                                                      ML_base, ML_bits, 
-                                                      ML_defaultDTable, dctx->fseEntropy, 
+            ip += ofhSize;
+        }
+
+        {   size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr,
+                                                      MLtype, MaxML, MLFSELog,
+                                                      ip, iend-ip,
+                                                      ML_base, ML_bits,
+                                                      ML_defaultDTable, dctx->fseEntropy,
                                                       dctx->ddictIsCold, nbSeq,
                                                       dctx->workspace, sizeof(dctx->workspace),
                                                       ZSTD_DCtx_get_bmi2(dctx));
             RETURN_ERROR_IF(ZSTD_isError(mlhSize), corruption_detected, "ZSTD_buildSeqTable failed");
-            ip += mlhSize; 
-        } 
-    } 
- 
-    return ip-istart; 
-} 
- 
- 
-typedef struct { 
-    size_t litLength; 
-    size_t matchLength; 
-    size_t offset; 
-} seq_t; 
- 
-typedef struct { 
-    size_t state; 
-    const ZSTD_seqSymbol* table; 
-} ZSTD_fseState; 
- 
-typedef struct { 
-    BIT_DStream_t DStream; 
-    ZSTD_fseState stateLL; 
-    ZSTD_fseState stateOffb; 
-    ZSTD_fseState stateML; 
-    size_t prevOffset[ZSTD_REP_NUM]; 
-} seqState_t; 
- 
+            ip += mlhSize;
+        }
+    }
+
+    return ip-istart;
+}
+
+
+typedef struct {
+    size_t litLength;
+    size_t matchLength;
+    size_t offset;
+} seq_t;
+
+typedef struct {
+    size_t state;
+    const ZSTD_seqSymbol* table;
+} ZSTD_fseState;
+
+typedef struct {
+    BIT_DStream_t DStream;
+    ZSTD_fseState stateLL;
+    ZSTD_fseState stateOffb;
+    ZSTD_fseState stateML;
+    size_t prevOffset[ZSTD_REP_NUM];
+} seqState_t;
+
 /*! ZSTD_overlapCopy8() :
  *  Copies 8 bytes from ip to op and updates op and ip where ip <= op.
  *  If the offset is < 8 then the offset is spread to at least 8 bytes.
@@ -777,7 +777,7 @@ HINT_INLINE void ZSTD_overlapCopy8(BYTE** op, BYTE const** ip, size_t offset) {
     *op += 8;
     assert(*op - *ip >= 8);
 }
- 
+
 /*! ZSTD_safecopy() :
  *  Specialized version of memcpy() that is allowed to READ up to WILDCOPY_OVERLENGTH past the input buffer
  *  and write up to 16 bytes past oend_w (op >= oend_w is allowed).
@@ -857,40 +857,40 @@ static void ZSTD_safecopyDstBeforeSrc(BYTE* op, BYTE const* ip, ptrdiff_t length
  * NOTE: This function needs to be fast for a single long sequence, but doesn't need
  * to be optimized for many small sequences, since those fall into ZSTD_execSequence().
  */
-FORCE_NOINLINE 
+FORCE_NOINLINE
 size_t ZSTD_execSequenceEnd(BYTE* op,
     BYTE* const oend, seq_t sequence,
     const BYTE** litPtr, const BYTE* const litLimit,
     const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)
-{ 
-    BYTE* const oLitEnd = op + sequence.litLength; 
-    size_t const sequenceLength = sequence.litLength + sequence.matchLength; 
-    const BYTE* const iLitEnd = *litPtr + sequence.litLength; 
-    const BYTE* match = oLitEnd - sequence.offset; 
+{
+    BYTE* const oLitEnd = op + sequence.litLength;
+    size_t const sequenceLength = sequence.litLength + sequence.matchLength;
+    const BYTE* const iLitEnd = *litPtr + sequence.litLength;
+    const BYTE* match = oLitEnd - sequence.offset;
     BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH;
- 
+
     /* bounds checks : careful of address space overflow in 32-bit mode */
     RETURN_ERROR_IF(sequenceLength > (size_t)(oend - op), dstSize_tooSmall, "last match must fit within dstBuffer");
     RETURN_ERROR_IF(sequence.litLength > (size_t)(litLimit - *litPtr), corruption_detected, "try to read beyond literal buffer");
     assert(op < op + sequenceLength);
     assert(oLitEnd < op + sequenceLength);
- 
-    /* copy literals */ 
+
+    /* copy literals */
     ZSTD_safecopy(op, oend_w, *litPtr, sequence.litLength, ZSTD_no_overlap);
     op = oLitEnd;
     *litPtr = iLitEnd;
- 
-    /* copy Match */ 
+
+    /* copy Match */
     if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
-        /* offset beyond prefix */ 
+        /* offset beyond prefix */
         RETURN_ERROR_IF(sequence.offset > (size_t)(oLitEnd - virtualStart), corruption_detected, "");
         match = dictEnd - (prefixStart - match);
-        if (match + sequence.matchLength <= dictEnd) { 
+        if (match + sequence.matchLength <= dictEnd) {
             ZSTD_memmove(oLitEnd, match, sequence.matchLength);
-            return sequenceLength; 
-        } 
-        /* span extDict & currentPrefixSegment */ 
-        {   size_t const length1 = dictEnd - match; 
+            return sequenceLength;
+        }
+        /* span extDict & currentPrefixSegment */
+        {   size_t const length1 = dictEnd - match;
         ZSTD_memmove(oLitEnd, match, length1);
         op = oLitEnd + length1;
         sequence.matchLength -= length1;
@@ -898,9 +898,9 @@ size_t ZSTD_execSequenceEnd(BYTE* op,
         }
     }
     ZSTD_safecopy(op, oend_w, match, sequence.matchLength, ZSTD_overlap_src_before_dst);
-    return sequenceLength; 
-} 
- 
+    return sequenceLength;
+}
+
 /* ZSTD_execSequenceEndSplitLitBuffer():
  * This version is intended to be used during instances where the litBuffer is still split.  It is kept separate to avoid performance impact for the good case.
  */
@@ -949,19 +949,19 @@ size_t ZSTD_execSequenceEndSplitLitBuffer(BYTE* op,
     return sequenceLength;
 }
 
-HINT_INLINE 
-size_t ZSTD_execSequence(BYTE* op, 
+HINT_INLINE
+size_t ZSTD_execSequence(BYTE* op,
     BYTE* const oend, seq_t sequence,
     const BYTE** litPtr, const BYTE* const litLimit,
     const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)
-{ 
-    BYTE* const oLitEnd = op + sequence.litLength; 
-    size_t const sequenceLength = sequence.litLength + sequence.matchLength; 
-    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */ 
+{
+    BYTE* const oLitEnd = op + sequence.litLength;
+    size_t const sequenceLength = sequence.litLength + sequence.matchLength;
+    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */
     BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH;   /* risk : address space underflow on oend=NULL */
-    const BYTE* const iLitEnd = *litPtr + sequence.litLength; 
-    const BYTE* match = oLitEnd - sequence.offset; 
- 
+    const BYTE* const iLitEnd = *litPtr + sequence.litLength;
+    const BYTE* match = oLitEnd - sequence.offset;
+
     assert(op != NULL /* Precondition */);
     assert(oend_w < oend /* No underflow */);
     /* Handle edge cases in a slow path:
@@ -1066,7 +1066,7 @@ size_t ZSTD_execSequenceSplitLitBuffer(BYTE* op,
             oMatchEnd > oend_w ||
             (MEM_32bits() && (size_t)(oend - op) < sequenceLength + WILDCOPY_OVERLENGTH)))
         return ZSTD_execSequenceEndSplitLitBuffer(op, oend, oend_w, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);
- 
+
     /* Assumptions (everything else goes into ZSTD_execSequenceEnd()) */
     assert(op <= oLitEnd /* No overflow */);
     assert(oLitEnd < oMatchEnd /* Non-zero match & no overflow */);
@@ -1084,31 +1084,31 @@ size_t ZSTD_execSequenceSplitLitBuffer(BYTE* op,
     if (UNLIKELY(sequence.litLength > 16)) {
         ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap);
     }
-    op = oLitEnd; 
-    *litPtr = iLitEnd;   /* update for next sequence */ 
- 
+    op = oLitEnd;
+    *litPtr = iLitEnd;   /* update for next sequence */
+
     /* Copy Match */
-    if (sequence.offset > (size_t)(oLitEnd - prefixStart)) { 
-        /* offset beyond prefix -> go into extDict */ 
+    if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {
+        /* offset beyond prefix -> go into extDict */
         RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, "");
-        match = dictEnd + (match - prefixStart); 
-        if (match + sequence.matchLength <= dictEnd) { 
+        match = dictEnd + (match - prefixStart);
+        if (match + sequence.matchLength <= dictEnd) {
             ZSTD_memmove(oLitEnd, match, sequence.matchLength);
-            return sequenceLength; 
-        } 
-        /* span extDict & currentPrefixSegment */ 
-        {   size_t const length1 = dictEnd - match; 
+            return sequenceLength;
+        }
+        /* span extDict & currentPrefixSegment */
+        {   size_t const length1 = dictEnd - match;
             ZSTD_memmove(oLitEnd, match, length1);
-            op = oLitEnd + length1; 
-            sequence.matchLength -= length1; 
-            match = prefixStart; 
-    }   } 
+            op = oLitEnd + length1;
+            sequence.matchLength -= length1;
+            match = prefixStart;
+    }   }
     /* Match within prefix of 1 or more bytes */
     assert(op <= oMatchEnd);
     assert(oMatchEnd <= oend_w);
     assert(match >= prefixStart);
     assert(sequence.matchLength >= 1);
- 
+
     /* Nearly all offsets are >= WILDCOPY_VECLEN bytes, which means we can use wildcopy
      * without overlap checking.
      */
@@ -1119,56 +1119,56 @@ size_t ZSTD_execSequenceSplitLitBuffer(BYTE* op,
          */
         ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength, ZSTD_no_overlap);
         return sequenceLength;
-    } 
+    }
     assert(sequence.offset < WILDCOPY_VECLEN);
- 
+
     /* Copy 8 bytes and spread the offset to be >= 8. */
     ZSTD_overlapCopy8(&op, &match, sequence.offset);
- 
+
     /* If the match length is > 8 bytes, then continue with the wildcopy. */
     if (sequence.matchLength > 8) {
         assert(op < oMatchEnd);
         ZSTD_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8, ZSTD_overlap_src_before_dst);
-    } 
-    return sequenceLength; 
-} 
- 
-
-static void 
-ZSTD_initFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, const ZSTD_seqSymbol* dt) 
-{ 
-    const void* ptr = dt; 
-    const ZSTD_seqSymbol_header* const DTableH = (const ZSTD_seqSymbol_header*)ptr; 
-    DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog); 
-    DEBUGLOG(6, "ZSTD_initFseState : val=%u using %u bits", 
-                (U32)DStatePtr->state, DTableH->tableLog); 
-    BIT_reloadDStream(bitD); 
-    DStatePtr->table = dt + 1; 
-} 
- 
-FORCE_INLINE_TEMPLATE void 
+    }
+    return sequenceLength;
+}
+
+
+static void
+ZSTD_initFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, const ZSTD_seqSymbol* dt)
+{
+    const void* ptr = dt;
+    const ZSTD_seqSymbol_header* const DTableH = (const ZSTD_seqSymbol_header*)ptr;
+    DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
+    DEBUGLOG(6, "ZSTD_initFseState : val=%u using %u bits",
+                (U32)DStatePtr->state, DTableH->tableLog);
+    BIT_reloadDStream(bitD);
+    DStatePtr->table = dt + 1;
+}
+
+FORCE_INLINE_TEMPLATE void
 ZSTD_updateFseStateWithDInfo(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, U16 nextState, U32 nbBits)
-{ 
-    size_t const lowBits = BIT_readBits(bitD, nbBits); 
+{
+    size_t const lowBits = BIT_readBits(bitD, nbBits);
     DStatePtr->state = nextState + lowBits;
-} 
- 
-/* We need to add at most (ZSTD_WINDOWLOG_MAX_32 - 1) bits to read the maximum 
- * offset bits. But we can only read at most (STREAM_ACCUMULATOR_MIN_32 - 1) 
- * bits before reloading. This value is the maximum number of bytes we read 
- * after reloading when we are decoding long offsets. 
- */ 
-#define LONG_OFFSETS_MAX_EXTRA_BITS_32                       \ 
-    (ZSTD_WINDOWLOG_MAX_32 > STREAM_ACCUMULATOR_MIN_32       \ 
-        ? ZSTD_WINDOWLOG_MAX_32 - STREAM_ACCUMULATOR_MIN_32  \ 
-        : 0) 
- 
-typedef enum { ZSTD_lo_isRegularOffset, ZSTD_lo_isLongOffset=1 } ZSTD_longOffset_e; 
- 
-FORCE_INLINE_TEMPLATE seq_t 
+}
+
+/* We need to add at most (ZSTD_WINDOWLOG_MAX_32 - 1) bits to read the maximum
+ * offset bits. But we can only read at most (STREAM_ACCUMULATOR_MIN_32 - 1)
+ * bits before reloading. This value is the maximum number of bytes we read
+ * after reloading when we are decoding long offsets.
+ */
+#define LONG_OFFSETS_MAX_EXTRA_BITS_32                       \
+    (ZSTD_WINDOWLOG_MAX_32 > STREAM_ACCUMULATOR_MIN_32       \
+        ? ZSTD_WINDOWLOG_MAX_32 - STREAM_ACCUMULATOR_MIN_32  \
+        : 0)
+
+typedef enum { ZSTD_lo_isRegularOffset, ZSTD_lo_isLongOffset=1 } ZSTD_longOffset_e;
+
+FORCE_INLINE_TEMPLATE seq_t
 ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets)
-{ 
-    seq_t seq; 
+{
+    seq_t seq;
     const ZSTD_seqSymbol* const llDInfo = seqState->stateLL.table + seqState->stateLL.state;
     const ZSTD_seqSymbol* const mlDInfo = seqState->stateML.table + seqState->stateML.state;
     const ZSTD_seqSymbol* const ofDInfo = seqState->stateOffb.table + seqState->stateOffb.state;
@@ -1179,7 +1179,7 @@ ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets)
         BYTE const mlBits = mlDInfo->nbAdditionalBits;
         BYTE const ofBits = ofDInfo->nbAdditionalBits;
         BYTE const totalBits = llBits+mlBits+ofBits;
- 
+
         U16 const llNext = llDInfo->nextState;
         U16 const mlNext = mlDInfo->nextState;
         U16 const ofNext = ofDInfo->nextState;
@@ -1215,7 +1215,7 @@ ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets)
                 seqState->prevOffset[2] = seqState->prevOffset[1];
                 seqState->prevOffset[1] = seqState->prevOffset[0];
                 seqState->prevOffset[0] = offset;
-            } else { 
+            } else {
                 U32 const ll0 = (llDInfo->baseValue == 0);
                 if (LIKELY((ofBits == 0))) {
                     offset = seqState->prevOffset[ll0];
@@ -1231,7 +1231,7 @@ ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets)
             }   }   }
             seq.offset = offset;
         }
- 
+
     #if defined(__clang__)
         if (UNLIKELY(mlBits > 0))
     #else
@@ -1245,7 +1245,7 @@ ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets)
             BIT_reloadDStream(&seqState->DStream);
         /* Ensure there are enough bits to read the rest of data in 64-bit mode. */
         ZSTD_STATIC_ASSERT(16+LLFSELog+MLFSELog+OffFSELog < STREAM_ACCUMULATOR_MIN_64);
- 
+
     #if defined(__clang__)
         if (UNLIKELY(llBits > 0))
     #else
@@ -1255,19 +1255,19 @@ ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets)
 
         if (MEM_32bits())
             BIT_reloadDStream(&seqState->DStream);
- 
+
         DEBUGLOG(6, "seq: litL=%u, matchL=%u, offset=%u",
                     (U32)seq.litLength, (U32)seq.matchLength, (U32)seq.offset);
- 
+
         ZSTD_updateFseStateWithDInfo(&seqState->stateLL, &seqState->DStream, llNext, llnbBits);    /* <=  9 bits */
         ZSTD_updateFseStateWithDInfo(&seqState->stateML, &seqState->DStream, mlNext, mlnbBits);    /* <=  9 bits */
         if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);    /* <= 18 bits */
         ZSTD_updateFseStateWithDInfo(&seqState->stateOffb, &seqState->DStream, ofNext, ofnbBits);  /* <=  8 bits */
     }
 
-    return seq; 
-} 
- 
+    return seq;
+}
+
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
 MEM_STATIC int ZSTD_dictionaryIsActive(ZSTD_DCtx const* dctx, BYTE const* prefixStart, BYTE const* oLitEnd)
 {
@@ -1317,40 +1317,40 @@ MEM_STATIC void ZSTD_assertValidSequence(
 #ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
 
 
-FORCE_INLINE_TEMPLATE size_t 
+FORCE_INLINE_TEMPLATE size_t
 DONT_VECTORIZE
 ZSTD_decompressSequences_bodySplitLitBuffer( ZSTD_DCtx* dctx,
-                               void* dst, size_t maxDstSize, 
-                         const void* seqStart, size_t seqSize, int nbSeq, 
+                               void* dst, size_t maxDstSize,
+                         const void* seqStart, size_t seqSize, int nbSeq,
                          const ZSTD_longOffset_e isLongOffset,
                          const int frame)
-{ 
-    const BYTE* ip = (const BYTE*)seqStart; 
-    const BYTE* const iend = ip + seqSize; 
+{
+    const BYTE* ip = (const BYTE*)seqStart;
+    const BYTE* const iend = ip + seqSize;
     BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + maxDstSize; 
-    BYTE* op = ostart; 
-    const BYTE* litPtr = dctx->litPtr; 
+    BYTE* const oend = ostart + maxDstSize;
+    BYTE* op = ostart;
+    const BYTE* litPtr = dctx->litPtr;
     const BYTE* litBufferEnd = dctx->litBufferEnd;
-    const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart); 
-    const BYTE* const vBase = (const BYTE*) (dctx->virtualStart); 
-    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd); 
+    const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart);
+    const BYTE* const vBase = (const BYTE*) (dctx->virtualStart);
+    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
     DEBUGLOG(5, "ZSTD_decompressSequences_bodySplitLitBuffer");
     (void)frame;
- 
-    /* Regen sequences */ 
-    if (nbSeq) { 
-        seqState_t seqState; 
-        dctx->fseEntropy = 1; 
-        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; } 
-        RETURN_ERROR_IF( 
-            ERR_isError(BIT_initDStream(&seqState.DStream, ip, iend-ip)), 
+
+    /* Regen sequences */
+    if (nbSeq) {
+        seqState_t seqState;
+        dctx->fseEntropy = 1;
+        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
+        RETURN_ERROR_IF(
+            ERR_isError(BIT_initDStream(&seqState.DStream, ip, iend-ip)),
             corruption_detected, "");
-        ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr); 
-        ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr); 
-        ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr); 
+        ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
+        ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
+        ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
         assert(dst != NULL);
- 
+
         ZSTD_STATIC_ASSERT(
                 BIT_DStream_unfinished < BIT_DStream_completed &&
                 BIT_DStream_endOfBuffer < BIT_DStream_completed &&
@@ -1602,36 +1602,36 @@ ZSTD_decompressSequences_body(ZSTD_DCtx* dctx,
                 break;
             BIT_reloadDStream(&(seqState.DStream));
         }
- 
-        /* check if reached exact end */ 
-        DEBUGLOG(5, "ZSTD_decompressSequences_body: after decode loop, remaining nbSeq : %i", nbSeq); 
+
+        /* check if reached exact end */
+        DEBUGLOG(5, "ZSTD_decompressSequences_body: after decode loop, remaining nbSeq : %i", nbSeq);
         RETURN_ERROR_IF(nbSeq, corruption_detected, "");
         RETURN_ERROR_IF(BIT_reloadDStream(&seqState.DStream) < BIT_DStream_completed, corruption_detected, "");
-        /* save reps for next block */ 
-        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); } 
-    } 
- 
-    /* last literal segment */ 
-    {   size_t const lastLLSize = litEnd - litPtr; 
+        /* save reps for next block */
+        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
+    }
+
+    /* last literal segment */
+    {   size_t const lastLLSize = litEnd - litPtr;
         RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, "");
         if (op != NULL) {
             ZSTD_memcpy(op, litPtr, lastLLSize);
             op += lastLLSize;
         }
-    } 
- 
-    return op-ostart; 
-} 
- 
-static size_t 
-ZSTD_decompressSequences_default(ZSTD_DCtx* dctx, 
-                                 void* dst, size_t maxDstSize, 
-                           const void* seqStart, size_t seqSize, int nbSeq, 
+    }
+
+    return op-ostart;
+}
+
+static size_t
+ZSTD_decompressSequences_default(ZSTD_DCtx* dctx,
+                                 void* dst, size_t maxDstSize,
+                           const void* seqStart, size_t seqSize, int nbSeq,
                            const ZSTD_longOffset_e isLongOffset,
                            const int frame)
-{ 
+{
     return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
-} 
+}
 
 static size_t
 ZSTD_decompressSequencesSplitLitBuffer_default(ZSTD_DCtx* dctx,
@@ -1642,11 +1642,11 @@ ZSTD_decompressSequencesSplitLitBuffer_default(ZSTD_DCtx* dctx,
 {
     return ZSTD_decompressSequences_bodySplitLitBuffer(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
 }
-#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */ 
- 
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT 
+#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */
+
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
 
-FORCE_INLINE_TEMPLATE size_t 
+FORCE_INLINE_TEMPLATE size_t
 ZSTD_prefetchMatch(size_t prefetchPos, seq_t const sequence,
                    const BYTE* const prefixStart, const BYTE* const dictEnd)
 {
@@ -1664,55 +1664,55 @@ ZSTD_prefetchMatch(size_t prefetchPos, seq_t const sequence,
  * It's generally employed when block contains a significant portion of long-distance matches
  * or when coupled with a "cold" dictionary */
 FORCE_INLINE_TEMPLATE size_t
-ZSTD_decompressSequencesLong_body( 
-                               ZSTD_DCtx* dctx, 
-                               void* dst, size_t maxDstSize, 
-                         const void* seqStart, size_t seqSize, int nbSeq, 
+ZSTD_decompressSequencesLong_body(
+                               ZSTD_DCtx* dctx,
+                               void* dst, size_t maxDstSize,
+                         const void* seqStart, size_t seqSize, int nbSeq,
                          const ZSTD_longOffset_e isLongOffset,
                          const int frame)
-{ 
-    const BYTE* ip = (const BYTE*)seqStart; 
-    const BYTE* const iend = ip + seqSize; 
+{
+    const BYTE* ip = (const BYTE*)seqStart;
+    const BYTE* const iend = ip + seqSize;
     BYTE* const ostart = (BYTE*)dst;
     BYTE* const oend = dctx->litBufferLocation == ZSTD_in_dst ? dctx->litBuffer : ostart + maxDstSize;
-    BYTE* op = ostart; 
-    const BYTE* litPtr = dctx->litPtr; 
+    BYTE* op = ostart;
+    const BYTE* litPtr = dctx->litPtr;
     const BYTE* litBufferEnd = dctx->litBufferEnd;
-    const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart); 
-    const BYTE* const dictStart = (const BYTE*) (dctx->virtualStart); 
-    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd); 
+    const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart);
+    const BYTE* const dictStart = (const BYTE*) (dctx->virtualStart);
+    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
     (void)frame;
- 
-    /* Regen sequences */ 
-    if (nbSeq) { 
+
+    /* Regen sequences */
+    if (nbSeq) {
 #define STORED_SEQS 8
-#define STORED_SEQS_MASK (STORED_SEQS-1) 
+#define STORED_SEQS_MASK (STORED_SEQS-1)
 #define ADVANCED_SEQS STORED_SEQS
-        seq_t sequences[STORED_SEQS]; 
-        int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS); 
-        seqState_t seqState; 
-        int seqNb; 
+        seq_t sequences[STORED_SEQS];
+        int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS);
+        seqState_t seqState;
+        int seqNb;
         size_t prefetchPos = (size_t)(op-prefixStart); /* track position relative to prefixStart */
 
-        dctx->fseEntropy = 1; 
-        { int i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; } 
+        dctx->fseEntropy = 1;
+        { int i; for (i=0; i<ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }
         assert(dst != NULL);
-        assert(iend >= ip); 
-        RETURN_ERROR_IF( 
-            ERR_isError(BIT_initDStream(&seqState.DStream, ip, iend-ip)), 
+        assert(iend >= ip);
+        RETURN_ERROR_IF(
+            ERR_isError(BIT_initDStream(&seqState.DStream, ip, iend-ip)),
             corruption_detected, "");
-        ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr); 
-        ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr); 
-        ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr); 
- 
-        /* prepare in advance */ 
-        for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) { 
+        ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
+        ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
+        ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
+
+        /* prepare in advance */
+        for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) {
             seq_t const sequence = ZSTD_decodeSequence(&seqState, isLongOffset);
             prefetchPos = ZSTD_prefetchMatch(prefetchPos, sequence, prefixStart, dictEnd);
             sequences[seqNb] = sequence;
-        } 
+        }
         RETURN_ERROR_IF(seqNb<seqAdvance, corruption_detected, "");
- 
+
         /* decompress without stomping litBuffer */
         for (; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb < nbSeq); seqNb++) {
             seq_t sequence = ZSTD_decodeSequence(&seqState, isLongOffset);
@@ -1759,12 +1759,12 @@ ZSTD_decompressSequencesLong_body(
                 sequences[seqNb & STORED_SEQS_MASK] = sequence;
                 op += oneSeqSize;
             }
-        } 
+        }
         RETURN_ERROR_IF(seqNb<nbSeq, corruption_detected, "");
- 
-        /* finish queue */ 
-        seqNb -= seqAdvance; 
-        for ( ; seqNb<nbSeq ; seqNb++) { 
+
+        /* finish queue */
+        seqNb -= seqAdvance;
+        for ( ; seqNb<nbSeq ; seqNb++) {
             seq_t *sequence = &(sequences[seqNb&STORED_SEQS_MASK]);
             if (dctx->litBufferLocation == ZSTD_split && litPtr + sequence->litLength > dctx->litBufferEnd)
             {
@@ -1801,13 +1801,13 @@ ZSTD_decompressSequencesLong_body(
                 if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
                 op += oneSeqSize;
             }
-        } 
- 
-        /* save reps for next block */ 
-        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); } 
-    } 
- 
-    /* last literal segment */ 
+        }
+
+        /* save reps for next block */
+        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) dctx->entropy.rep[i] = (U32)(seqState.prevOffset[i]); }
+    }
+
+    /* last literal segment */
     if (dctx->litBufferLocation == ZSTD_split)  /* first deplete literal buffer in dst, then copy litExtraBuffer */
     {
         size_t const lastLLSize = litBufferEnd - litPtr;
@@ -1825,37 +1825,37 @@ ZSTD_decompressSequencesLong_body(
             ZSTD_memmove(op, litPtr, lastLLSize);
             op += lastLLSize;
         }
-    } 
- 
-    return op-ostart; 
-} 
- 
-static size_t 
-ZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx, 
-                                 void* dst, size_t maxDstSize, 
-                           const void* seqStart, size_t seqSize, int nbSeq, 
+    }
+
+    return op-ostart;
+}
+
+static size_t
+ZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx,
+                                 void* dst, size_t maxDstSize,
+                           const void* seqStart, size_t seqSize, int nbSeq,
                            const ZSTD_longOffset_e isLongOffset,
                            const int frame)
-{ 
+{
     return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
-} 
-#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */ 
- 
- 
- 
-#if DYNAMIC_BMI2 
- 
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG 
+}
+#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */
+
+
+
+#if DYNAMIC_BMI2
+
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
 static BMI2_TARGET_ATTRIBUTE size_t
 DONT_VECTORIZE
-ZSTD_decompressSequences_bmi2(ZSTD_DCtx* dctx, 
-                                 void* dst, size_t maxDstSize, 
-                           const void* seqStart, size_t seqSize, int nbSeq, 
+ZSTD_decompressSequences_bmi2(ZSTD_DCtx* dctx,
+                                 void* dst, size_t maxDstSize,
+                           const void* seqStart, size_t seqSize, int nbSeq,
                            const ZSTD_longOffset_e isLongOffset,
                            const int frame)
-{ 
+{
     return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
-} 
+}
 static BMI2_TARGET_ATTRIBUTE size_t
 DONT_VECTORIZE
 ZSTD_decompressSequencesSplitLitBuffer_bmi2(ZSTD_DCtx* dctx,
@@ -1866,44 +1866,44 @@ ZSTD_decompressSequencesSplitLitBuffer_bmi2(ZSTD_DCtx* dctx,
 {
     return ZSTD_decompressSequences_bodySplitLitBuffer(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
 }
-#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */ 
- 
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT 
+#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */
+
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
 static BMI2_TARGET_ATTRIBUTE size_t
-ZSTD_decompressSequencesLong_bmi2(ZSTD_DCtx* dctx, 
-                                 void* dst, size_t maxDstSize, 
-                           const void* seqStart, size_t seqSize, int nbSeq, 
+ZSTD_decompressSequencesLong_bmi2(ZSTD_DCtx* dctx,
+                                 void* dst, size_t maxDstSize,
+                           const void* seqStart, size_t seqSize, int nbSeq,
                            const ZSTD_longOffset_e isLongOffset,
                            const int frame)
-{ 
+{
     return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
-} 
-#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */ 
- 
-#endif /* DYNAMIC_BMI2 */ 
- 
-typedef size_t (*ZSTD_decompressSequences_t)( 
-                            ZSTD_DCtx* dctx, 
-                            void* dst, size_t maxDstSize, 
-                            const void* seqStart, size_t seqSize, int nbSeq, 
+}
+#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */
+
+#endif /* DYNAMIC_BMI2 */
+
+typedef size_t (*ZSTD_decompressSequences_t)(
+                            ZSTD_DCtx* dctx,
+                            void* dst, size_t maxDstSize,
+                            const void* seqStart, size_t seqSize, int nbSeq,
                             const ZSTD_longOffset_e isLongOffset,
                             const int frame);
- 
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG 
-static size_t 
-ZSTD_decompressSequences(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, 
-                   const void* seqStart, size_t seqSize, int nbSeq, 
+
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
+static size_t
+ZSTD_decompressSequences(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize,
+                   const void* seqStart, size_t seqSize, int nbSeq,
                    const ZSTD_longOffset_e isLongOffset,
                    const int frame)
-{ 
-    DEBUGLOG(5, "ZSTD_decompressSequences"); 
-#if DYNAMIC_BMI2 
+{
+    DEBUGLOG(5, "ZSTD_decompressSequences");
+#if DYNAMIC_BMI2
     if (ZSTD_DCtx_get_bmi2(dctx)) {
         return ZSTD_decompressSequences_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
-    } 
-#endif 
+    }
+#endif
     return ZSTD_decompressSequences_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
-} 
+}
 static size_t
 ZSTD_decompressSequencesSplitLitBuffer(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize,
                                  const void* seqStart, size_t seqSize, int nbSeq,
@@ -1918,137 +1918,137 @@ ZSTD_decompressSequencesSplitLitBuffer(ZSTD_DCtx* dctx, void* dst, size_t maxDst
 #endif
     return ZSTD_decompressSequencesSplitLitBuffer_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
 }
-#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */ 
- 
- 
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT 
-/* ZSTD_decompressSequencesLong() : 
- * decompression function triggered when a minimum share of offsets is considered "long", 
- * aka out of cache. 
- * note : "long" definition seems overloaded here, sometimes meaning "wider than bitstream register", and sometimes meaning "farther than memory cache distance". 
- * This function will try to mitigate main memory latency through the use of prefetching */ 
-static size_t 
-ZSTD_decompressSequencesLong(ZSTD_DCtx* dctx, 
-                             void* dst, size_t maxDstSize, 
-                             const void* seqStart, size_t seqSize, int nbSeq, 
+#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */
+
+
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
+/* ZSTD_decompressSequencesLong() :
+ * decompression function triggered when a minimum share of offsets is considered "long",
+ * aka out of cache.
+ * note : "long" definition seems overloaded here, sometimes meaning "wider than bitstream register", and sometimes meaning "farther than memory cache distance".
+ * This function will try to mitigate main memory latency through the use of prefetching */
+static size_t
+ZSTD_decompressSequencesLong(ZSTD_DCtx* dctx,
+                             void* dst, size_t maxDstSize,
+                             const void* seqStart, size_t seqSize, int nbSeq,
                              const ZSTD_longOffset_e isLongOffset,
                              const int frame)
-{ 
-    DEBUGLOG(5, "ZSTD_decompressSequencesLong"); 
-#if DYNAMIC_BMI2 
+{
+    DEBUGLOG(5, "ZSTD_decompressSequencesLong");
+#if DYNAMIC_BMI2
     if (ZSTD_DCtx_get_bmi2(dctx)) {
         return ZSTD_decompressSequencesLong_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
-    } 
-#endif 
+    }
+#endif
   return ZSTD_decompressSequencesLong_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset, frame);
-} 
-#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */ 
- 
- 
- 
-#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \ 
-    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG) 
-/* ZSTD_getLongOffsetsShare() : 
- * condition : offTable must be valid 
- * @return : "share" of long offsets (arbitrarily defined as > (1<<23)) 
- *           compared to maximum possible of (1<<OffFSELog) */ 
-static unsigned 
-ZSTD_getLongOffsetsShare(const ZSTD_seqSymbol* offTable) 
-{ 
-    const void* ptr = offTable; 
-    U32 const tableLog = ((const ZSTD_seqSymbol_header*)ptr)[0].tableLog; 
-    const ZSTD_seqSymbol* table = offTable + 1; 
-    U32 const max = 1 << tableLog; 
-    U32 u, total = 0; 
-    DEBUGLOG(5, "ZSTD_getLongOffsetsShare: (tableLog=%u)", tableLog); 
- 
-    assert(max <= (1 << OffFSELog));  /* max not too large */ 
-    for (u=0; u<max; u++) { 
-        if (table[u].nbAdditionalBits > 22) total += 1; 
-    } 
- 
-    assert(tableLog <= OffFSELog); 
-    total <<= (OffFSELog - tableLog);  /* scale to OffFSELog */ 
- 
-    return total; 
-} 
-#endif 
- 
-size_t 
-ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx, 
-                              void* dst, size_t dstCapacity, 
+}
+#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */
+
+
+
+#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
+    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
+/* ZSTD_getLongOffsetsShare() :
+ * condition : offTable must be valid
+ * @return : "share" of long offsets (arbitrarily defined as > (1<<23))
+ *           compared to maximum possible of (1<<OffFSELog) */
+static unsigned
+ZSTD_getLongOffsetsShare(const ZSTD_seqSymbol* offTable)
+{
+    const void* ptr = offTable;
+    U32 const tableLog = ((const ZSTD_seqSymbol_header*)ptr)[0].tableLog;
+    const ZSTD_seqSymbol* table = offTable + 1;
+    U32 const max = 1 << tableLog;
+    U32 u, total = 0;
+    DEBUGLOG(5, "ZSTD_getLongOffsetsShare: (tableLog=%u)", tableLog);
+
+    assert(max <= (1 << OffFSELog));  /* max not too large */
+    for (u=0; u<max; u++) {
+        if (table[u].nbAdditionalBits > 22) total += 1;
+    }
+
+    assert(tableLog <= OffFSELog);
+    total <<= (OffFSELog - tableLog);  /* scale to OffFSELog */
+
+    return total;
+}
+#endif
+
+size_t
+ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
+                              void* dst, size_t dstCapacity,
                         const void* src, size_t srcSize, const int frame, const streaming_operation streaming)
-{   /* blockType == blockCompressed */ 
-    const BYTE* ip = (const BYTE*)src; 
-    /* isLongOffset must be true if there are long offsets. 
-     * Offsets are long if they are larger than 2^STREAM_ACCUMULATOR_MIN. 
-     * We don't expect that to be the case in 64-bit mode. 
-     * In block mode, window size is not known, so we have to be conservative. 
-     * (note: but it could be evaluated from current-lowLimit) 
-     */ 
-    ZSTD_longOffset_e const isLongOffset = (ZSTD_longOffset_e)(MEM_32bits() && (!frame || (dctx->fParams.windowSize > (1ULL << STREAM_ACCUMULATOR_MIN)))); 
-    DEBUGLOG(5, "ZSTD_decompressBlock_internal (size : %u)", (U32)srcSize); 
- 
+{   /* blockType == blockCompressed */
+    const BYTE* ip = (const BYTE*)src;
+    /* isLongOffset must be true if there are long offsets.
+     * Offsets are long if they are larger than 2^STREAM_ACCUMULATOR_MIN.
+     * We don't expect that to be the case in 64-bit mode.
+     * In block mode, window size is not known, so we have to be conservative.
+     * (note: but it could be evaluated from current-lowLimit)
+     */
+    ZSTD_longOffset_e const isLongOffset = (ZSTD_longOffset_e)(MEM_32bits() && (!frame || (dctx->fParams.windowSize > (1ULL << STREAM_ACCUMULATOR_MIN))));
+    DEBUGLOG(5, "ZSTD_decompressBlock_internal (size : %u)", (U32)srcSize);
+
     RETURN_ERROR_IF(srcSize >= ZSTD_BLOCKSIZE_MAX, srcSize_wrong, "");
- 
-    /* Decode literals section */ 
+
+    /* Decode literals section */
     {   size_t const litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize, dst, dstCapacity, streaming);
-        DEBUGLOG(5, "ZSTD_decodeLiteralsBlock : %u", (U32)litCSize); 
-        if (ZSTD_isError(litCSize)) return litCSize; 
-        ip += litCSize; 
-        srcSize -= litCSize; 
-    } 
- 
-    /* Build Decoding Tables */ 
-    { 
-        /* These macros control at build-time which decompressor implementation 
-         * we use. If neither is defined, we do some inspection and dispatch at 
-         * runtime. 
-         */ 
-#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \ 
-    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG) 
-        int usePrefetchDecoder = dctx->ddictIsCold; 
-#endif 
-        int nbSeq; 
-        size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, srcSize); 
-        if (ZSTD_isError(seqHSize)) return seqHSize; 
-        ip += seqHSize; 
-        srcSize -= seqHSize; 
- 
+        DEBUGLOG(5, "ZSTD_decodeLiteralsBlock : %u", (U32)litCSize);
+        if (ZSTD_isError(litCSize)) return litCSize;
+        ip += litCSize;
+        srcSize -= litCSize;
+    }
+
+    /* Build Decoding Tables */
+    {
+        /* These macros control at build-time which decompressor implementation
+         * we use. If neither is defined, we do some inspection and dispatch at
+         * runtime.
+         */
+#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
+    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
+        int usePrefetchDecoder = dctx->ddictIsCold;
+#endif
+        int nbSeq;
+        size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, srcSize);
+        if (ZSTD_isError(seqHSize)) return seqHSize;
+        ip += seqHSize;
+        srcSize -= seqHSize;
+
         RETURN_ERROR_IF(dst == NULL && nbSeq > 0, dstSize_tooSmall, "NULL not handled");
 
-#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \ 
-    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG) 
-        if ( !usePrefetchDecoder 
-          && (!frame || (dctx->fParams.windowSize > (1<<24))) 
-          && (nbSeq>ADVANCED_SEQS) ) {  /* could probably use a larger nbSeq limit */ 
-            U32 const shareLongOffsets = ZSTD_getLongOffsetsShare(dctx->OFTptr); 
-            U32 const minShare = MEM_64bits() ? 7 : 20; /* heuristic values, correspond to 2.73% and 7.81% */ 
-            usePrefetchDecoder = (shareLongOffsets >= minShare); 
-        } 
-#endif 
- 
-        dctx->ddictIsCold = 0; 
- 
-#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \ 
-    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG) 
-        if (usePrefetchDecoder) 
-#endif 
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT 
+#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
+    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
+        if ( !usePrefetchDecoder
+          && (!frame || (dctx->fParams.windowSize > (1<<24)))
+          && (nbSeq>ADVANCED_SEQS) ) {  /* could probably use a larger nbSeq limit */
+            U32 const shareLongOffsets = ZSTD_getLongOffsetsShare(dctx->OFTptr);
+            U32 const minShare = MEM_64bits() ? 7 : 20; /* heuristic values, correspond to 2.73% and 7.81% */
+            usePrefetchDecoder = (shareLongOffsets >= minShare);
+        }
+#endif
+
+        dctx->ddictIsCold = 0;
+
+#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
+    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
+        if (usePrefetchDecoder)
+#endif
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
             return ZSTD_decompressSequencesLong(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset, frame);
-#endif 
- 
-#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG 
-        /* else */ 
+#endif
+
+#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
+        /* else */
         if (dctx->litBufferLocation == ZSTD_split)
             return ZSTD_decompressSequencesSplitLitBuffer(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset, frame);
         else
             return ZSTD_decompressSequences(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset, frame);
-#endif 
-    } 
-} 
- 
- 
+#endif
+    }
+}
+
+
 void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize)
 {
     if (dst != dctx->previousDstEnd && dstSize > 0) {   /* not contiguous */
@@ -2060,13 +2060,13 @@ void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize)
 }
 
 
-size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, 
-                            void* dst, size_t dstCapacity, 
-                      const void* src, size_t srcSize) 
-{ 
-    size_t dSize; 
+size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,
+                            void* dst, size_t dstCapacity,
+                      const void* src, size_t srcSize)
+{
+    size_t dSize;
     ZSTD_checkContinuity(dctx, dst, dstCapacity);
     dSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 0, not_streaming);
-    dctx->previousDstEnd = (char*)dst + dSize; 
-    return dSize; 
-} 
+    dctx->previousDstEnd = (char*)dst + dSize;
+    return dSize;
+}
diff --git a/contrib/libs/zstd/lib/decompress/zstd_decompress_block.h b/contrib/libs/zstd/lib/decompress/zstd_decompress_block.h
index a4936c6533..c61a9d0c4b 100644
--- a/contrib/libs/zstd/lib/decompress/zstd_decompress_block.h
+++ b/contrib/libs/zstd/lib/decompress/zstd_decompress_block.h
@@ -1,68 +1,68 @@
-/* 
+/*
  * Copyright (c) Yann Collet, Facebook, Inc.
- * All rights reserved. 
- * 
- * This source code is licensed under both the BSD-style license (found in the 
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found 
- * in the COPYING file in the root directory of this source tree). 
- * You may select, at your option, one of the above-listed licenses. 
- */ 
- 
- 
-#ifndef ZSTD_DEC_BLOCK_H 
-#define ZSTD_DEC_BLOCK_H 
- 
-/*-******************************************************* 
- *  Dependencies 
- *********************************************************/ 
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+#ifndef ZSTD_DEC_BLOCK_H
+#define ZSTD_DEC_BLOCK_H
+
+/*-*******************************************************
+ *  Dependencies
+ *********************************************************/
 #include "../common/zstd_deps.h"   /* size_t */
 #include "../zstd.h"    /* DCtx, and some public functions */
 #include "../common/zstd_internal.h"  /* blockProperties_t, and some public functions */
-#include "zstd_decompress_internal.h"  /* ZSTD_seqSymbol */ 
- 
- 
-/* ===   Prototypes   === */ 
- 
-/* note: prototypes already published within `zstd.h` : 
- * ZSTD_decompressBlock() 
- */ 
- 
-/* note: prototypes already published within `zstd_internal.h` : 
- * ZSTD_getcBlockSize() 
- * ZSTD_decodeSeqHeaders() 
- */ 
- 
- 
+#include "zstd_decompress_internal.h"  /* ZSTD_seqSymbol */
+
+
+/* ===   Prototypes   === */
+
+/* note: prototypes already published within `zstd.h` :
+ * ZSTD_decompressBlock()
+ */
+
+/* note: prototypes already published within `zstd_internal.h` :
+ * ZSTD_getcBlockSize()
+ * ZSTD_decodeSeqHeaders()
+ */
+
+
  /* Streaming state is used to inform allocation of the literal buffer */
 typedef enum {
     not_streaming = 0,
     is_streaming = 1
 } streaming_operation;
 
-/* ZSTD_decompressBlock_internal() : 
- * decompress block, starting at `src`, 
- * into destination buffer `dst`. 
- * @return : decompressed block size, 
- *           or an error code (which can be tested using ZSTD_isError()) 
- */ 
-size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx, 
-                               void* dst, size_t dstCapacity, 
+/* ZSTD_decompressBlock_internal() :
+ * decompress block, starting at `src`,
+ * into destination buffer `dst`.
+ * @return : decompressed block size,
+ *           or an error code (which can be tested using ZSTD_isError())
+ */
+size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
+                               void* dst, size_t dstCapacity,
                          const void* src, size_t srcSize, const int frame, const streaming_operation streaming);
- 
-/* ZSTD_buildFSETable() : 
- * generate FSE decoding table for one symbol (ll, ml or off) 
- * this function must be called with valid parameters only 
- * (dt is large enough, normalizedCounter distribution total is a power of 2, max is within range, etc.) 
- * in which case it cannot fail. 
+
+/* ZSTD_buildFSETable() :
+ * generate FSE decoding table for one symbol (ll, ml or off)
+ * this function must be called with valid parameters only
+ * (dt is large enough, normalizedCounter distribution total is a power of 2, max is within range, etc.)
+ * in which case it cannot fail.
  * The workspace must be 4-byte aligned and at least ZSTD_BUILD_FSE_TABLE_WKSP_SIZE bytes, which is
  * defined in zstd_decompress_internal.h.
- * Internal use only. 
- */ 
-void ZSTD_buildFSETable(ZSTD_seqSymbol* dt, 
-             const short* normalizedCounter, unsigned maxSymbolValue, 
+ * Internal use only.
+ */
+void ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
+             const short* normalizedCounter, unsigned maxSymbolValue,
              const U32* baseValue, const U8* nbAdditionalBits,
                    unsigned tableLog, void* wksp, size_t wkspSize,
                    int bmi2);
- 
- 
-#endif /* ZSTD_DEC_BLOCK_H */ 
+
+
+#endif /* ZSTD_DEC_BLOCK_H */
diff --git a/contrib/libs/zstd/lib/decompress/zstd_decompress_internal.h b/contrib/libs/zstd/lib/decompress/zstd_decompress_internal.h
index 0f4d363cb2..2b5a53850a 100644
--- a/contrib/libs/zstd/lib/decompress/zstd_decompress_internal.h
+++ b/contrib/libs/zstd/lib/decompress/zstd_decompress_internal.h
@@ -1,104 +1,104 @@
-/* 
+/*
  * Copyright (c) Yann Collet, Facebook, Inc.
- * All rights reserved. 
- * 
- * This source code is licensed under both the BSD-style license (found in the 
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found 
- * in the COPYING file in the root directory of this source tree). 
- * You may select, at your option, one of the above-listed licenses. 
- */ 
- 
- 
-/* zstd_decompress_internal: 
- * objects and definitions shared within lib/decompress modules */ 
- 
- #ifndef ZSTD_DECOMPRESS_INTERNAL_H 
- #define ZSTD_DECOMPRESS_INTERNAL_H 
- 
- 
-/*-******************************************************* 
- *  Dependencies 
- *********************************************************/ 
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+
+/* zstd_decompress_internal:
+ * objects and definitions shared within lib/decompress modules */
+
+ #ifndef ZSTD_DECOMPRESS_INTERNAL_H
+ #define ZSTD_DECOMPRESS_INTERNAL_H
+
+
+/*-*******************************************************
+ *  Dependencies
+ *********************************************************/
 #include "../common/mem.h"             /* BYTE, U16, U32 */
 #include "../common/zstd_internal.h"   /* constants : MaxLL, MaxML, MaxOff, LLFSELog, etc. */
- 
- 
- 
-/*-******************************************************* 
- *  Constants 
- *********************************************************/ 
+
+
+
+/*-*******************************************************
+ *  Constants
+ *********************************************************/
 static UNUSED_ATTR const U32 LL_base[MaxLL+1] = {
-                 0,    1,    2,     3,     4,     5,     6,      7, 
-                 8,    9,   10,    11,    12,    13,    14,     15, 
-                16,   18,   20,    22,    24,    28,    32,     40, 
-                48,   64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 
-                0x2000, 0x4000, 0x8000, 0x10000 }; 
- 
+                 0,    1,    2,     3,     4,     5,     6,      7,
+                 8,    9,   10,    11,    12,    13,    14,     15,
+                16,   18,   20,    22,    24,    28,    32,     40,
+                48,   64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000,
+                0x2000, 0x4000, 0x8000, 0x10000 };
+
 static UNUSED_ATTR const U32 OF_base[MaxOff+1] = {
-                 0,        1,       1,       5,     0xD,     0x1D,     0x3D,     0x7D, 
-                 0xFD,   0x1FD,   0x3FD,   0x7FD,   0xFFD,   0x1FFD,   0x3FFD,   0x7FFD, 
-                 0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD, 
-                 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD, 0x1FFFFFFD, 0x3FFFFFFD, 0x7FFFFFFD }; 
- 
+                 0,        1,       1,       5,     0xD,     0x1D,     0x3D,     0x7D,
+                 0xFD,   0x1FD,   0x3FD,   0x7FD,   0xFFD,   0x1FFD,   0x3FFD,   0x7FFD,
+                 0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD,
+                 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD, 0x1FFFFFFD, 0x3FFFFFFD, 0x7FFFFFFD };
+
 static UNUSED_ATTR const U8 OF_bits[MaxOff+1] = {
-                     0,  1,  2,  3,  4,  5,  6,  7, 
-                     8,  9, 10, 11, 12, 13, 14, 15, 
-                    16, 17, 18, 19, 20, 21, 22, 23, 
-                    24, 25, 26, 27, 28, 29, 30, 31 }; 
- 
+                     0,  1,  2,  3,  4,  5,  6,  7,
+                     8,  9, 10, 11, 12, 13, 14, 15,
+                    16, 17, 18, 19, 20, 21, 22, 23,
+                    24, 25, 26, 27, 28, 29, 30, 31 };
+
 static UNUSED_ATTR const U32 ML_base[MaxML+1] = {
-                     3,  4,  5,    6,     7,     8,     9,    10, 
-                    11, 12, 13,   14,    15,    16,    17,    18, 
-                    19, 20, 21,   22,    23,    24,    25,    26, 
-                    27, 28, 29,   30,    31,    32,    33,    34, 
-                    35, 37, 39,   41,    43,    47,    51,    59, 
-                    67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803, 
-                    0x1003, 0x2003, 0x4003, 0x8003, 0x10003 }; 
- 
- 
-/*-******************************************************* 
- *  Decompression types 
- *********************************************************/ 
- typedef struct { 
-     U32 fastMode; 
-     U32 tableLog; 
- } ZSTD_seqSymbol_header; 
- 
- typedef struct { 
-     U16  nextState; 
-     BYTE nbAdditionalBits; 
-     BYTE nbBits; 
-     U32  baseValue; 
- } ZSTD_seqSymbol; 
- 
- #define SEQSYMBOL_TABLE_SIZE(log)   (1 + (1 << (log))) 
- 
+                     3,  4,  5,    6,     7,     8,     9,    10,
+                    11, 12, 13,   14,    15,    16,    17,    18,
+                    19, 20, 21,   22,    23,    24,    25,    26,
+                    27, 28, 29,   30,    31,    32,    33,    34,
+                    35, 37, 39,   41,    43,    47,    51,    59,
+                    67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803,
+                    0x1003, 0x2003, 0x4003, 0x8003, 0x10003 };
+
+
+/*-*******************************************************
+ *  Decompression types
+ *********************************************************/
+ typedef struct {
+     U32 fastMode;
+     U32 tableLog;
+ } ZSTD_seqSymbol_header;
+
+ typedef struct {
+     U16  nextState;
+     BYTE nbAdditionalBits;
+     BYTE nbBits;
+     U32  baseValue;
+ } ZSTD_seqSymbol;
+
+ #define SEQSYMBOL_TABLE_SIZE(log)   (1 + (1 << (log)))
+
 #define ZSTD_BUILD_FSE_TABLE_WKSP_SIZE (sizeof(S16) * (MaxSeq + 1) + (1u << MaxFSELog) + sizeof(U64))
 #define ZSTD_BUILD_FSE_TABLE_WKSP_SIZE_U32 ((ZSTD_BUILD_FSE_TABLE_WKSP_SIZE + sizeof(U32) - 1) / sizeof(U32))
 
-typedef struct { 
-    ZSTD_seqSymbol LLTable[SEQSYMBOL_TABLE_SIZE(LLFSELog)];    /* Note : Space reserved for FSE Tables */ 
-    ZSTD_seqSymbol OFTable[SEQSYMBOL_TABLE_SIZE(OffFSELog)];   /* is also used as temporary workspace while building hufTable during DDict creation */ 
-    ZSTD_seqSymbol MLTable[SEQSYMBOL_TABLE_SIZE(MLFSELog)];    /* and therefore must be at least HUF_DECOMPRESS_WORKSPACE_SIZE large */ 
-    HUF_DTable hufTable[HUF_DTABLE_SIZE(HufLog)];  /* can accommodate HUF_decompress4X */ 
-    U32 rep[ZSTD_REP_NUM]; 
+typedef struct {
+    ZSTD_seqSymbol LLTable[SEQSYMBOL_TABLE_SIZE(LLFSELog)];    /* Note : Space reserved for FSE Tables */
+    ZSTD_seqSymbol OFTable[SEQSYMBOL_TABLE_SIZE(OffFSELog)];   /* is also used as temporary workspace while building hufTable during DDict creation */
+    ZSTD_seqSymbol MLTable[SEQSYMBOL_TABLE_SIZE(MLFSELog)];    /* and therefore must be at least HUF_DECOMPRESS_WORKSPACE_SIZE large */
+    HUF_DTable hufTable[HUF_DTABLE_SIZE(HufLog)];  /* can accommodate HUF_decompress4X */
+    U32 rep[ZSTD_REP_NUM];
     U32 workspace[ZSTD_BUILD_FSE_TABLE_WKSP_SIZE_U32];
-} ZSTD_entropyDTables_t; 
- 
-typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader, 
-               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock, 
-               ZSTDds_decompressLastBlock, ZSTDds_checkChecksum, 
-               ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTD_dStage; 
- 
-typedef enum { zdss_init=0, zdss_loadHeader, 
-               zdss_read, zdss_load, zdss_flush } ZSTD_dStreamStage; 
- 
-typedef enum { 
-    ZSTD_use_indefinitely = -1,  /* Use the dictionary indefinitely */ 
-    ZSTD_dont_use = 0,           /* Do not use the dictionary (if one exists free it) */ 
-    ZSTD_use_once = 1            /* Use the dictionary once and set to ZSTD_dont_use */ 
-} ZSTD_dictUses_e; 
- 
+} ZSTD_entropyDTables_t;
+
+typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,
+               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock,
+               ZSTDds_decompressLastBlock, ZSTDds_checkChecksum,
+               ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTD_dStage;
+
+typedef enum { zdss_init=0, zdss_loadHeader,
+               zdss_read, zdss_load, zdss_flush } ZSTD_dStreamStage;
+
+typedef enum {
+    ZSTD_use_indefinitely = -1,  /* Use the dictionary indefinitely */
+    ZSTD_dont_use = 0,           /* Do not use the dictionary (if one exists free it) */
+    ZSTD_use_once = 1            /* Use the dictionary once and set to ZSTD_dont_use */
+} ZSTD_dictUses_e;
+
 /* Hashset for storing references to multiple ZSTD_DDict within ZSTD_DCtx */
 typedef struct {
     const ZSTD_DDict** ddictPtrTable;
@@ -122,76 +122,76 @@ typedef enum {
     ZSTD_split = 2            /* Split between litExtraBuffer and dst */
 } ZSTD_litLocation_e;
 
-struct ZSTD_DCtx_s 
-{ 
-    const ZSTD_seqSymbol* LLTptr; 
-    const ZSTD_seqSymbol* MLTptr; 
-    const ZSTD_seqSymbol* OFTptr; 
-    const HUF_DTable* HUFptr; 
-    ZSTD_entropyDTables_t entropy; 
-    U32 workspace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];   /* space needed when building huffman tables */ 
-    const void* previousDstEnd;   /* detect continuity */ 
-    const void* prefixStart;      /* start of current segment */ 
-    const void* virtualStart;     /* virtual start of previous segment if it was just before current one */ 
-    const void* dictEnd;          /* end of previous segment */ 
-    size_t expected; 
-    ZSTD_frameHeader fParams; 
+struct ZSTD_DCtx_s
+{
+    const ZSTD_seqSymbol* LLTptr;
+    const ZSTD_seqSymbol* MLTptr;
+    const ZSTD_seqSymbol* OFTptr;
+    const HUF_DTable* HUFptr;
+    ZSTD_entropyDTables_t entropy;
+    U32 workspace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];   /* space needed when building huffman tables */
+    const void* previousDstEnd;   /* detect continuity */
+    const void* prefixStart;      /* start of current segment */
+    const void* virtualStart;     /* virtual start of previous segment if it was just before current one */
+    const void* dictEnd;          /* end of previous segment */
+    size_t expected;
+    ZSTD_frameHeader fParams;
     U64 processedCSize;
-    U64 decodedSize; 
-    blockType_e bType;            /* used in ZSTD_decompressContinue(), store blockType between block header decoding and block decompression stages */ 
-    ZSTD_dStage stage; 
-    U32 litEntropy; 
-    U32 fseEntropy; 
-    XXH64_state_t xxhState; 
-    size_t headerSize; 
-    ZSTD_format_e format; 
+    U64 decodedSize;
+    blockType_e bType;            /* used in ZSTD_decompressContinue(), store blockType between block header decoding and block decompression stages */
+    ZSTD_dStage stage;
+    U32 litEntropy;
+    U32 fseEntropy;
+    XXH64_state_t xxhState;
+    size_t headerSize;
+    ZSTD_format_e format;
     ZSTD_forceIgnoreChecksum_e forceIgnoreChecksum;   /* User specified: if == 1, will ignore checksums in compressed frame. Default == 0 */
     U32 validateChecksum;         /* if == 1, will validate checksum. Is == 1 if (fParams.checksumFlag == 1) and (forceIgnoreChecksum == 0). */
-    const BYTE* litPtr; 
-    ZSTD_customMem customMem; 
-    size_t litSize; 
-    size_t rleSize; 
-    size_t staticSize; 
+    const BYTE* litPtr;
+    ZSTD_customMem customMem;
+    size_t litSize;
+    size_t rleSize;
+    size_t staticSize;
 #if DYNAMIC_BMI2 != 0
-    int bmi2;                     /* == 1 if the CPU supports BMI2 and 0 otherwise. CPU support is determined dynamically once per context lifetime. */ 
+    int bmi2;                     /* == 1 if the CPU supports BMI2 and 0 otherwise. CPU support is determined dynamically once per context lifetime. */
 #endif
- 
-    /* dictionary */ 
-    ZSTD_DDict* ddictLocal; 
-    const ZSTD_DDict* ddict;     /* set by ZSTD_initDStream_usingDDict(), or ZSTD_DCtx_refDDict() */ 
-    U32 dictID; 
-    int ddictIsCold;             /* if == 1 : dictionary is "new" for working context, and presumed "cold" (not in cpu cache) */ 
-    ZSTD_dictUses_e dictUses; 
+
+    /* dictionary */
+    ZSTD_DDict* ddictLocal;
+    const ZSTD_DDict* ddict;     /* set by ZSTD_initDStream_usingDDict(), or ZSTD_DCtx_refDDict() */
+    U32 dictID;
+    int ddictIsCold;             /* if == 1 : dictionary is "new" for working context, and presumed "cold" (not in cpu cache) */
+    ZSTD_dictUses_e dictUses;
     ZSTD_DDictHashSet* ddictSet;                    /* Hash set for multiple ddicts */
     ZSTD_refMultipleDDicts_e refMultipleDDicts;     /* User specified: if == 1, will allow references to multiple DDicts. Default == 0 (disabled) */
- 
-    /* streaming */ 
-    ZSTD_dStreamStage streamStage; 
-    char*  inBuff; 
-    size_t inBuffSize; 
-    size_t inPos; 
-    size_t maxWindowSize; 
-    char*  outBuff; 
-    size_t outBuffSize; 
-    size_t outStart; 
-    size_t outEnd; 
-    size_t lhSize; 
+
+    /* streaming */
+    ZSTD_dStreamStage streamStage;
+    char*  inBuff;
+    size_t inBuffSize;
+    size_t inPos;
+    size_t maxWindowSize;
+    char*  outBuff;
+    size_t outBuffSize;
+    size_t outStart;
+    size_t outEnd;
+    size_t lhSize;
 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
-    void* legacyContext; 
-    U32 previousLegacyVersion; 
-    U32 legacyVersion; 
+    void* legacyContext;
+    U32 previousLegacyVersion;
+    U32 legacyVersion;
 #endif
-    U32 hostageByte; 
-    int noForwardProgress; 
+    U32 hostageByte;
+    int noForwardProgress;
     ZSTD_bufferMode_e outBufferMode;
     ZSTD_outBuffer expectedOutBuffer;
- 
-    /* workspace */ 
+
+    /* workspace */
     BYTE* litBuffer;
     const BYTE* litBufferEnd;
     ZSTD_litLocation_e litBufferLocation;
     BYTE litExtraBuffer[ZSTD_LITBUFFEREXTRASIZE + WILDCOPY_OVERLENGTH]; /* literal buffer can be split between storage within dst and within this scratch buffer */
-    BYTE headerBuffer[ZSTD_FRAMEHEADERSIZE_MAX]; 
+    BYTE headerBuffer[ZSTD_FRAMEHEADERSIZE_MAX];
 
     size_t oversizedDuration;
 
@@ -204,8 +204,8 @@ struct ZSTD_DCtx_s
 #if ZSTD_TRACE
     ZSTD_TraceCtx traceCtx;
 #endif
-};  /* typedef'd to ZSTD_DCtx within "zstd.h" */ 
- 
+};  /* typedef'd to ZSTD_DCtx within "zstd.h" */
+
 MEM_STATIC int ZSTD_DCtx_get_bmi2(const struct ZSTD_DCtx_s *dctx) {
 #if DYNAMIC_BMI2 != 0
 	return dctx->bmi2;
@@ -214,23 +214,23 @@ MEM_STATIC int ZSTD_DCtx_get_bmi2(const struct ZSTD_DCtx_s *dctx) {
 	return 0;
 #endif
 }
- 
-/*-******************************************************* 
- *  Shared internal functions 
- *********************************************************/ 
- 
-/*! ZSTD_loadDEntropy() : 
- *  dict : must point at beginning of a valid zstd dictionary. 
+
+/*-*******************************************************
+ *  Shared internal functions
+ *********************************************************/
+
+/*! ZSTD_loadDEntropy() :
+ *  dict : must point at beginning of a valid zstd dictionary.
  * @return : size of dictionary header (size of magic number + dict ID + entropy tables) */
-size_t ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy, 
-                   const void* const dict, size_t const dictSize); 
- 
-/*! ZSTD_checkContinuity() : 
- *  check if next `dst` follows previous position, where decompression ended. 
- *  If yes, do nothing (continue on current segment). 
- *  If not, classify previous segment as "external dictionary", and start a new segment. 
- *  This function cannot fail. */ 
+size_t ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
+                   const void* const dict, size_t const dictSize);
+
+/*! ZSTD_checkContinuity() :
+ *  check if next `dst` follows previous position, where decompression ended.
+ *  If yes, do nothing (continue on current segment).
+ *  If not, classify previous segment as "external dictionary", and start a new segment.
+ *  This function cannot fail. */
 void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize);
- 
- 
-#endif /* ZSTD_DECOMPRESS_INTERNAL_H */ 
+
+
+#endif /* ZSTD_DECOMPRESS_INTERNAL_H */