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

16 files changed, 428 insertions, 428 deletions

diff --git a/contrib/libs/zstd/lib/common/bitstream.h b/contrib/libs/zstd/lib/common/bitstream.h
index 84b6062ff3..35483bb7c2 100644
--- a/contrib/libs/zstd/lib/common/bitstream.h
+++ b/contrib/libs/zstd/lib/common/bitstream.h
@@ -28,7 +28,7 @@ extern "C" {
 ******************************************/
 #include "mem.h"            /* unaligned access routines */
 #include "compiler.h"       /* UNLIKELY() */
-#include "debug.h"          /* assert(), DEBUGLOG(), RAWLOG() */
+#include "debug.h"          /* assert(), DEBUGLOG(), RAWLOG() */ 
 #include "error_private.h"  /* error codes and messages */
 
 
@@ -55,7 +55,7 @@ extern "C" {
  * A critical property of these streams is that they encode and decode in **reverse** direction.
  * So the first bit sequence you add will be the last to be read, like a LIFO stack.
  */
-typedef struct {
+typedef struct { 
     size_t bitContainer;
     unsigned bitPos;
     char*  startPtr;
@@ -89,7 +89,7 @@ MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC);
 /*-********************************************
 *  bitStream decoding API (read backward)
 **********************************************/
-typedef struct {
+typedef struct { 
     size_t   bitContainer;
     unsigned bitsConsumed;
     const char* ptr;
@@ -217,8 +217,8 @@ MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC,
 }
 
 /*! BIT_addBitsFast() :
- *  works only if `value` is _clean_,
- *  meaning all high bits above nbBits are 0 */
+ *  works only if `value` is _clean_, 
+ *  meaning all high bits above nbBits are 0 */ 
 MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC,
                                 size_t value, unsigned nbBits)
 {
@@ -335,8 +335,8 @@ MEM_STATIC FORCE_INLINE_ATTR size_t BIT_getUpperBits(size_t bitContainer, U32 co
 
 MEM_STATIC FORCE_INLINE_ATTR size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 const nbBits)
 {
-    U32 const regMask = sizeof(bitContainer)*8 - 1;
-    /* if start > regMask, bitstream is corrupted, and result is undefined */
+    U32 const regMask = sizeof(bitContainer)*8 - 1; 
+    /* if start > regMask, bitstream is corrupted, and result is undefined */ 
     assert(nbBits < BIT_MASK_SIZE);
     /* x86 transform & ((1 << nbBits) - 1) to bzhi instruction, it is better
      * than accessing memory. When bmi2 instruction is not present, we consider
@@ -346,7 +346,7 @@ MEM_STATIC FORCE_INLINE_ATTR size_t BIT_getMiddleBits(size_t bitContainer, U32 c
 #if defined(__x86_64__) || defined(_M_X86)
     return (bitContainer >> (start & regMask)) & ((((U64)1) << nbBits) - 1);
 #else
-    return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
+    return (bitContainer >> (start & regMask)) & BIT_mask[nbBits]; 
 #endif
 }
 
@@ -368,13 +368,13 @@ MEM_STATIC FORCE_INLINE_ATTR size_t BIT_getLowerBits(size_t bitContainer, U32 co
  * @return : value extracted */
 MEM_STATIC  FORCE_INLINE_ATTR size_t BIT_lookBits(const BIT_DStream_t*  bitD, U32 nbBits)
 {
-    /* arbitrate between double-shift and shift+mask */
-#if 1
-    /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8,
-     * bitstream is likely corrupted, and result is undefined */
+    /* arbitrate between double-shift and shift+mask */ 
+#if 1 
+    /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8, 
+     * bitstream is likely corrupted, and result is undefined */ 
     return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
 #else
-    /* this code path is slower on my os-x laptop */
+    /* this code path is slower on my os-x laptop */ 
     U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
     return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask);
 #endif
@@ -407,7 +407,7 @@ MEM_STATIC FORCE_INLINE_ATTR size_t BIT_readBits(BIT_DStream_t* bitD, unsigned n
 
 /*! BIT_readBitsFast() :
  *  unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits)
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits) 
 {
     size_t const value = BIT_lookBitsFast(bitD, nbBits);
     assert(nbBits >= 1);
diff --git a/contrib/libs/zstd/lib/common/compiler.h b/contrib/libs/zstd/lib/common/compiler.h
index 516930c01e..29c1b56864 100644
--- a/contrib/libs/zstd/lib/common/compiler.h
+++ b/contrib/libs/zstd/lib/common/compiler.h
@@ -17,8 +17,8 @@
 *  Compiler specifics
 *********************************************************/
 /* force inlining */
-
-#if !defined(ZSTD_NO_INLINE)
+ 
+#if !defined(ZSTD_NO_INLINE) 
 #if (defined(__GNUC__) && !defined(__STRICT_ANSI__)) || defined(__cplusplus) || defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
 #  define INLINE_KEYWORD inline
 #else
@@ -33,13 +33,13 @@
 #  define FORCE_INLINE_ATTR
 #endif
 
-#else
-
-#define INLINE_KEYWORD
-#define FORCE_INLINE_ATTR
-
-#endif
-
+#else 
+ 
+#define INLINE_KEYWORD 
+#define FORCE_INLINE_ATTR 
+ 
+#endif 
+ 
 /**
   On MSVC qsort requires that functions passed into it use the __cdecl calling conversion(CC).
   This explicitly marks such functions as __cdecl so that the code will still compile
@@ -53,7 +53,7 @@
 
 /**
  * FORCE_INLINE_TEMPLATE is used to define C "templates", which take constant
- * parameters. They must be inlined for the compiler to eliminate the constant
+ * parameters. They must be inlined for the compiler to eliminate the constant 
  * branches.
  */
 #define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR
@@ -106,39 +106,39 @@
  */
 #define BMI2_TARGET_ATTRIBUTE TARGET_ATTRIBUTE("lzcnt,bmi,bmi2")
 
-/* prefetch
- * can be disabled, by declaring NO_PREFETCH build macro */
-#if defined(NO_PREFETCH)
-#  define PREFETCH_L1(ptr)  (void)(ptr)  /* disabled */
-#  define PREFETCH_L2(ptr)  (void)(ptr)  /* disabled */
+/* prefetch 
+ * can be disabled, by declaring NO_PREFETCH build macro */ 
+#if defined(NO_PREFETCH) 
+#  define PREFETCH_L1(ptr)  (void)(ptr)  /* disabled */ 
+#  define PREFETCH_L2(ptr)  (void)(ptr)  /* disabled */ 
 #else
-#  if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86))  /* _mm_prefetch() is not defined outside of x86/x64 */
-#    include <mmintrin.h>   /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */
-#    define PREFETCH_L1(ptr)  _mm_prefetch((const char*)(ptr), _MM_HINT_T0)
-#    define PREFETCH_L2(ptr)  _mm_prefetch((const char*)(ptr), _MM_HINT_T1)
-#  elif defined(__GNUC__) && ( (__GNUC__ >= 4) || ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) ) )
-#    define PREFETCH_L1(ptr)  __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality */)
-#    define PREFETCH_L2(ptr)  __builtin_prefetch((ptr), 0 /* rw==read */, 2 /* locality */)
+#  if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86))  /* _mm_prefetch() is not defined outside of x86/x64 */ 
+#    include <mmintrin.h>   /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */ 
+#    define PREFETCH_L1(ptr)  _mm_prefetch((const char*)(ptr), _MM_HINT_T0) 
+#    define PREFETCH_L2(ptr)  _mm_prefetch((const char*)(ptr), _MM_HINT_T1) 
+#  elif defined(__GNUC__) && ( (__GNUC__ >= 4) || ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) ) ) 
+#    define PREFETCH_L1(ptr)  __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality */) 
+#    define PREFETCH_L2(ptr)  __builtin_prefetch((ptr), 0 /* rw==read */, 2 /* locality */) 
 #  elif defined(__aarch64__)
 #    define PREFETCH_L1(ptr)  __asm__ __volatile__("prfm pldl1keep, %0" ::"Q"(*(ptr)))
 #    define PREFETCH_L2(ptr)  __asm__ __volatile__("prfm pldl2keep, %0" ::"Q"(*(ptr)))
-#  else
-#    define PREFETCH_L1(ptr) (void)(ptr)  /* disabled */
-#    define PREFETCH_L2(ptr) (void)(ptr)  /* disabled */
-#  endif
-#endif  /* NO_PREFETCH */
-
-#define CACHELINE_SIZE 64
-
-#define PREFETCH_AREA(p, s)  {            \
-    const char* const _ptr = (const char*)(p);  \
-    size_t const _size = (size_t)(s);     \
-    size_t _pos;                          \
-    for (_pos=0; _pos<_size; _pos+=CACHELINE_SIZE) {  \
-        PREFETCH_L2(_ptr + _pos);         \
-    }                                     \
-}
-
+#  else 
+#    define PREFETCH_L1(ptr) (void)(ptr)  /* disabled */ 
+#    define PREFETCH_L2(ptr) (void)(ptr)  /* disabled */ 
+#  endif 
+#endif  /* NO_PREFETCH */ 
+
+#define CACHELINE_SIZE 64 
+ 
+#define PREFETCH_AREA(p, s)  {            \ 
+    const char* const _ptr = (const char*)(p);  \ 
+    size_t const _size = (size_t)(s);     \ 
+    size_t _pos;                          \ 
+    for (_pos=0; _pos<_size; _pos+=CACHELINE_SIZE) {  \ 
+        PREFETCH_L2(_ptr + _pos);         \ 
+    }                                     \ 
+} 
+ 
 /* vectorization
  * older GCC (pre gcc-4.3 picked as the cutoff) uses a different syntax,
  * and some compilers, like Intel ICC and MCST LCC, do not support it at all. */
diff --git a/contrib/libs/zstd/lib/common/cpu.h b/contrib/libs/zstd/lib/common/cpu.h
index 8acd33be3c..fcd36742eb 100644
--- a/contrib/libs/zstd/lib/common/cpu.h
+++ b/contrib/libs/zstd/lib/common/cpu.h
@@ -34,7 +34,7 @@ MEM_STATIC ZSTD_cpuid_t ZSTD_cpuid(void) {
     U32 f1d = 0;
     U32 f7b = 0;
     U32 f7c = 0;
-#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))
+#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86)) 
     int reg[4];
     __cpuid((int*)reg, 0);
     {
@@ -70,13 +70,13 @@ MEM_STATIC ZSTD_cpuid_t ZSTD_cpuid(void) {
           "cpuid\n\t"
           "popl %%ebx\n\t"
           : "=a"(f1a), "=c"(f1c), "=d"(f1d)
-          : "a"(1));
+          : "a"(1)); 
     }
     if (n >= 7) {
       __asm__(
           "pushl %%ebx\n\t"
           "cpuid\n\t"
-          "movl %%ebx, %%eax\n\t"
+          "movl %%ebx, %%eax\n\t" 
           "popl %%ebx"
           : "=a"(f7b), "=c"(f7c)
           : "a"(7), "c"(0)
diff --git a/contrib/libs/zstd/lib/common/debug.c b/contrib/libs/zstd/lib/common/debug.c
index bb863c9ea6..713b79c625 100644
--- a/contrib/libs/zstd/lib/common/debug.c
+++ b/contrib/libs/zstd/lib/common/debug.c
@@ -1,4 +1,4 @@
-/* ******************************************************************
+/* ****************************************************************** 
  * debug
  * Part of FSE library
  * Copyright (c) Yann Collet, Facebook, Inc.
@@ -10,15 +10,15 @@
  * 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.
-****************************************************************** */
-
-
-/*
- * This module only hosts one global variable
- * which can be used to dynamically influence the verbosity of traces,
- * such as DEBUGLOG and RAWLOG
- */
-
-#include "debug.h"
-
-int g_debuglevel = DEBUGLEVEL;
+****************************************************************** */ 
+ 
+ 
+/* 
+ * This module only hosts one global variable 
+ * which can be used to dynamically influence the verbosity of traces, 
+ * such as DEBUGLOG and RAWLOG 
+ */ 
+ 
+#include "debug.h" 
+ 
+int g_debuglevel = DEBUGLEVEL; 
diff --git a/contrib/libs/zstd/lib/common/debug.h b/contrib/libs/zstd/lib/common/debug.h
index 3b2a320a18..320f0b757e 100644
--- a/contrib/libs/zstd/lib/common/debug.h
+++ b/contrib/libs/zstd/lib/common/debug.h
@@ -1,4 +1,4 @@
-/* ******************************************************************
+/* ****************************************************************** 
  * debug
  * Part of FSE library
  * 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.
-****************************************************************** */
-
-
-/*
- * The purpose of this header is to enable debug functions.
- * They regroup assert(), DEBUGLOG() and RAWLOG() for run-time,
- * and DEBUG_STATIC_ASSERT() for compile-time.
- *
- * By default, DEBUGLEVEL==0, which means run-time debug is disabled.
- *
- * Level 1 enables assert() only.
- * Starting level 2, traces can be generated and pushed to stderr.
- * The higher the level, the more verbose the traces.
- *
- * It's possible to dynamically adjust level using variable g_debug_level,
- * which is only declared if DEBUGLEVEL>=2,
- * and is a global variable, not multi-thread protected (use with care)
- */
-
-#ifndef DEBUG_H_12987983217
-#define DEBUG_H_12987983217
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* static assert is triggered at compile time, leaving no runtime artefact.
- * static assert only works with compile-time constants.
- * Also, this variant can only be used inside a function. */
-#define DEBUG_STATIC_ASSERT(c) (void)sizeof(char[(c) ? 1 : -1])
-
-
-/* DEBUGLEVEL is expected to be defined externally,
- * typically through compiler command line.
- * Value must be a number. */
-#ifndef DEBUGLEVEL
-#  define DEBUGLEVEL 0
-#endif
-
-
-/* recommended values for DEBUGLEVEL :
- * 0 : release mode, no debug, all run-time checks disabled
- * 1 : enables assert() only, no display
- * 2 : reserved, for currently active debug path
- * 3 : events once per object lifetime (CCtx, CDict, etc.)
- * 4 : events once per frame
- * 5 : events once per block
- * 6 : events once per sequence (verbose)
- * 7+: events at every position (*very* verbose)
- *
- * It's generally inconvenient to output traces > 5.
- * In which case, it's possible to selectively trigger high verbosity levels
- * by modifying g_debug_level.
- */
-
-#if (DEBUGLEVEL>=1)
+****************************************************************** */ 
+ 
+ 
+/* 
+ * The purpose of this header is to enable debug functions. 
+ * They regroup assert(), DEBUGLOG() and RAWLOG() for run-time, 
+ * and DEBUG_STATIC_ASSERT() for compile-time. 
+ * 
+ * By default, DEBUGLEVEL==0, which means run-time debug is disabled. 
+ * 
+ * Level 1 enables assert() only. 
+ * Starting level 2, traces can be generated and pushed to stderr. 
+ * The higher the level, the more verbose the traces. 
+ * 
+ * It's possible to dynamically adjust level using variable g_debug_level, 
+ * which is only declared if DEBUGLEVEL>=2, 
+ * and is a global variable, not multi-thread protected (use with care) 
+ */ 
+ 
+#ifndef DEBUG_H_12987983217 
+#define DEBUG_H_12987983217 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* static assert is triggered at compile time, leaving no runtime artefact. 
+ * static assert only works with compile-time constants. 
+ * Also, this variant can only be used inside a function. */ 
+#define DEBUG_STATIC_ASSERT(c) (void)sizeof(char[(c) ? 1 : -1]) 
+ 
+ 
+/* DEBUGLEVEL is expected to be defined externally, 
+ * typically through compiler command line. 
+ * Value must be a number. */ 
+#ifndef DEBUGLEVEL 
+#  define DEBUGLEVEL 0 
+#endif 
+ 
+ 
+/* recommended values for DEBUGLEVEL : 
+ * 0 : release mode, no debug, all run-time checks disabled 
+ * 1 : enables assert() only, no display 
+ * 2 : reserved, for currently active debug path 
+ * 3 : events once per object lifetime (CCtx, CDict, etc.) 
+ * 4 : events once per frame 
+ * 5 : events once per block 
+ * 6 : events once per sequence (verbose) 
+ * 7+: events at every position (*very* verbose) 
+ * 
+ * It's generally inconvenient to output traces > 5. 
+ * In which case, it's possible to selectively trigger high verbosity levels 
+ * by modifying g_debug_level. 
+ */ 
+ 
+#if (DEBUGLEVEL>=1) 
 #  define ZSTD_DEPS_NEED_ASSERT
 #  include "zstd_deps.h"
-#else
-#  ifndef assert   /* assert may be already defined, due to prior #include <assert.h> */
-#    define assert(condition) ((void)0)   /* disable assert (default) */
-#  endif
-#endif
-
-#if (DEBUGLEVEL>=2)
+#else 
+#  ifndef assert   /* assert may be already defined, due to prior #include <assert.h> */ 
+#    define assert(condition) ((void)0)   /* disable assert (default) */ 
+#  endif 
+#endif 
+ 
+#if (DEBUGLEVEL>=2) 
 #  define ZSTD_DEPS_NEED_IO
 #  include "zstd_deps.h"
-extern int g_debuglevel; /* the variable is only declared,
-                            it actually lives in debug.c,
-                            and is shared by the whole process.
-                            It's not thread-safe.
-                            It's useful when enabling very verbose levels
-                            on selective conditions (such as position in src) */
-
+extern int g_debuglevel; /* the variable is only declared, 
+                            it actually lives in debug.c, 
+                            and is shared by the whole process. 
+                            It's not thread-safe. 
+                            It's useful when enabling very verbose levels 
+                            on selective conditions (such as position in src) */ 
+ 
 #  define RAWLOG(l, ...) {                                       \
                 if (l<=g_debuglevel) {                           \
                     ZSTD_DEBUG_PRINT(__VA_ARGS__);               \
-            }   }
+            }   } 
 #  define DEBUGLOG(l, ...) {                                     \
                 if (l<=g_debuglevel) {                           \
                     ZSTD_DEBUG_PRINT(__FILE__ ": " __VA_ARGS__); \
                     ZSTD_DEBUG_PRINT(" \n");                     \
-            }   }
-#else
-#  define RAWLOG(l, ...)      {}    /* disabled */
-#  define DEBUGLOG(l, ...)    {}    /* disabled */
-#endif
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* DEBUG_H_12987983217 */
+            }   } 
+#else 
+#  define RAWLOG(l, ...)      {}    /* disabled */ 
+#  define DEBUGLOG(l, ...)    {}    /* disabled */ 
+#endif 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* DEBUG_H_12987983217 */ 
diff --git a/contrib/libs/zstd/lib/common/entropy_common.c b/contrib/libs/zstd/lib/common/entropy_common.c
index 4229b40c5e..009a8d9c41 100644
--- a/contrib/libs/zstd/lib/common/entropy_common.c
+++ b/contrib/libs/zstd/lib/common/entropy_common.c
@@ -86,15 +86,15 @@ size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigne
         /* This function only works when hbSize >= 8 */
         char buffer[8] = {0};
         ZSTD_memcpy(buffer, headerBuffer, hbSize);
