Restoring authorship annotation for Ruslan Kovalev <ruslan.a.kovalev@gmail.com>. Commit 1 of 2.

1 files changed, 241 insertions, 241 deletions

diff --git a/contrib/libs/zstd/lib/common/fse_decompress.c b/contrib/libs/zstd/lib/common/fse_decompress.c
index a5a358015f..d8c9ae1753 100644
--- a/contrib/libs/zstd/lib/common/fse_decompress.c
+++ b/contrib/libs/zstd/lib/common/fse_decompress.c
@@ -1,4 +1,4 @@
-/* ******************************************************************
+/* ****************************************************************** 
  * FSE : Finite State Entropy decoder
  * Copyright (c) Yann Collet, Facebook, Inc.
  *
@@ -10,98 +10,98 @@
  * 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.
-****************************************************************** */
-
-
-/* **************************************************************
-*  Includes
-****************************************************************/
+****************************************************************** */ 
+ 
+ 
+/* ************************************************************** 
+*  Includes 
+****************************************************************/ 
 #include "debug.h"      /* assert */
-#include "bitstream.h"
+#include "bitstream.h" 
 #include "compiler.h"
-#define FSE_STATIC_LINKING_ONLY
-#include "fse.h"
+#define FSE_STATIC_LINKING_ONLY 
+#include "fse.h" 
 #include "error_private.h"
 #define ZSTD_DEPS_NEED_MALLOC
 #include "zstd_deps.h"
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#define FSE_isError ERR_isError
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#define FSE_isError ERR_isError 
 #define FSE_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)   /* use only *after* variable declarations */
-
-
-/* **************************************************************
-*  Templates
-****************************************************************/
-/*
-  designed to be included
-  for type-specific functions (template emulation in C)
-  Objective is to write these functions only once, for improved maintenance
-*/
-
-/* safety checks */
-#ifndef FSE_FUNCTION_EXTENSION
-#  error "FSE_FUNCTION_EXTENSION must be defined"
-#endif
-#ifndef FSE_FUNCTION_TYPE
-#  error "FSE_FUNCTION_TYPE must be defined"
-#endif
-
-/* Function names */
-#define FSE_CAT(X,Y) X##Y
-#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)
-#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)
-
-
-/* Function templates */
-FSE_DTable* FSE_createDTable (unsigned tableLog)
-{
-    if (tableLog > FSE_TABLELOG_ABSOLUTE_MAX) tableLog = FSE_TABLELOG_ABSOLUTE_MAX;
+ 
+ 
+/* ************************************************************** 
+*  Templates 
+****************************************************************/ 
+/* 
+  designed to be included 
+  for type-specific functions (template emulation in C) 
+  Objective is to write these functions only once, for improved maintenance 
+*/ 
+ 
+/* safety checks */ 
+#ifndef FSE_FUNCTION_EXTENSION 
+#  error "FSE_FUNCTION_EXTENSION must be defined" 
+#endif 
+#ifndef FSE_FUNCTION_TYPE 
+#  error "FSE_FUNCTION_TYPE must be defined" 
+#endif 
+ 
+/* Function names */ 
+#define FSE_CAT(X,Y) X##Y 
+#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y) 
+#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y) 
+ 
+ 
+/* Function templates */ 
+FSE_DTable* FSE_createDTable (unsigned tableLog) 
+{ 
+    if (tableLog > FSE_TABLELOG_ABSOLUTE_MAX) tableLog = FSE_TABLELOG_ABSOLUTE_MAX; 
     return (FSE_DTable*)ZSTD_malloc( FSE_DTABLE_SIZE_U32(tableLog) * sizeof (U32) );
-}
-
-void FSE_freeDTable (FSE_DTable* dt)
-{
+} 
+ 
+void FSE_freeDTable (FSE_DTable* dt) 
+{ 
     ZSTD_free(dt);
-}
-
+} 
+ 
 static size_t FSE_buildDTable_internal(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize)