-        {   size_t const countSize = FSE_readNCount(normalizedCounter, maxSVPtr, tableLogPtr,
-                                                    buffer, sizeof(buffer));
-            if (FSE_isError(countSize)) return countSize;
-            if (countSize > hbSize) return ERROR(corruption_detected);
-            return countSize;
-    }   }
+        {   size_t const countSize = FSE_readNCount(normalizedCounter, maxSVPtr, tableLogPtr, 
+                                                    buffer, sizeof(buffer)); 
+            if (FSE_isError(countSize)) return countSize; 
+            if (countSize > hbSize) return ERROR(corruption_detected); 
+            return countSize; 
+    }   } 
     assert(hbSize >= 8);
-
-    /* init */
+ 
+    /* init */ 
     ZSTD_memset(normalizedCounter, 0, (*maxSVPtr+1) * sizeof(normalizedCounter[0]));   /* all symbols not present in NCount have a frequency of 0 */
     bitStream = MEM_readLE32(ip);
     nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */
@@ -146,7 +146,7 @@ size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigne
              */
 
             if (LIKELY(ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
-                assert((bitCount >> 3) <= 3); /* For first condition to work */
+                assert((bitCount >> 3) <= 3); /* For first condition to work */ 
                 ip += bitCount>>3;
                 bitCount &= 7;
             } else {
diff --git a/contrib/libs/zstd/lib/common/error_private.c b/contrib/libs/zstd/lib/common/error_private.c
index 6d1135f8c3..1a7b455f94 100644
--- a/contrib/libs/zstd/lib/common/error_private.c
+++ b/contrib/libs/zstd/lib/common/error_private.c
@@ -14,10 +14,10 @@
 
 const char* ERR_getErrorString(ERR_enum code)
 {
-#ifdef ZSTD_STRIP_ERROR_STRINGS
-    (void)code;
-    return "Error strings stripped";
-#else
+#ifdef ZSTD_STRIP_ERROR_STRINGS 
+    (void)code; 
+    return "Error strings stripped"; 
+#else 
     static const char* const notErrorCode = "Unspecified error code";
     switch( code )
     {
@@ -43,7 +43,7 @@ const char* ERR_getErrorString(ERR_enum code)
     case PREFIX(dictionaryCreation_failed): return "Cannot create Dictionary from provided samples";
     case PREFIX(dstSize_tooSmall): return "Destination buffer is too small";
     case PREFIX(srcSize_wrong): return "Src size is incorrect";
-    case PREFIX(dstBuffer_null): return "Operation on NULL destination buffer";
+    case PREFIX(dstBuffer_null): return "Operation on NULL destination buffer"; 
         /* following error codes are not stable and may be removed or changed in a future version */
     case PREFIX(frameIndex_tooLarge): return "Frame index is too large";
     case PREFIX(seekableIO): return "An I/O error occurred when reading/seeking";
@@ -52,5 +52,5 @@ const char* ERR_getErrorString(ERR_enum code)
     case PREFIX(maxCode):
     default: return notErrorCode;
     }
-#endif
+#endif 
 }
diff --git a/contrib/libs/zstd/lib/common/fse.h b/contrib/libs/zstd/lib/common/fse.h
index 714bfd3e7f..5c72feed69 100644
--- a/contrib/libs/zstd/lib/common/fse.h
+++ b/contrib/libs/zstd/lib/common/fse.h
@@ -52,7 +52,7 @@ extern "C" {
 #define FSE_VERSION_NUMBER  (FSE_VERSION_MAJOR *100*100 + FSE_VERSION_MINOR *100 + FSE_VERSION_RELEASE)
 FSE_PUBLIC_API unsigned FSE_versionNumber(void);   /**< library version number; to be used when checking dll version */
 
-
+ 
 /*-****************************************
 *  FSE simple functions
 ******************************************/
@@ -110,7 +110,7 @@ FSE_PUBLIC_API size_t FSE_compress2 (void* dst, size_t dstSize, const void* src,
 ******************************************/
 /*!
 FSE_compress() does the following:
-1. count symbol occurrence from source[] into table count[] (see hist.h)
+1. count symbol occurrence from source[] into table count[] (see hist.h) 
 2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog)
 3. save normalized counters to memory buffer using writeNCount()
 4. build encoding table 'CTable' from normalized counters
@@ -145,7 +145,7 @@ FSE_PUBLIC_API unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize
     Otherwise, useLowProbCount=1 is a good default, since the speed difference is small.
     @return : tableLog,
               or an errorCode, which can be tested using FSE_isError() */
-FSE_PUBLIC_API size_t FSE_normalizeCount(short* normalizedCounter, unsigned tableLog,
+FSE_PUBLIC_API size_t FSE_normalizeCount(short* normalizedCounter, unsigned tableLog, 
                     const unsigned* count, size_t srcSize, unsigned maxSymbolValue, unsigned useLowProbCount);
 
 /*! FSE_NCountWriteBound():
@@ -157,9 +157,9 @@ FSE_PUBLIC_API size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tab
     Compactly save 'normalizedCounter' into 'buffer'.
     @return : size of the compressed table,
               or an errorCode, which can be tested using FSE_isError(). */
-FSE_PUBLIC_API size_t FSE_writeNCount (void* buffer, size_t bufferSize,
-                                 const short* normalizedCounter,
-                                 unsigned maxSymbolValue, unsigned tableLog);
+FSE_PUBLIC_API size_t FSE_writeNCount (void* buffer, size_t bufferSize, 
+                                 const short* normalizedCounter, 
+                                 unsigned maxSymbolValue, unsigned tableLog); 
 
 /*! Constructor and Destructor of FSE_CTable.
     Note that FSE_CTable size depends on 'tableLog' and 'maxSymbolValue' */
@@ -230,9 +230,9 @@ If there is an error, the function will return an ErrorCode (which can be tested
     @return : size read from 'rBuffer',
               or an errorCode, which can be tested using FSE_isError().
               maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
-FSE_PUBLIC_API size_t FSE_readNCount (short* normalizedCounter,
-                           unsigned* maxSymbolValuePtr, unsigned* tableLogPtr,
-                           const void* rBuffer, size_t rBuffSize);
+FSE_PUBLIC_API size_t FSE_readNCount (short* normalizedCounter, 
+                           unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, 
+                           const void* rBuffer, size_t rBuffSize); 
 
 /*! FSE_readNCount_bmi2():
  * Same as FSE_readNCount() but pass bmi2=1 when your CPU supports BMI2 and 0 otherwise.
@@ -314,8 +314,8 @@ If there is an error, the function will return an error code, which can be teste
 
 
 /* *****************************************
- *  FSE advanced API
- ***************************************** */
+ *  FSE advanced API 
+ ***************************************** */ 
 
 unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus);
 /**< same as FSE_optimalTableLog(), which used `minus==2` */
@@ -364,7 +364,7 @@ size_t FSE_decompress_wksp_bmi2(void* dst, size_t dstCapacity, const void* cSrc,
 typedef enum {
    FSE_repeat_none,  /**< Cannot use the previous table */
    FSE_repeat_check, /**< Can use the previous table but it must be checked */
-   FSE_repeat_valid  /**< Can use the previous table and it is assumed to be valid */
+   FSE_repeat_valid  /**< Can use the previous table and it is assumed to be valid */ 
  } FSE_repeat;
 
 /* *****************************************
@@ -518,7 +518,7 @@ MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct)
     const U32 tableLog = MEM_read16(ptr);
     statePtr->value = (ptrdiff_t)1<<tableLog;
     statePtr->stateTable = u16ptr+2;
-    statePtr->symbolTT = ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1);
+    statePtr->symbolTT = ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1); 
     statePtr->stateLog = tableLog;
 }
 
@@ -537,7 +537,7 @@ MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U3
     }
 }
 
-MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, unsigned symbol)
+MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, unsigned symbol) 
 {
     FSE_symbolCompressionTransform const symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
     const U16* const stateTable = (const U16*)(statePtr->stateTable);
@@ -553,39 +553,39 @@ MEM_STATIC void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* statePt
 }
 
 
-/* FSE_getMaxNbBits() :
- * Approximate maximum cost of a symbol, in bits.
- * Fractional get rounded up (i.e : a symbol with a normalized frequency of 3 gives the same result as a frequency of 2)
- * note 1 : assume symbolValue is valid (<= maxSymbolValue)
- * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */
-MEM_STATIC U32 FSE_getMaxNbBits(const void* symbolTTPtr, U32 symbolValue)
-{
-    const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
-    return (symbolTT[symbolValue].deltaNbBits + ((1<<16)-1)) >> 16;
-}
-
-/* FSE_bitCost() :
- * Approximate symbol cost, as fractional value, using fixed-point format (accuracyLog fractional bits)
- * note 1 : assume symbolValue is valid (<= maxSymbolValue)
- * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */
-MEM_STATIC U32 FSE_bitCost(const void* symbolTTPtr, U32 tableLog, U32 symbolValue, U32 accuracyLog)
-{
-    const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;
-    U32 const minNbBits = symbolTT[symbolValue].deltaNbBits >> 16;
-    U32 const threshold = (minNbBits+1) << 16;
-    assert(tableLog < 16);
-    assert(accuracyLog < 31-tableLog);  /* ensure enough room for renormalization double shift */
-    {   U32 const tableSize = 1 << tableLog;
-        U32 const deltaFromThreshold = threshold - (symbolTT[symbolValue].deltaNbBits + tableSize);
-        U32 const normalizedDeltaFromThreshold = (deltaFromThreshold << accuracyLog) >> tableLog;   /* linear interpolation (very approximate) */
-        U32 const bitMultiplier = 1 << accuracyLog;
-        assert(symbolTT[symbolValue].deltaNbBits + tableSize <= threshold);
-        assert(normalizedDeltaFromThreshold <= bitMultiplier);
-        return (minNbBits+1)*bitMultiplier - normalizedDeltaFromThreshold;
-    }
-}
-
-
+/* FSE_getMaxNbBits() : 
+ * Approximate maximum cost of a symbol, in bits. 
+ * Fractional get rounded up (i.e : a symbol with a normalized frequency of 3 gives the same result as a frequency of 2) 
+ * note 1 : assume symbolValue is valid (<= maxSymbolValue) 
+ * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */ 
+MEM_STATIC U32 FSE_getMaxNbBits(const void* symbolTTPtr, U32 symbolValue) 
+{ 
+    const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr; 
+    return (symbolTT[symbolValue].deltaNbBits + ((1<<16)-1)) >> 16; 
+} 
+ 
+/* FSE_bitCost() : 
+ * Approximate symbol cost, as fractional value, using fixed-point format (accuracyLog fractional bits) 
+ * note 1 : assume symbolValue is valid (<= maxSymbolValue) 
+ * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */ 
+MEM_STATIC U32 FSE_bitCost(const void* symbolTTPtr, U32 tableLog, U32 symbolValue, U32 accuracyLog) 
+{ 
+    const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr; 
+    U32 const minNbBits = symbolTT[symbolValue].deltaNbBits >> 16; 
+    U32 const threshold = (minNbBits+1) << 16; 
+    assert(tableLog < 16); 
+    assert(accuracyLog < 31-tableLog);  /* ensure enough room for renormalization double shift */ 
+    {   U32 const tableSize = 1 << tableLog; 
+        U32 const deltaFromThreshold = threshold - (symbolTT[symbolValue].deltaNbBits + tableSize); 
+        U32 const normalizedDeltaFromThreshold = (deltaFromThreshold << accuracyLog) >> tableLog;   /* linear interpolation (very approximate) */ 
+        U32 const bitMultiplier = 1 << accuracyLog; 
+        assert(symbolTT[symbolValue].deltaNbBits + tableSize <= threshold); 
+        assert(normalizedDeltaFromThreshold <= bitMultiplier); 
+        return (minNbBits+1)*bitMultiplier - normalizedDeltaFromThreshold; 
+    } 
+} 
+ 
+ 
 /* ======    Decompression    ====== */
 
 typedef struct {
diff --git a/contrib/libs/zstd/lib/common/fse_decompress.c b/contrib/libs/zstd/lib/common/fse_decompress.c
index a5a358015f..c05f5cd103 100644
--- a/contrib/libs/zstd/lib/common/fse_decompress.c
+++ b/contrib/libs/zstd/lib/common/fse_decompress.c
@@ -30,7 +30,7 @@
 *  Error Management
 ****************************************************************/
 #define FSE_isError ERR_isError
-#define FSE_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)   /* use only *after* variable declarations */
+#define FSE_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)   /* use only *after* variable declarations */ 
 
 
 /* **************************************************************
diff --git a/contrib/libs/zstd/lib/common/huf.h b/contrib/libs/zstd/lib/common/huf.h
index 85518481ec..759b2d13d8 100644
--- a/contrib/libs/zstd/lib/common/huf.h
+++ b/contrib/libs/zstd/lib/common/huf.h
@@ -145,8 +145,8 @@ typedef size_t HUF_CElt;   /* consider it an incomplete type */
 /* static allocation of HUF's DTable */
 typedef U32 HUF_DTable;
 #define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<(maxTableLog)))
-#define HUF_CREATE_STATIC_DTABLEX1(DTable, maxTableLog) \
-        HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1) * 0x01000001) }
+#define HUF_CREATE_STATIC_DTABLEX1(DTable, maxTableLog) \ 
+        HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1) * 0x01000001) } 
 #define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
         HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) }
 