-{
-    void* const tdPtr = dt+1;   /* because *dt is unsigned, 32-bits aligned on 32-bits */
-    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*) (tdPtr);
+{ 
+    void* const tdPtr = dt+1;   /* because *dt is unsigned, 32-bits aligned on 32-bits */ 
+    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*) (tdPtr); 
     U16* symbolNext = (U16*)workSpace;
     BYTE* spread = (BYTE*)(symbolNext + maxSymbolValue + 1);
-
-    U32 const maxSV1 = maxSymbolValue + 1;
-    U32 const tableSize = 1 << tableLog;
-    U32 highThreshold = tableSize-1;
-
-    /* Sanity Checks */
+ 
+    U32 const maxSV1 = maxSymbolValue + 1; 
+    U32 const tableSize = 1 << tableLog; 
+    U32 highThreshold = tableSize-1; 
+ 
+    /* Sanity Checks */ 
     if (FSE_BUILD_DTABLE_WKSP_SIZE(tableLog, maxSymbolValue) > wkspSize) return ERROR(maxSymbolValue_tooLarge);
-    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
-    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
-
-    /* Init, lay down lowprob symbols */
-    {   FSE_DTableHeader DTableH;
-        DTableH.tableLog = (U16)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--].symbol = (FSE_FUNCTION_TYPE)s;
-                    symbolNext[s] = 1;
-                } else {
-                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
-                    symbolNext[s] = normalizedCounter[s];
-        }   }   }
+    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge); 
+    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge); 
+ 
+    /* Init, lay down lowprob symbols */ 
+    {   FSE_DTableHeader DTableH; 
+        DTableH.tableLog = (U16)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--].symbol = (FSE_FUNCTION_TYPE)s; 
+                    symbolNext[s] = 1; 
+                } else { 
+                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0; 
+                    symbolNext[s] = normalizedCounter[s]; 
+        }   }   } 
         ZSTD_memcpy(dt, &DTableH, sizeof(DTableH));
-    }
-
-    /* Spread symbols */
+    } 
+ 
+    /* Spread symbols */ 
     if (highThreshold == tableSize - 1) {
         size_t const tableMask = tableSize-1;
         size_t const step = FSE_TABLESTEP(tableSize);
@@ -149,164 +149,164 @@ static size_t FSE_buildDTable_internal(FSE_DTable* dt, const short* normalizedCo
         }
     } else {
         U32 const tableMask = tableSize-1;
-        U32 const step = FSE_TABLESTEP(tableSize);
-        U32 s, position = 0;
-        for (s=0; s<maxSV1; s++) {
-            int i;
-            for (i=0; i<normalizedCounter[s]; i++) {
-                tableDecode[position].symbol = (FSE_FUNCTION_TYPE)s;
-                position = (position + step) & tableMask;
-                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
-        }   }
-        if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
-    }
-
-    /* Build Decoding table */
-    {   U32 u;
-        for (u=0; u<tableSize; u++) {
-            FSE_FUNCTION_TYPE const symbol = (FSE_FUNCTION_TYPE)(tableDecode[u].symbol);
+        U32 const step = FSE_TABLESTEP(tableSize); 
+        U32 s, position = 0; 
+        for (s=0; s<maxSV1; s++) { 
+            int i; 
+            for (i=0; i<normalizedCounter[s]; i++) { 
+                tableDecode[position].symbol = (FSE_FUNCTION_TYPE)s; 
+                position = (position + step) & tableMask; 
+                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */ 
+        }   } 
+        if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */ 
+    } 
+ 
+    /* Build Decoding table */ 
+    {   U32 u; 
+        for (u=0; u<tableSize; u++) { 
+            FSE_FUNCTION_TYPE const symbol = (FSE_FUNCTION_TYPE)(tableDecode[u].symbol); 
             U32 const nextState = symbolNext[symbol]++;
             tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) );
-            tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
-    }   }
-
-    return 0;
-}
-
+            tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize); 
+    }   } 
+ 
+    return 0; 
+} 
+ 
 size_t FSE_buildDTable_wksp(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize)
 {
     return FSE_buildDTable_internal(dt, normalizedCounter, maxSymbolValue, tableLog, workSpace, wkspSize);
 }