@@ -154,20 +154,20 @@ typedef U32 HUF_DTable;
 /* ****************************************
 *  Advanced decompression functions
 ******************************************/
-size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */
-#ifndef HUF_FORCE_DECOMPRESS_X1
-size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */
-#endif
+size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */ 
+#ifndef HUF_FORCE_DECOMPRESS_X1 
+size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */ 
+#endif 
 
 size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< decodes RLE and uncompressed */
 size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */
 size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< considers RLE and uncompressed as errors */
-size_t HUF_decompress4X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */
-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);   /**< single-symbol decoder */
-#ifndef HUF_FORCE_DECOMPRESS_X1
-size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */
-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);   /**< double-symbols decoder */
-#endif
+size_t HUF_decompress4X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */ 
+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);   /**< single-symbol decoder */ 
+#ifndef HUF_FORCE_DECOMPRESS_X1 
+size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */ 
+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);   /**< double-symbols decoder */ 
+#endif 
 
 
 /* ****************************************
@@ -197,7 +197,7 @@ int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned m
 typedef enum {
    HUF_repeat_none,  /**< Cannot use the previous table */
    HUF_repeat_check, /**< Can use the previous table but it must be checked. Note : The previous table must have been constructed by HUF_compress{1, 4}X_repeat */
-   HUF_repeat_valid  /**< Can use the previous table and it is assumed to be valid */
+   HUF_repeat_valid  /**< Can use the previous table and it is assumed to be valid */ 
  } HUF_repeat;
 /** HUF_compress4X_repeat() :
  *  Same as HUF_compress4X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none.
@@ -217,9 +217,9 @@ size_t HUF_compress4X_repeat(void* dst, size_t dstSize,
  */
 #define HUF_CTABLE_WORKSPACE_SIZE_U32 (2*HUF_SYMBOLVALUE_MAX +1 +1)
 #define HUF_CTABLE_WORKSPACE_SIZE (HUF_CTABLE_WORKSPACE_SIZE_U32 * sizeof(unsigned))
-size_t HUF_buildCTable_wksp (HUF_CElt* tree,
-                       const unsigned* count, U32 maxSymbolValue, U32 maxNbBits,
-                             void* workSpace, size_t wkspSize);
+size_t HUF_buildCTable_wksp (HUF_CElt* tree, 
+                       const unsigned* count, U32 maxSymbolValue, U32 maxNbBits, 
+                             void* workSpace, size_t wkspSize); 
 
 /*! HUF_readStats() :
  *  Read compact Huffman tree, saved by HUF_writeCTable().
@@ -248,13 +248,13 @@ size_t HUF_readStats_wksp(BYTE* huffWeight, size_t hwSize,
 size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize, unsigned *hasZeroWeights);
 
 /** HUF_getNbBitsFromCTable() :
- *  Read nbBits from CTable symbolTable, for symbol `symbolValue` presumed <= HUF_SYMBOLVALUE_MAX
+ *  Read nbBits from CTable symbolTable, for symbol `symbolValue` presumed <= HUF_SYMBOLVALUE_MAX 
  *  Note 1 : is not inlined, as HUF_CElt definition is private */
 U32 HUF_getNbBitsFromCTable(const HUF_CElt* symbolTable, U32 symbolValue);
 
 /*
  * HUF_decompress() does the following:
- * 1. select the decompression algorithm (X1, X2) based on pre-computed heuristics
+ * 1. select the decompression algorithm (X1, X2) based on pre-computed heuristics 
  * 2. build Huffman table from save, using HUF_readDTableX?()
  * 3. decode 1 or 4 segments in parallel using HUF_decompress?X?_usingDTable()
  */