-
-
-#ifndef FSE_COMMONDEFS_ONLY
-
-/*-*******************************************************
-*  Decompression (Byte symbols)
-*********************************************************/
-size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
-{
-    void* ptr = dt;
-    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
-    void* dPtr = dt + 1;
-    FSE_decode_t* const cell = (FSE_decode_t*)dPtr;
-
-    DTableH->tableLog = 0;
-    DTableH->fastMode = 0;
-
-    cell->newState = 0;
-    cell->symbol = symbolValue;
-    cell->nbBits = 0;
-
-    return 0;
-}
-
-
-size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
-{
-    void* ptr = dt;
-    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
-    void* dPtr = dt + 1;
-    FSE_decode_t* const dinfo = (FSE_decode_t*)dPtr;
-    const unsigned tableSize = 1 << nbBits;
-    const unsigned tableMask = tableSize - 1;
-    const unsigned maxSV1 = tableMask+1;
-    unsigned s;
-
-    /* Sanity checks */
-    if (nbBits < 1) return ERROR(GENERIC);         /* min size */
-
-    /* Build Decoding Table */
-    DTableH->tableLog = (U16)nbBits;
-    DTableH->fastMode = 1;
-    for (s=0; s<maxSV1; s++) {
-        dinfo[s].newState = 0;
-        dinfo[s].symbol = (BYTE)s;
-        dinfo[s].nbBits = (BYTE)nbBits;
-    }
-
-    return 0;
-}
-
+ 
+
+#ifndef FSE_COMMONDEFS_ONLY 
+ 
+/*-******************************************************* 
+*  Decompression (Byte symbols) 
+*********************************************************/ 
+size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue) 
+{ 
+    void* ptr = dt; 
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; 
+    void* dPtr = dt + 1; 
+    FSE_decode_t* const cell = (FSE_decode_t*)dPtr; 
+ 
+    DTableH->tableLog = 0; 
+    DTableH->fastMode = 0; 
+ 
+    cell->newState = 0; 
+    cell->symbol = symbolValue; 
+    cell->nbBits = 0; 
+ 
+    return 0; 
+} 
+ 
+ 
+size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits) 
+{ 
+    void* ptr = dt; 
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; 
+    void* dPtr = dt + 1; 
+    FSE_decode_t* const dinfo = (FSE_decode_t*)dPtr; 
+    const unsigned tableSize = 1 << nbBits; 
+    const unsigned tableMask = tableSize - 1; 
+    const unsigned maxSV1 = tableMask+1; 
+    unsigned s; 
+ 
+    /* Sanity checks */ 
+    if (nbBits < 1) return ERROR(GENERIC);         /* min size */ 
+ 
+    /* Build Decoding Table */ 
+    DTableH->tableLog = (U16)nbBits; 
+    DTableH->fastMode = 1; 
+    for (s=0; s<maxSV1; s++) { 
+        dinfo[s].newState = 0; 
+        dinfo[s].symbol = (BYTE)s; 
+        dinfo[s].nbBits = (BYTE)nbBits; 
+    } 
+ 
+    return 0; 
+} 
+ 
 FORCE_INLINE_TEMPLATE size_t FSE_decompress_usingDTable_generic(
-          void* dst, size_t maxDstSize,
-    const void* cSrc, size_t cSrcSize,
-    const FSE_DTable* dt, const unsigned fast)
-{
-    BYTE* const ostart = (BYTE*) dst;
-    BYTE* op = ostart;
-    BYTE* const omax = op + maxDstSize;
-    BYTE* const olimit = omax-3;
-
-    BIT_DStream_t bitD;
-    FSE_DState_t state1;
-    FSE_DState_t state2;
-
-    /* Init */
+          void* dst, size_t maxDstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const FSE_DTable* dt, const unsigned fast) 
+{ 
+    BYTE* const ostart = (BYTE*) dst; 
+    BYTE* op = ostart; 
+    BYTE* const omax = op + maxDstSize; 
+    BYTE* const olimit = omax-3; 
+ 
+    BIT_DStream_t bitD; 
+    FSE_DState_t state1; 
+    FSE_DState_t state2; 
+ 
+    /* Init */ 
     CHECK_F(BIT_initDStream(&bitD, cSrc, cSrcSize));
-
-    FSE_initDState(&state1, &bitD, dt);
-    FSE_initDState(&state2, &bitD, dt);
-
-#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)
-
-    /* 4 symbols per loop */
+ 
+    FSE_initDState(&state1, &bitD, dt); 
+    FSE_initDState(&state2, &bitD, dt); 
+ 
+#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD) 
+ 
+    /* 4 symbols per loop */ 
     for ( ; (BIT_reloadDStream(&bitD)==BIT_DStream_unfinished) & (op<olimit) ; op+=4) {
-        op[0] = FSE_GETSYMBOL(&state1);
-
-        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            BIT_reloadDStream(&bitD);
-
-        op[1] = FSE_GETSYMBOL(&state2);
-
-        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }
-
-        op[2] = FSE_GETSYMBOL(&state1);
-
-        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            BIT_reloadDStream(&bitD);
-
-        op[3] = FSE_GETSYMBOL(&state2);
-    }
-
-    /* tail */
-    /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */
-    while (1) {
-        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
-        *op++ = FSE_GETSYMBOL(&state1);
-        if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) {
-            *op++ = FSE_GETSYMBOL(&state2);
-            break;
-        }
-
-        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
-        *op++ = FSE_GETSYMBOL(&state2);
-        if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) {
-            *op++ = FSE_GETSYMBOL(&state1);
-            break;
-    }   }
-
-    return op-ostart;
-}
-
-
-size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
-                            const void* cSrc, size_t cSrcSize,
-                            const FSE_DTable* dt)
-{
-    const void* ptr = dt;
-    const FSE_DTableHeader* DTableH = (const FSE_DTableHeader*)ptr;
-    const U32 fastMode = DTableH->fastMode;
-
-    /* select fast mode (static) */
-    if (fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
-    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
-}
-
-
+        op[0] = FSE_GETSYMBOL(&state1); 
+ 
+        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            BIT_reloadDStream(&bitD); 
+ 
+        op[1] = FSE_GETSYMBOL(&state2); 
+ 
+        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } } 
+ 
+        op[2] = FSE_GETSYMBOL(&state1); 
+ 
+        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            BIT_reloadDStream(&bitD); 
+ 
+        op[3] = FSE_GETSYMBOL(&state2); 
+    } 
+ 
+    /* tail */ 
+    /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */ 
+    while (1) { 
+        if (op>(omax-2)) return ERROR(dstSize_tooSmall); 
+        *op++ = FSE_GETSYMBOL(&state1); 
+        if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) { 
+            *op++ = FSE_GETSYMBOL(&state2); 
+            break; 
+        } 
+ 
+        if (op>(omax-2)) return ERROR(dstSize_tooSmall); 
+        *op++ = FSE_GETSYMBOL(&state2); 
+        if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) { 
+            *op++ = FSE_GETSYMBOL(&state1); 
+            break; 
+    }   } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+size_t FSE_decompress_usingDTable(void* dst, size_t originalSize, 
+                            const void* cSrc, size_t cSrcSize, 
+                            const FSE_DTable* dt) 
+{ 
+    const void* ptr = dt; 
+    const FSE_DTableHeader* DTableH = (const FSE_DTableHeader*)ptr; 
+    const U32 fastMode = DTableH->fastMode; 
+ 
+    /* select fast mode (static) */ 
+    if (fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1); 
+    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0); 
+} 
+ 
+ 
 size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize)