@@ -262,13 +262,13 @@ U32 HUF_getNbBitsFromCTable(const HUF_CElt* symbolTable, U32 symbolValue);
 /** 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);
 
 /**
  *  The minimum workspace size for the `workSpace` used in
- *  HUF_readDTableX1_wksp() and HUF_readDTableX2_wksp().
+ *  HUF_readDTableX1_wksp() and HUF_readDTableX2_wksp(). 
  *
  *  The space used depends on HUF_TABLELOG_MAX, ranging from ~1500 bytes when
  *  HUF_TABLE_LOG_MAX=12 to ~1850 bytes when HUF_TABLE_LOG_MAX=15.
@@ -279,22 +279,22 @@ U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize);
 #define HUF_DECOMPRESS_WORKSPACE_SIZE ((2 << 10) + (1 << 9))
 #define HUF_DECOMPRESS_WORKSPACE_SIZE_U32 (HUF_DECOMPRESS_WORKSPACE_SIZE / sizeof(U32))
 
-#ifndef HUF_FORCE_DECOMPRESS_X2
-size_t HUF_readDTableX1 (HUF_DTable* DTable, const void* src, size_t srcSize);
-size_t HUF_readDTableX1_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize);
-#endif
-#ifndef HUF_FORCE_DECOMPRESS_X1
+#ifndef HUF_FORCE_DECOMPRESS_X2 
+size_t HUF_readDTableX1 (HUF_DTable* DTable, const void* src, size_t srcSize); 
+size_t HUF_readDTableX1_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize); 
+#endif 
+#ifndef HUF_FORCE_DECOMPRESS_X1 
 size_t HUF_readDTableX2 (HUF_DTable* DTable, const void* src, size_t srcSize);
 size_t HUF_readDTableX2_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize);
-#endif
+#endif 
 
 size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
-#ifndef HUF_FORCE_DECOMPRESS_X2
-size_t HUF_decompress4X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
-#endif
-#ifndef HUF_FORCE_DECOMPRESS_X1
+#ifndef HUF_FORCE_DECOMPRESS_X2 
+size_t HUF_decompress4X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); 
+#endif 
+#ifndef HUF_FORCE_DECOMPRESS_X1 
 size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
-#endif
+#endif 
 
 
 /* ====================== */
@@ -317,37 +317,37 @@ size_t HUF_compress1X_repeat(void* dst, size_t dstSize,
                        void* workSpace, size_t wkspSize,   /**< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */
                        HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2, unsigned suspectUncompressible);
 
-size_t HUF_decompress1X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
-#ifndef HUF_FORCE_DECOMPRESS_X1
-size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */
-#endif
+size_t HUF_decompress1X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */ 
+#ifndef HUF_FORCE_DECOMPRESS_X1 
+size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */ 
+#endif 
 
 size_t HUF_decompress1X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
 size_t HUF_decompress1X_DCtx_wksp (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize);
-#ifndef HUF_FORCE_DECOMPRESS_X2
-size_t HUF_decompress1X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */
-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);   /**< single-symbol decoder */
-#endif
-#ifndef HUF_FORCE_DECOMPRESS_X1
-size_t HUF_decompress1X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */
-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);   /**< double-symbols decoder */
-#endif
+#ifndef HUF_FORCE_DECOMPRESS_X2 
+size_t HUF_decompress1X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */ 
+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);   /**< single-symbol decoder */ 
+#endif 
+#ifndef HUF_FORCE_DECOMPRESS_X1 
+size_t HUF_decompress1X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */ 
+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);   /**< double-symbols decoder */ 
+#endif 
 
 size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);   /**< automatic selection of sing or double symbol decoder, based on DTable */
-#ifndef HUF_FORCE_DECOMPRESS_X2
-size_t HUF_decompress1X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
-#endif
-#ifndef HUF_FORCE_DECOMPRESS_X1
+#ifndef HUF_FORCE_DECOMPRESS_X2 
+size_t HUF_decompress1X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); 
+#endif 
+#ifndef HUF_FORCE_DECOMPRESS_X1 
 size_t HUF_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
-#endif
+#endif 
 
 /* BMI2 variants.
  * If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0.
  */
 size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2);
-#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);
-#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); 
+#endif 
 size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2);
 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);
 #ifndef HUF_FORCE_DECOMPRESS_X2
diff --git a/contrib/libs/zstd/lib/common/mem.h b/contrib/libs/zstd/lib/common/mem.h
index 85581c3847..c066849cf1 100644
--- a/contrib/libs/zstd/lib/common/mem.h
+++ b/contrib/libs/zstd/lib/common/mem.h
@@ -60,25 +60,25 @@ extern "C" {
   typedef  uint64_t U64;
   typedef   int64_t S64;
 #else
-# include <limits.h>
-#if CHAR_BIT != 8
-#  error "this implementation requires char to be exactly 8-bit type"
-#endif
+# include <limits.h> 
+#if CHAR_BIT != 8 
+#  error "this implementation requires char to be exactly 8-bit type" 
+#endif 
   typedef unsigned char      BYTE;
   typedef unsigned char      U8;
   typedef   signed char      S8;
-#if USHRT_MAX != 65535
-#  error "this implementation requires short to be exactly 16-bit type"
-#endif
+#if USHRT_MAX != 65535 
+#  error "this implementation requires short to be exactly 16-bit type" 
+#endif 
   typedef unsigned short      U16;
   typedef   signed short      S16;
-#if UINT_MAX != 4294967295
-#  error "this implementation requires int to be exactly 32-bit type"
-#endif
+#if UINT_MAX != 4294967295 
+#  error "this implementation requires int to be exactly 32-bit type" 
+#endif 
   typedef unsigned int        U32;
   typedef   signed int        S32;
-/* note : there are no limits defined for long long type in C90.
- * limits exist in C99, however, in such case, <stdint.h> is preferred */
+/* note : there are no limits defined for long long type in C90. 
+ * limits exist in C99, however, in such case, <stdint.h> is preferred */ 
   typedef unsigned long long  U64;
   typedef   signed long long  S64;
 #endif
@@ -261,8 +261,8 @@ MEM_STATIC U32 MEM_swap32(U32 in)
 {
 #if defined(_MSC_VER)     /* Visual Studio */
     return _byteswap_ulong(in);
-#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
-  || (defined(__clang__) && __has_builtin(__builtin_bswap32))
+#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \ 
+  || (defined(__clang__) && __has_builtin(__builtin_bswap32)) 
     return __builtin_bswap32(in);
 #else
     return  ((in << 24) & 0xff000000 ) |
@@ -276,8 +276,8 @@ MEM_STATIC U64 MEM_swap64(U64 in)
 {
 #if defined(_MSC_VER)     /* Visual Studio */
     return _byteswap_uint64(in);
-#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
-  || (defined(__clang__) && __has_builtin(__builtin_bswap64))
+#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \ 
+  || (defined(__clang__) && __has_builtin(__builtin_bswap64)) 
     return __builtin_bswap64(in);
 #else
     return  ((in << 56) & 0xff00000000000000ULL) |
diff --git a/contrib/libs/zstd/lib/common/pool.c b/contrib/libs/zstd/lib/common/pool.c
index 2e37cdd73c..c2ee120039 100644
--- a/contrib/libs/zstd/lib/common/pool.c
+++ b/contrib/libs/zstd/lib/common/pool.c
@@ -11,7 +11,7 @@
 
 /* ======   Dependencies   ======= */
 #include "zstd_deps.h" /* size_t */
-#include "debug.h"     /* assert */
+#include "debug.h"     /* assert */ 
 #include "zstd_internal.h"  /* ZSTD_customMalloc, ZSTD_customFree */
 #include "pool.h"
 
@@ -34,9 +34,9 @@ typedef struct POOL_job_s {
 struct POOL_ctx_s {
     ZSTD_customMem customMem;
     /* Keep track of the threads */
-    ZSTD_pthread_t* threads;
-    size_t threadCapacity;
-    size_t threadLimit;
+    ZSTD_pthread_t* threads; 
+    size_t threadCapacity; 
+    size_t threadLimit; 
 
     /* The queue is a circular buffer */
     POOL_job *queue;
@@ -60,10 +60,10 @@ struct POOL_ctx_s {
 };
 
 /* POOL_thread() :
- * Work thread for the thread pool.
- * Waits for jobs and executes them.
- * @returns : NULL on failure else non-null.
- */
+ * Work thread for the thread pool. 
+ * Waits for jobs and executes them. 
+ * @returns : NULL on failure else non-null. 
+ */ 
 static void* POOL_thread(void* opaque) {
     POOL_ctx* const ctx = (POOL_ctx*)opaque;
     if (!ctx) { return NULL; }
@@ -71,15 +71,15 @@ static void* POOL_thread(void* opaque) {
         /* Lock the mutex and wait for a non-empty queue or until shutdown */
         ZSTD_pthread_mutex_lock(&ctx->queueMutex);
 
-        while ( ctx->queueEmpty
-            || (ctx->numThreadsBusy >= ctx->threadLimit) ) {
-            if (ctx->shutdown) {
-                /* even if !queueEmpty, (possible if numThreadsBusy >= threadLimit),
-                 * a few threads will be shutdown while !queueEmpty,
-                 * but enough threads will remain active to finish the queue */
-                ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
-                return opaque;
-            }
+        while ( ctx->queueEmpty 
+            || (ctx->numThreadsBusy >= ctx->threadLimit) ) { 
+            if (ctx->shutdown) { 
+                /* even if !queueEmpty, (possible if numThreadsBusy >= threadLimit), 
+                 * a few threads will be shutdown while !queueEmpty, 
+                 * but enough threads will remain active to finish the queue */ 
+                ZSTD_pthread_mutex_unlock(&ctx->queueMutex); 
+                return opaque; 
+            } 
             ZSTD_pthread_cond_wait(&ctx->queuePopCond, &ctx->queueMutex);
         }
         /* Pop a job off the queue */
@@ -88,21 +88,21 @@ static void* POOL_thread(void* opaque) {
             ctx->numThreadsBusy++;
             ctx->queueEmpty = (ctx->queueHead == ctx->queueTail);
             /* Unlock the mutex, signal a pusher, and run the job */
-            ZSTD_pthread_cond_signal(&ctx->queuePushCond);
+            ZSTD_pthread_cond_signal(&ctx->queuePushCond); 
             ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
 
             job.function(job.opaque);
 
             /* If the intended queue size was 0, signal after finishing job */
-            ZSTD_pthread_mutex_lock(&ctx->queueMutex);
-            ctx->numThreadsBusy--;
+            ZSTD_pthread_mutex_lock(&ctx->queueMutex); 
+            ctx->numThreadsBusy--; 
             if (ctx->queueSize == 1) {
                 ZSTD_pthread_cond_signal(&ctx->queuePushCond);
-            }
-            ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
-        }
+            } 
+            ZSTD_pthread_mutex_unlock(&ctx->queueMutex); 
+        } 
     }  /* for (;;) */
-    assert(0);  /* Unreachable */
+    assert(0);  /* Unreachable */ 
 }
 
 /* ZSTD_createThreadPool() : public access point */
@@ -114,18 +114,18 @@ POOL_ctx* POOL_create(size_t numThreads, size_t queueSize) {
     return POOL_create_advanced(numThreads, queueSize, ZSTD_defaultCMem);
 }
 
-POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
+POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize, 
                                ZSTD_customMem customMem)
 {
     POOL_ctx* ctx;
-    /* Check parameters */
+    /* Check parameters */ 
     if (!numThreads) { return NULL; }
     /* Allocate the context and zero initialize */
     ctx = (POOL_ctx*)ZSTD_customCalloc(sizeof(POOL_ctx), customMem);
     if (!ctx) { return NULL; }
     /* Initialize the job queue.
-     * It needs one extra space since one space is wasted to differentiate
-     * empty and full queues.
+     * It needs one extra space since one space is wasted to differentiate 
+     * empty and full queues. 
      */
     ctx->queueSize = queueSize + 1;
     ctx->queue = (POOL_job*)ZSTD_customMalloc(ctx->queueSize * sizeof(POOL_job), customMem);
@@ -143,7 +143,7 @@ POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
     ctx->shutdown = 0;
     /* Allocate space for the thread handles */
     ctx->threads = (ZSTD_pthread_t*)ZSTD_customMalloc(numThreads * sizeof(ZSTD_pthread_t), customMem);
-    ctx->threadCapacity = 0;
+    ctx->threadCapacity = 0; 
     ctx->customMem = customMem;
     /* Check for errors */
     if (!ctx->threads || !ctx->queue) { POOL_free(ctx); return NULL; }
@@ -151,12 +151,12 @@ POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
     {   size_t i;
         for (i = 0; i < numThreads; ++i) {
             if (ZSTD_pthread_create(&ctx->threads[i], NULL, &POOL_thread, ctx)) {
-                ctx->threadCapacity = i;
+                ctx->threadCapacity = i; 
                 POOL_free(ctx);
                 return NULL;
         }   }
-        ctx->threadCapacity = numThreads;
-        ctx->threadLimit = numThreads;
+        ctx->threadCapacity = numThreads; 
+        ctx->threadLimit = numThreads; 
     }
     return ctx;
 }
@@ -174,8 +174,8 @@ static void POOL_join(POOL_ctx* ctx) {
     ZSTD_pthread_cond_broadcast(&ctx->queuePopCond);
     /* Join all of the threads */
     {   size_t i;
-        for (i = 0; i < ctx->threadCapacity; ++i) {
-            ZSTD_pthread_join(ctx->threads[i], NULL);  /* note : could fail */
+        for (i = 0; i < ctx->threadCapacity; ++i) { 
+            ZSTD_pthread_join(ctx->threads[i], NULL);  /* note : could fail */ 
     }   }
 }
 
@@ -193,67 +193,67 @@ void POOL_free(POOL_ctx *ctx) {
 void ZSTD_freeThreadPool (ZSTD_threadPool* pool) {
   POOL_free (pool);
 }
-
+ 
 size_t POOL_sizeof(const POOL_ctx* ctx) {
     if (ctx==NULL) return 0;  /* supports sizeof NULL */
     return sizeof(*ctx)
         + ctx->queueSize * sizeof(POOL_job)
-        + ctx->threadCapacity * sizeof(ZSTD_pthread_t);
+        + ctx->threadCapacity * sizeof(ZSTD_pthread_t); 
 }
 
-
-/* @return : 0 on success, 1 on error */
-static int POOL_resize_internal(POOL_ctx* ctx, size_t numThreads)
-{
-    if (numThreads <= ctx->threadCapacity) {
-        if (!numThreads) return 1;
-        ctx->threadLimit = numThreads;
-        return 0;
-    }
-    /* numThreads > threadCapacity */
+ 
+/* @return : 0 on success, 1 on error */ 
+static int POOL_resize_internal(POOL_ctx* ctx, size_t numThreads) 
+{ 
+    if (numThreads <= ctx->threadCapacity) { 
+        if (!numThreads) return 1; 
+        ctx->threadLimit = numThreads; 
+        return 0; 
+    } 
+    /* numThreads > threadCapacity */ 
     {   ZSTD_pthread_t* const threadPool = (ZSTD_pthread_t*)ZSTD_customMalloc(numThreads * sizeof(ZSTD_pthread_t), ctx->customMem);
-        if (!threadPool) return 1;
-        /* replace existing thread pool */
+        if (!threadPool) return 1; 
+        /* replace existing thread pool */ 
         ZSTD_memcpy(threadPool, ctx->threads, ctx->threadCapacity * sizeof(*threadPool));
         ZSTD_customFree(ctx->threads, ctx->customMem);
-        ctx->threads = threadPool;
-        /* Initialize additional threads */
-        {   size_t threadId;
-            for (threadId = ctx->threadCapacity; threadId < numThreads; ++threadId) {
-                if (ZSTD_pthread_create(&threadPool[threadId], NULL, &POOL_thread, ctx)) {
-                    ctx->threadCapacity = threadId;
-                    return 1;
-            }   }
-    }   }
-    /* successfully expanded */
-    ctx->threadCapacity = numThreads;
-    ctx->threadLimit = numThreads;
-    return 0;
-}
-
-/* @return : 0 on success, 1 on error */
-int POOL_resize(POOL_ctx* ctx, size_t numThreads)
-{
-    int result;
-    if (ctx==NULL) return 1;
-    ZSTD_pthread_mutex_lock(&ctx->queueMutex);
-    result = POOL_resize_internal(ctx, numThreads);
-    ZSTD_pthread_cond_broadcast(&ctx->queuePopCond);
-    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);
-    return result;
-}
-
+        ctx->threads = threadPool; 
+        /* Initialize additional threads */ 
+        {   size_t threadId; 
+            for (threadId = ctx->threadCapacity; threadId < numThreads; ++threadId) { 
+                if (ZSTD_pthread_create(&threadPool[threadId], NULL, &POOL_thread, ctx)) { 
+                    ctx->threadCapacity = threadId; 
+                    return 1; 
+            }   } 
+    }   } 
+    /* successfully expanded */ 
+    ctx->threadCapacity = numThreads; 
+    ctx->threadLimit = numThreads; 
+    return 0; 
+} 
+ 
+/* @return : 0 on success, 1 on error */ 
+int POOL_resize(POOL_ctx* ctx, size_t numThreads) 
+{ 
+    int result; 
+    if (ctx==NULL) return 1; 
+    ZSTD_pthread_mutex_lock(&ctx->queueMutex); 
+    result = POOL_resize_internal(ctx, numThreads); 
+    ZSTD_pthread_cond_broadcast(&ctx->queuePopCond); 
+    ZSTD_pthread_mutex_unlock(&ctx->queueMutex); 
+    return result; 
+} 
+ 
 /**
  * Returns 1 if the queue is full and 0 otherwise.
  *
- * When queueSize is 1 (pool was created with an intended queueSize of 0),
- * then a queue is empty if there is a thread free _and_ no job is waiting.
+ * When queueSize is 1 (pool was created with an intended queueSize of 0), 
+ * then a queue is empty if there is a thread free _and_ no job is waiting. 
  */
 static int isQueueFull(POOL_ctx const* ctx) {
     if (ctx->queueSize > 1) {
         return ctx->queueHead == ((ctx->queueTail + 1) % ctx->queueSize);
     } else {
-        return (ctx->numThreadsBusy == ctx->threadLimit) ||
+        return (ctx->numThreadsBusy == ctx->threadLimit) || 
                !ctx->queueEmpty;
     }
 }
@@ -330,11 +330,11 @@ void POOL_free(POOL_ctx* ctx) {
     (void)ctx;
 }
 
-int POOL_resize(POOL_ctx* ctx, size_t numThreads) {
-    (void)ctx; (void)numThreads;
-    return 0;
-}
-
+int POOL_resize(POOL_ctx* ctx, size_t numThreads) { 
+    (void)ctx; (void)numThreads; 
+    return 0; 
+} 
+ 
 void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque) {
     (void)ctx;
     function(opaque);
diff --git a/contrib/libs/zstd/lib/common/pool.h b/contrib/libs/zstd/lib/common/pool.h
index 0ebde1805d..0fcfe6f858 100644
--- a/contrib/libs/zstd/lib/common/pool.h
+++ b/contrib/libs/zstd/lib/common/pool.h
@@ -30,50 +30,50 @@ typedef struct POOL_ctx_s POOL_ctx;
 */
 POOL_ctx* POOL_create(size_t numThreads, size_t queueSize);
 
-POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,
-                               ZSTD_customMem customMem);
+POOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize, 
+                               ZSTD_customMem customMem); 
 
 /*! POOL_free() :
- *  Free a thread pool returned by POOL_create().
- */
+ *  Free a thread pool returned by POOL_create(). 
+ */ 
 void POOL_free(POOL_ctx* ctx);
 
-/*! POOL_resize() :
- *  Expands or shrinks pool's number of threads.
- *  This is more efficient than releasing + creating a new context,
- *  since it tries to preserve and re-use existing threads.
- * `numThreads` must be at least 1.
- * @return : 0 when resize was successful,
- *           !0 (typically 1) if there is an error.
- *    note : only numThreads can be resized, queueSize remains unchanged.
- */
-int POOL_resize(POOL_ctx* ctx, size_t numThreads);
-
+/*! POOL_resize() : 
+ *  Expands or shrinks pool's number of threads. 
+ *  This is more efficient than releasing + creating a new context, 
+ *  since it tries to preserve and re-use existing threads. 
+ * `numThreads` must be at least 1. 
+ * @return : 0 when resize was successful, 
+ *           !0 (typically 1) if there is an error. 
+ *    note : only numThreads can be resized, queueSize remains unchanged. 
+ */ 
+int POOL_resize(POOL_ctx* ctx, size_t numThreads); 
+ 
 /*! POOL_sizeof() :
- * @return threadpool memory usage
- *  note : compatible with NULL (returns 0 in this case)
- */
+ * @return threadpool memory usage 
+ *  note : compatible with NULL (returns 0 in this case) 
+ */ 
 size_t POOL_sizeof(const POOL_ctx* ctx);
 
 /*! POOL_function :
- *  The function type that can be added to a thread pool.
- */
+ *  The function type that can be added to a thread pool. 
+ */ 
 typedef void (*POOL_function)(void*);
 
 /*! POOL_add() :
- *  Add the job `function(opaque)` to the thread pool. `ctx` must be valid.
- *  Possibly blocks until there is room in the queue.
- *  Note : The function may be executed asynchronously,
- *         therefore, `opaque` must live until function has been completed.
- */
+ *  Add the job `function(opaque)` to the thread pool. `ctx` must be valid. 
+ *  Possibly blocks until there is room in the queue. 
+ *  Note : The function may be executed asynchronously, 
+ *         therefore, `opaque` must live until function has been completed. 
+ */ 
 void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque);
 
 
 /*! POOL_tryAdd() :
  *  Add the job `function(opaque)` to thread pool _if_ a queue slot is available.
- *  Returns immediately even if not (does not block).
- * @return : 1 if successful, 0 if not.
- */
+ *  Returns immediately even if not (does not block). 
+ * @return : 1 if successful, 0 if not. 
+ */ 
 int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque);
 
 