-{
+{ 
     return FSE_decompress_wksp_bmi2(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize, /* bmi2 */ 0);
 }
 
@@ -322,16 +322,16 @@ FORCE_INLINE_TEMPLATE size_t FSE_decompress_wksp_body(
         unsigned maxLog, void* workSpace, size_t wkspSize,
         int bmi2)
 {
-    const BYTE* const istart = (const BYTE*)cSrc;
-    const BYTE* ip = istart;
-    unsigned tableLog;
-    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
+    const BYTE* const istart = (const BYTE*)cSrc; 
+    const BYTE* ip = istart; 
+    unsigned tableLog; 
+    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE; 
     FSE_DecompressWksp* const wksp = (FSE_DecompressWksp*)workSpace;
-
+ 
     DEBUG_STATIC_ASSERT((FSE_MAX_SYMBOL_VALUE + 1) % 2 == 0);
     if (wkspSize < sizeof(*wksp)) return ERROR(GENERIC);
 
-    /* normal FSE decoding mode */
+    /* normal FSE decoding mode */ 
     {
         size_t const NCountLength = FSE_readNCount_bmi2(wksp->ncount, &maxSymbolValue, &tableLog, istart, cSrcSize, bmi2);
         if (FSE_isError(NCountLength)) return NCountLength;
@@ -340,11 +340,11 @@ FORCE_INLINE_TEMPLATE size_t FSE_decompress_wksp_body(
         ip += NCountLength;
         cSrcSize -= NCountLength;
     }
-
+ 
     if (FSE_DECOMPRESS_WKSP_SIZE(tableLog, maxSymbolValue) > wkspSize) return ERROR(tableLog_tooLarge);
     workSpace = wksp->dtable + FSE_DTABLE_SIZE_U32(tableLog);
     wkspSize -= sizeof(*wksp) + FSE_DTABLE_SIZE(tableLog);
-
+ 
     CHECK_F( FSE_buildDTable_internal(wksp->dtable, wksp->ncount, maxSymbolValue, tableLog, workSpace, wkspSize) );
 
     {
@@ -356,14 +356,14 @@ FORCE_INLINE_TEMPLATE size_t FSE_decompress_wksp_body(
         if (fastMode) return FSE_decompress_usingDTable_generic(dst, dstCapacity, ip, cSrcSize, wksp->dtable, 1);
         return FSE_decompress_usingDTable_generic(dst, dstCapacity, ip, cSrcSize, wksp->dtable, 0);
     }
-}
-
+} 
+ 
 /* Avoids the FORCE_INLINE of the _body() function. */
 static size_t FSE_decompress_wksp_body_default(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize)
 {
     return FSE_decompress_wksp_body(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize, 0);
 }
-
+ 
 #if DYNAMIC_BMI2
 BMI2_TARGET_ATTRIBUTE static size_t FSE_decompress_wksp_body_bmi2(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize)
 {
@@ -384,7 +384,7 @@ size_t FSE_decompress_wksp_bmi2(void* dst, size_t dstCapacity, const void* cSrc,
 
 
 typedef FSE_DTable DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];
-
+ 
 #ifndef ZSTD_NO_UNUSED_FUNCTIONS
 size_t FSE_buildDTable(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) {
     U32 wksp[FSE_BUILD_DTABLE_WKSP_SIZE_U32(FSE_TABLELOG_ABSOLUTE_MAX, FSE_MAX_SYMBOL_VALUE)];
@@ -400,4 +400,4 @@ size_t FSE_decompress(void* dst, size_t dstCapacity, const void* cSrc, size_t cS
 #endif
 
 
-#endif   /* FSE_COMMONDEFS_ONLY */
+#endif   /* FSE_COMMONDEFS_ONLY */