diff --git a/contrib/libs/zstd/lib/common/threading.c b/contrib/libs/zstd/lib/common/threading.c
index 92cf57c195..3983013f45 100644
--- a/contrib/libs/zstd/lib/common/threading.c
+++ b/contrib/libs/zstd/lib/common/threading.c
@@ -17,8 +17,8 @@
 
 #include "threading.h"
 
-/* create fake symbol to avoid empty translation unit warning */
-int g_ZSTD_threading_useless_symbol;
+/* create fake symbol to avoid empty translation unit warning */ 
+int g_ZSTD_threading_useless_symbol; 
 
 #if defined(ZSTD_MULTITHREAD) && defined(_WIN32)
 
diff --git a/contrib/libs/zstd/lib/common/zstd_common.c b/contrib/libs/zstd/lib/common/zstd_common.c
index 3d7e35b309..afae38e72c 100644
--- a/contrib/libs/zstd/lib/common/zstd_common.c
+++ b/contrib/libs/zstd/lib/common/zstd_common.c
@@ -30,10 +30,10 @@ const char* ZSTD_versionString(void) { return ZSTD_VERSION_STRING; }
 /*-****************************************
 *  ZSTD Error Management
 ******************************************/
-#undef ZSTD_isError   /* defined within zstd_internal.h */
+#undef ZSTD_isError   /* defined within zstd_internal.h */ 
 /*! ZSTD_isError() :
- *  tells if a return value is an error code
- *  symbol is required for external callers */
+ *  tells if a return value is an error code 
+ *  symbol is required for external callers */ 
 unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }
 
 /*! ZSTD_getErrorName() :
diff --git a/contrib/libs/zstd/lib/common/zstd_internal.h b/contrib/libs/zstd/lib/common/zstd_internal.h
index 1dee37cdbe..6fc7ff0fc9 100644
--- a/contrib/libs/zstd/lib/common/zstd_internal.h
+++ b/contrib/libs/zstd/lib/common/zstd_internal.h
@@ -22,7 +22,7 @@
 #include "compiler.h"
 #include "cpu.h"
 #include "mem.h"
-#include "debug.h"                 /* assert, DEBUGLOG, RAWLOG, g_debuglevel */
+#include "debug.h"                 /* assert, DEBUGLOG, RAWLOG, g_debuglevel */ 
 #include "error_private.h"
 #define ZSTD_STATIC_LINKING_ONLY
 #include "../zstd.h"
@@ -44,11 +44,11 @@
 extern "C" {
 #endif
 
-/* ---- static assert (debug) --- */
-#define ZSTD_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)
-#define ZSTD_isError ERR_isError   /* for inlining */
-#define FSE_isError  ERR_isError
-#define HUF_isError  ERR_isError
+/* ---- static assert (debug) --- */ 
+#define ZSTD_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c) 
+#define ZSTD_isError ERR_isError   /* for inlining */ 
+#define FSE_isError  ERR_isError 
+#define HUF_isError  ERR_isError 
 
 
 /*-*************************************
@@ -84,7 +84,7 @@ static UNUSED_ATTR const U32 repStartValue[ZSTD_REP_NUM] = { 1, 4, 8 };
 static UNUSED_ATTR const size_t ZSTD_fcs_fieldSize[4] = { 0, 2, 4, 8 };
 static UNUSED_ATTR const size_t ZSTD_did_fieldSize[4] = { 0, 1, 2, 4 };
 
-#define ZSTD_FRAMEIDSIZE 4   /* magic number size */
+#define ZSTD_FRAMEIDSIZE 4   /* magic number size */ 
 
 #define ZSTD_BLOCKHEADERSIZE 3   /* C standard doesn't allow `static const` variable to be init using another `static const` variable */
 static UNUSED_ATTR const size_t ZSTD_blockHeaderSize = ZSTD_BLOCKHEADERSIZE;
@@ -304,8 +304,8 @@ typedef struct {
     BYTE* llCode;
     BYTE* mlCode;
     BYTE* ofCode;
-    size_t maxNbSeq;
-    size_t maxNbLit;
+    size_t maxNbSeq; 
+    size_t maxNbLit; 
 
     /* longLengthPos and longLengthType to allow us to represent either a single litLength or matchLength
      * in the seqStore that has a value larger than U16 (if it exists). To do so, we increment
@@ -320,7 +320,7 @@ typedef struct {
     U32 matchLength;
 } ZSTD_sequenceLength;
 
-/**
+/** 
  * Returns the ZSTD_sequenceLength for the given sequences. It handles the decoding of long sequences
  * indicated by longLengthPos and longLengthType, and adds MINMATCH back to matchLength.
  */
@@ -341,16 +341,16 @@ MEM_STATIC ZSTD_sequenceLength ZSTD_getSequenceLength(seqStore_t const* seqStore
 }
 
 /**
- * Contains the compressed frame size and an upper-bound for the decompressed frame size.
- * Note: before using `compressedSize`, check for errors using ZSTD_isError().
- *       similarly, before using `decompressedBound`, check for errors using:
- *          `decompressedBound != ZSTD_CONTENTSIZE_ERROR`
- */
-typedef struct {
-    size_t compressedSize;
-    unsigned long long decompressedBound;
-} ZSTD_frameSizeInfo;   /* decompress & legacy */
-
+ * Contains the compressed frame size and an upper-bound for the decompressed frame size. 
+ * Note: before using `compressedSize`, check for errors using ZSTD_isError(). 
+ *       similarly, before using `decompressedBound`, check for errors using: 
+ *          `decompressedBound != ZSTD_CONTENTSIZE_ERROR` 
+ */ 
+typedef struct { 
+    size_t compressedSize; 
+    unsigned long long decompressedBound; 
+} ZSTD_frameSizeInfo;   /* decompress & legacy */ 
+ 
 const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx);   /* compress & dictBuilder */
 void ZSTD_seqToCodes(const seqStore_t* seqStorePtr);   /* compress, dictBuilder, decodeCorpus (shouldn't get its definition from here) */
 
@@ -463,7 +463,7 @@ typedef struct {
     blockType_e blockType;
     U32 lastBlock;
     U32 origSize;
-} blockProperties_t;   /* declared here for decompress and fullbench */
+} blockProperties_t;   /* declared here for decompress and fullbench */ 
 
 /*! ZSTD_getcBlockSize() :
  *  Provides the size of compressed block from block header `src` */
@@ -471,12 +471,12 @@ typedef struct {
 size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
                           blockProperties_t* bpPtr);
 
-/*! ZSTD_decodeSeqHeaders() :
- *  decode sequence header from src */
-/* Used by: decompress, fullbench (does not get its definition from here) */
-size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
-                       const void* src, size_t srcSize);
-
+/*! ZSTD_decodeSeqHeaders() : 
+ *  decode sequence header from src */ 
+/* Used by: decompress, fullbench (does not get its definition from here) */ 
+size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr, 
+                       const void* src, size_t srcSize); 
+ 
 /**
  * @returns true iff the CPU supports dynamic BMI2 dispatch.
  */
@@ -485,7 +485,7 @@ MEM_STATIC int ZSTD_cpuSupportsBmi2(void)
     ZSTD_cpuid_t cpuid = ZSTD_cpuid();
     return ZSTD_cpuid_bmi1(cpuid) && ZSTD_cpuid_bmi2(cpuid);
 }
-
+ 
 #if defined (__cplusplus)
 }
 #endif