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

18 files changed, 2270 insertions, 2270 deletions

diff --git a/contrib/libs/zstd06/common/bitstream.h b/contrib/libs/zstd06/common/bitstream.h
index 97fc621579..ae1071a6d3 100644
--- a/contrib/libs/zstd06/common/bitstream.h
+++ b/contrib/libs/zstd06/common/bitstream.h
@@ -1,4 +1,4 @@
-#include <contrib/libs/zstd06/renames.h>
+#include <contrib/libs/zstd06/renames.h> 
 /* ******************************************************************
    bitstream
    Part of FSE library
@@ -85,7 +85,7 @@ MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC);
 
 /* Start with initCStream, providing the size of buffer to write into.
 *  bitStream will never write outside of this buffer.
-*  `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code.
+*  `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code. 
 *
 *  bits are first added to a local register.
 *  Local register is size_t, hence 64-bits on 64-bits systems, or 32-bits on 32-bits systems.
@@ -129,7 +129,7 @@ MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
 *  Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
 *  You can then retrieve bitFields stored into the local register, **in reverse order**.
 *  Local register is explicitly reloaded from memory by the BIT_reloadDStream() method.
-*  A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished.
+*  A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished. 
 *  Otherwise, it can be less than that, so proceed accordingly.
 *  Checking if DStream has reached its end can be performed with BIT_endOfDStream().
 */
@@ -264,9 +264,9 @@ MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, si
 {
     if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
 
-    if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */
+    if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */ 
         bitD->start = (const char*)srcBuffer;
-        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer); 
         bitD->bitContainer = MEM_readLEST(bitD->ptr);
         { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
           if (lastByte == 0) return ERROR(GENERIC);   /* endMark not present */
@@ -277,58 +277,58 @@ MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, si
         bitD->bitContainer = *(const BYTE*)(bitD->start);
         switch(srcSize)
         {
-            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
-            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
-            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
-            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24;
-            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16;
-            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) <<  8;
+            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16); 
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24); 
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32); 
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24; 
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; 
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) <<  8; 
             default:;
         }
         { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
           if (lastByte == 0) return ERROR(GENERIC);   /* endMark not present */
           bitD->bitsConsumed = 8 - BIT_highbit32(lastByte); }
-        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
+        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; 
     }
 
     return srcSize;
 }
 
-MEM_STATIC size_t BIT_getUpperBits(size_t bitContainer, U32 const start)
+MEM_STATIC size_t BIT_getUpperBits(size_t bitContainer, U32 const start) 
 {
-    return bitContainer >> start;
+    return bitContainer >> start; 
 }
 
-MEM_STATIC size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 const nbBits)
+MEM_STATIC size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 const nbBits) 
 {
 #if defined(__BMI__) && defined(__GNUC__)   /* experimental */
-#  if defined(__x86_64__)
-    if (sizeof(bitContainer)==8)
-        return _bextr_u64(bitContainer, start, nbBits);
-    else
-#  endif
-        return _bextr_u32(bitContainer, start, nbBits);
+#  if defined(__x86_64__) 
+    if (sizeof(bitContainer)==8) 
+        return _bextr_u64(bitContainer, start, nbBits); 
+    else 
+#  endif 
+        return _bextr_u32(bitContainer, start, nbBits); 
 #else
-    return (bitContainer >> start) & BIT_mask[nbBits];
+    return (bitContainer >> start) & BIT_mask[nbBits]; 
 #endif
 }
 
-MEM_STATIC size_t BIT_getLowerBits(size_t bitContainer, U32 const nbBits)
+MEM_STATIC size_t BIT_getLowerBits(size_t bitContainer, U32 const nbBits) 
 {
-    return bitContainer & BIT_mask[nbBits];
+    return bitContainer & BIT_mask[nbBits]; 
 }
 
 /*! BIT_lookBits() :
  *  Provides next n bits from local register.
- *  local register is not modified.
+ *  local register is not modified. 
  *  On 32-bits, maxNbBits==24.
  *  On 64-bits, maxNbBits==56.
  *  @return : value extracted
  */
  MEM_STATIC size_t BIT_lookBits(const BIT_DStream_t* bitD, U32 nbBits)
 {
-#if defined(__BMI__) && defined(__GNUC__)   /* experimental; fails if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8 */
-    return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
+#if defined(__BMI__) && defined(__GNUC__)   /* experimental; fails if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8 */ 
+    return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); 
 #else
     U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;
     return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
@@ -373,7 +373,7 @@ MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)
 *   Refill `BIT_DStream_t` from src buffer previously defined (see BIT_initDStream() ).
 *   This function is safe, it guarantees it will not read beyond src buffer.
 *   @return : status of `BIT_DStream_t` internal register.
-              if status == unfinished, internal register is filled with >= (sizeof(bitD->bitContainer)*8 - 7) bits */
+              if status == unfinished, internal register is filled with >= (sizeof(bitD->bitContainer)*8 - 7) bits */ 
 MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
 {
 	if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
diff --git a/contrib/libs/zstd06/common/entropy_common.c b/contrib/libs/zstd06/common/entropy_common.c
index b4c366e61a..f8c957736a 100644
--- a/contrib/libs/zstd06/common/entropy_common.c
+++ b/contrib/libs/zstd06/common/entropy_common.c
@@ -1,158 +1,158 @@
-/*
-   Common functions of New Generation Entropy library
-   Copyright (C) 2016, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    You can contact the author at :
-    - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
-    - Public forum : https://groups.google.com/forum/#!forum/lz4c
-*************************************************************************** */
-
-/* *************************************
-*  Dependencies
-***************************************/
-#include <stdlib.h>
-#include "mem.h"
-#include "fse_static.h"  /* FSE_MIN_TABLELOG */
-#include "error_private.h"
-#include "fse.h" /* declaration of FSE_isError, FSE_getErrorName */
-#include "huf.h" /* declaration of HUF_isError, HUF_getErrorName */
-
-
-
-/*-****************************************
-*  FSE Error Management
-******************************************/
-unsigned FSE_isError(size_t code) { return ERR_isError(code); }
-
-const char* FSE_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-
-/* **************************************************************
-*  HUF Error Management
-****************************************************************/
-unsigned HUF_isError(size_t code) { return ERR_isError(code); }
-
-const char* HUF_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-
-/*-**************************************************************
-*  FSE NCount encoding-decoding
-****************************************************************/
-static short FSE_abs(short a) { return a<0 ? -a : a; }
-
-size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
-                 const void* headerBuffer, size_t hbSize)
-{
-    const BYTE* const istart = (const BYTE*) headerBuffer;
-    const BYTE* const iend = istart + hbSize;
-    const BYTE* ip = istart;
-    int nbBits;
-    int remaining;
-    int threshold;
-    U32 bitStream;
-    int bitCount;
-    unsigned charnum = 0;
-    int previous0 = 0;
-
-    if (hbSize < 4) return ERROR(srcSize_wrong);
-    bitStream = MEM_readLE32(ip);
-    nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */
-    if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
-    bitStream >>= 4;
-    bitCount = 4;
-    *tableLogPtr = nbBits;
-    remaining = (1<<nbBits)+1;
-    threshold = 1<<nbBits;
-    nbBits++;
-
-    while ((remaining>1) && (charnum<=*maxSVPtr)) {
-        if (previous0) {
-            unsigned n0 = charnum;
-            while ((bitStream & 0xFFFF) == 0xFFFF) {
-                n0+=24;
-                if (ip < iend-5) {
-                    ip+=2;
-                    bitStream = MEM_readLE32(ip) >> bitCount;
-                } else {
-                    bitStream >>= 16;
-                    bitCount+=16;
-            }   }
-            while ((bitStream & 3) == 3) {
-                n0+=3;
-                bitStream>>=2;
-                bitCount+=2;
-            }
-            n0 += bitStream & 3;
-            bitCount += 2;
-            if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);
-            while (charnum < n0) normalizedCounter[charnum++] = 0;
-            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
-                ip += bitCount>>3;
-                bitCount &= 7;
-                bitStream = MEM_readLE32(ip) >> bitCount;
-            }
-            else
-                bitStream >>= 2;
-        }
-        {   short const max = (short)((2*threshold-1)-remaining);
-            short count;
-
-            if ((bitStream & (threshold-1)) < (U32)max) {
-                count = (short)(bitStream & (threshold-1));
-                bitCount   += nbBits-1;
-            } else {
-                count = (short)(bitStream & (2*threshold-1));
-                if (count >= threshold) count -= max;
-                bitCount   += nbBits;
-            }
-
-            count--;   /* extra accuracy */
-            remaining -= FSE_abs(count);
-            normalizedCounter[charnum++] = count;
-            previous0 = !count;
-            while (remaining < threshold) {
-                nbBits--;
-                threshold >>= 1;
-            }
-
-            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
-                ip += bitCount>>3;
-                bitCount &= 7;
-            } else {
-                bitCount -= (int)(8 * (iend - 4 - ip));
-                ip = iend - 4;
-            }
-            bitStream = MEM_readLE32(ip) >> (bitCount & 31);
-    }   }   /* while ((remaining>1) && (charnum<=*maxSVPtr)) */
-    if (remaining != 1) return ERROR(GENERIC);
-    *maxSVPtr = charnum-1;
-
-    ip += (bitCount+7)>>3;
-    if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);
-    return ip-istart;
-}
+/* 
+   Common functions of New Generation Entropy library 
+   Copyright (C) 2016, Yann Collet. 
+ 
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+   Redistribution and use in source and binary forms, with or without 
+   modification, are permitted provided that the following conditions are 
+   met: 
+ 
+       * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer. 
+       * Redistributions in binary form must reproduce the above 
+   copyright notice, this list of conditions and the following disclaimer 
+   in the documentation and/or other materials provided with the 
+   distribution. 
+ 
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+    You can contact the author at : 
+    - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+*************************************************************************** */ 
+ 
+/* ************************************* 
+*  Dependencies 
+***************************************/ 
+#include <stdlib.h> 
+#include "mem.h" 
+#include "fse_static.h"  /* FSE_MIN_TABLELOG */ 
+#include "error_private.h" 
+#include "fse.h" /* declaration of FSE_isError, FSE_getErrorName */ 
+#include "huf.h" /* declaration of HUF_isError, HUF_getErrorName */ 
+ 
+ 
+ 
+/*-**************************************** 
+*  FSE Error Management 
+******************************************/ 
+unsigned FSE_isError(size_t code) { return ERR_isError(code); } 
+ 
+const char* FSE_getErrorName(size_t code) { return ERR_getErrorName(code); } 
+ 
+ 
+/* ************************************************************** 
+*  HUF Error Management 
+****************************************************************/ 
+unsigned HUF_isError(size_t code) { return ERR_isError(code); } 
+ 
+const char* HUF_getErrorName(size_t code) { return ERR_getErrorName(code); } 
+ 
+ 
+/*-************************************************************** 
+*  FSE NCount encoding-decoding 
+****************************************************************/ 
+static short FSE_abs(short a) { return a<0 ? -a : a; } 
+ 
+size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr, 
+                 const void* headerBuffer, size_t hbSize) 
+{ 
+    const BYTE* const istart = (const BYTE*) headerBuffer; 
+    const BYTE* const iend = istart + hbSize; 
+    const BYTE* ip = istart; 
+    int nbBits; 
+    int remaining; 
+    int threshold; 
+    U32 bitStream; 
+    int bitCount; 
+    unsigned charnum = 0; 
+    int previous0 = 0; 
+ 
+    if (hbSize < 4) return ERROR(srcSize_wrong); 
+    bitStream = MEM_readLE32(ip); 
+    nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */ 
+    if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge); 
+    bitStream >>= 4; 
+    bitCount = 4; 
+    *tableLogPtr = nbBits; 
+    remaining = (1<<nbBits)+1; 
+    threshold = 1<<nbBits; 
+    nbBits++; 
+ 
+    while ((remaining>1) && (charnum<=*maxSVPtr)) { 
+        if (previous0) { 
+            unsigned n0 = charnum; 
+            while ((bitStream & 0xFFFF) == 0xFFFF) { 
+                n0+=24; 
+                if (ip < iend-5) { 
+                    ip+=2; 
+                    bitStream = MEM_readLE32(ip) >> bitCount; 
+                } else { 
+                    bitStream >>= 16; 
+                    bitCount+=16; 
+            }   } 
+            while ((bitStream & 3) == 3) { 
+                n0+=3; 
+                bitStream>>=2; 
+                bitCount+=2; 
+            } 
+            n0 += bitStream & 3; 
+            bitCount += 2; 
+            if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall); 
+            while (charnum < n0) normalizedCounter[charnum++] = 0; 
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { 
+                ip += bitCount>>3; 
+                bitCount &= 7; 
+                bitStream = MEM_readLE32(ip) >> bitCount; 
+            } 
+            else 
+                bitStream >>= 2; 
+        } 
+        {   short const max = (short)((2*threshold-1)-remaining); 
+            short count; 
+ 
+            if ((bitStream & (threshold-1)) < (U32)max) { 
+                count = (short)(bitStream & (threshold-1)); 
+                bitCount   += nbBits-1; 
+            } else { 
+                count = (short)(bitStream & (2*threshold-1)); 
+                if (count >= threshold) count -= max; 
+                bitCount   += nbBits; 
+            } 
+ 
+            count--;   /* extra accuracy */ 
+            remaining -= FSE_abs(count); 
+            normalizedCounter[charnum++] = count; 
+            previous0 = !count; 
+            while (remaining < threshold) { 
+                nbBits--; 
+                threshold >>= 1; 
+            } 
+ 
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { 
+                ip += bitCount>>3; 
+                bitCount &= 7; 
+            } else { 
+                bitCount -= (int)(8 * (iend - 4 - ip)); 
+                ip = iend - 4; 
+            } 
+            bitStream = MEM_readLE32(ip) >> (bitCount & 31); 
+    }   }   /* while ((remaining>1) && (charnum<=*maxSVPtr)) */ 
+    if (remaining != 1) return ERROR(GENERIC); 
+    *maxSVPtr = charnum-1; 
+ 
+    ip += (bitCount+7)>>3; 
+    if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong); 
+    return ip-istart; 
+} 
diff --git a/contrib/libs/zstd06/common/error_private.h b/contrib/libs/zstd06/common/error_private.h
index d8d1ef24b3..c423dddfe9 100644
--- a/contrib/libs/zstd06/common/error_private.h
+++ b/contrib/libs/zstd06/common/error_private.h
@@ -1,4 +1,4 @@
-#include <contrib/libs/zstd06/renames.h>
+#include <contrib/libs/zstd06/renames.h> 
 /* ******************************************************************
    Error codes and messages
    Copyright (C) 2013-2016, Yann Collet
@@ -79,17 +79,17 @@ typedef ZSTD_ErrorCode ERR_enum;
 
 ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }
 
-ERR_STATIC ERR_enum ERR_getErrorCode(size_t code) { if (!ERR_isError(code)) return (ERR_enum)0; return (ERR_enum) (0-code); }
+ERR_STATIC ERR_enum ERR_getErrorCode(size_t code) { if (!ERR_isError(code)) return (ERR_enum)0; return (ERR_enum) (0-code); } 
 
 
 /*-****************************************
 *  Error Strings
 ******************************************/
 
-ERR_STATIC const char* ERR_getErrorString(ERR_enum code)
+ERR_STATIC const char* ERR_getErrorString(ERR_enum code) 
 {
     static const char* notErrorCode = "Unspecified error code";
-    switch( code )
+    switch( code ) 
     {
     case PREFIX(no_error): return "No error detected";
     case PREFIX(GENERIC):  return "Error (generic)";
@@ -108,14 +108,14 @@ ERR_STATIC const char* ERR_getErrorString(ERR_enum code)
     case PREFIX(maxSymbolValue_tooSmall): return "Specified maxSymbolValue is too small";
     case PREFIX(dictionary_corrupted): return "Dictionary is corrupted";
     case PREFIX(maxCode):
-    default: return notErrorCode;
+    default: return notErrorCode; 
     }
 }
 
-ERR_STATIC const char* ERR_getErrorName(size_t code)
-{
-    return ERR_getErrorString(ERR_getErrorCode(code));
-}
+ERR_STATIC const char* ERR_getErrorName(size_t code) 
+{ 
+    return ERR_getErrorString(ERR_getErrorCode(code)); 
+} 
 
 #if defined (__cplusplus)
 }
diff --git a/contrib/libs/zstd06/common/error_public.h b/contrib/libs/zstd06/common/error_public.h
index 1d8f03995f..e9ce5a9f09 100644
--- a/contrib/libs/zstd06/common/error_public.h
+++ b/contrib/libs/zstd06/common/error_public.h
@@ -1,4 +1,4 @@
-#include <contrib/libs/zstd06/renames.h>
+#include <contrib/libs/zstd06/renames.h> 
 /* ******************************************************************
    Error codes list
    Copyright (C) 2016, Yann Collet
diff --git a/contrib/libs/zstd06/common/fse.h b/contrib/libs/zstd06/common/fse.h
index 1cc6992951..942e8d79a2 100644
--- a/contrib/libs/zstd06/common/fse.h
+++ b/contrib/libs/zstd06/common/fse.h
@@ -1,4 +1,4 @@
-#include <contrib/libs/zstd06/renames.h>
+#include <contrib/libs/zstd06/renames.h> 
 /* ******************************************************************
    FSE : Finite State Entropy codec
    Public Prototypes declaration
diff --git a/contrib/libs/zstd06/common/fse_decompress.c b/contrib/libs/zstd06/common/fse_decompress.c
index 601edd7417..db6378a610 100644
--- a/contrib/libs/zstd06/common/fse_decompress.c
+++ b/contrib/libs/zstd06/common/fse_decompress.c
@@ -1,330 +1,330 @@
-/* ******************************************************************
-   FSE : Finite State Entropy decoder
-   Copyright (C) 2013-2015, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    You can contact the author at :
-    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
-    - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-
-
-/* **************************************************************
-*  Compiler specifics
-****************************************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  define FORCE_INLINE static __forceinline
-#  include <intrin.h>                    /* For Visual 2005 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
-#else
-#  ifdef __GNUC__
-#    define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#    define FORCE_INLINE static inline __attribute__((always_inline))
-#  else
-#    define FORCE_INLINE static inline
-#  endif
-#endif
-
-
-/* **************************************************************
-*  Includes
-****************************************************************/
-#include <stdlib.h>     /* malloc, free, qsort */
-#include <string.h>     /* memcpy, memset */
-#include <stdio.h>      /* printf (debug) */
-#include "bitstream.h"
-#include "fse_static.h"
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#define FSE_isError ERR_isError
-#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-
-
-/* **************************************************************
-*  Complex types
-****************************************************************/
-typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];
-
-
-/* **************************************************************
-*  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*)malloc( FSE_DTABLE_SIZE_U32(tableLog) * sizeof (U32) );
-}
-
-void FSE_freeDTable (FSE_DTable* dt)
-{
-    free(dt);
-}
-
-size_t FSE_buildDTable(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
-{
-    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[FSE_MAX_SYMBOL_VALUE+1];
-
-    U32 const maxSV1 = maxSymbolValue + 1;
-    U32 const tableSize = 1 << tableLog;
-    U32 highThreshold = tableSize-1;
-
-    /* Sanity Checks */
-    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];
-        }   }   }
-        memcpy(dt, &DTableH, sizeof(DTableH));
-    }
-
-    /* Spread symbols */
-    {   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);
-            U16 nextState = symbolNext[symbol]++;
-            tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32 ((U32)nextState) );
-            tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
-    }   }
-
-    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 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 */
-    { size_t const errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */
-      if (FSE_isError(errorCode)) return errorCode; }
-
-    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);
-}
-
-
-size_t FSE_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)
-{
-    const BYTE* const istart = (const BYTE*)cSrc;
-    const BYTE* ip = istart;
-    short counting[FSE_MAX_SYMBOL_VALUE+1];
-    DTable_max_t dt;   /* Static analyzer seems unable to understand this table will be properly initialized later */
-    unsigned tableLog;
-    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
-
-    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */
-
-    /* normal FSE decoding mode */
-    {   size_t const NCountLength = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
-        if (FSE_isError(NCountLength)) return NCountLength;
-        if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */
-        ip += NCountLength;
-        cSrcSize -= NCountLength;
-    }
-
-    { size_t const errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);
-      if (FSE_isError(errorCode)) return errorCode; }
-
-    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);   /* always return, even if it is an error code */
-}
-
-
-
-#endif   /* FSE_COMMONDEFS_ONLY */
+/* ****************************************************************** 
+   FSE : Finite State Entropy decoder 
+   Copyright (C) 2013-2015, Yann Collet. 
+ 
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+   Redistribution and use in source and binary forms, with or without 
+   modification, are permitted provided that the following conditions are 
+   met: 
+ 
+       * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer. 
+       * Redistributions in binary form must reproduce the above 
+   copyright notice, this list of conditions and the following disclaimer 
+   in the documentation and/or other materials provided with the 
+   distribution. 
+ 
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+    You can contact the author at : 
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+ 
+ 
+/* ************************************************************** 
+*  Compiler specifics 
+****************************************************************/ 
+#ifdef _MSC_VER    /* Visual Studio */ 
+#  define FORCE_INLINE static __forceinline 
+#  include <intrin.h>                    /* For Visual 2005 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */ 
+#else 
+#  ifdef __GNUC__ 
+#    define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) 
+#    define FORCE_INLINE static inline __attribute__((always_inline)) 
+#  else 
+#    define FORCE_INLINE static inline 
+#  endif 
+#endif 
+ 
+ 
+/* ************************************************************** 
+*  Includes 
+****************************************************************/ 
+#include <stdlib.h>     /* malloc, free, qsort */ 
+#include <string.h>     /* memcpy, memset */ 
+#include <stdio.h>      /* printf (debug) */ 
+#include "bitstream.h" 
+#include "fse_static.h" 
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#define FSE_isError ERR_isError 
+#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */ 
+ 
+ 
+/* ************************************************************** 
+*  Complex types 
+****************************************************************/ 
+typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)]; 
+ 
+ 
+/* ************************************************************** 
+*  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*)malloc( FSE_DTABLE_SIZE_U32(tableLog) * sizeof (U32) ); 
+} 
+ 
+void FSE_freeDTable (FSE_DTable* dt) 
+{ 
+    free(dt); 
+} 
+ 
+size_t FSE_buildDTable(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) 
+{ 
+    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[FSE_MAX_SYMBOL_VALUE+1]; 
+ 
+    U32 const maxSV1 = maxSymbolValue + 1; 
+    U32 const tableSize = 1 << tableLog; 
+    U32 highThreshold = tableSize-1; 
+ 
+    /* Sanity Checks */ 
+    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]; 
+        }   }   } 
+        memcpy(dt, &DTableH, sizeof(DTableH)); 
+    } 
+ 
+    /* Spread symbols */ 
+    {   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); 
+            U16 nextState = symbolNext[symbol]++; 
+            tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32 ((U32)nextState) ); 
+            tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize); 
+    }   } 
+ 
+    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 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 */ 
+    { size_t const errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */ 
+      if (FSE_isError(errorCode)) return errorCode; } 
+ 
+    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); 
+} 
+ 
+ 
+size_t FSE_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    const BYTE* const istart = (const BYTE*)cSrc; 
+    const BYTE* ip = istart; 
+    short counting[FSE_MAX_SYMBOL_VALUE+1]; 
+    DTable_max_t dt;   /* Static analyzer seems unable to understand this table will be properly initialized later */ 
+    unsigned tableLog; 
+    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE; 
+ 
+    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */ 
+ 
+    /* normal FSE decoding mode */ 
+    {   size_t const NCountLength = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize); 
+        if (FSE_isError(NCountLength)) return NCountLength; 
+        if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */ 
+        ip += NCountLength; 
+        cSrcSize -= NCountLength; 
+    } 
+ 
+    { size_t const errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog); 
+      if (FSE_isError(errorCode)) return errorCode; } 
+ 
+    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);   /* always return, even if it is an error code */ 
+} 
+ 
+ 
+ 
+#endif   /* FSE_COMMONDEFS_ONLY */ 
diff --git a/contrib/libs/zstd06/common/fse_static.h b/contrib/libs/zstd06/common/fse_static.h
index d09589efee..d499f45df4 100644
--- a/contrib/libs/zstd06/common/fse_static.h
+++ b/contrib/libs/zstd06/common/fse_static.h
@@ -1,4 +1,4 @@
-#include <contrib/libs/zstd06/renames.h>
+#include <contrib/libs/zstd06/renames.h> 
 /* ******************************************************************
    FSE : Finite State Entropy coder
    header file for static linking (only)
@@ -335,54 +335,54 @@ MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
 }
 
 
-
-#ifndef FSE_COMMONDEFS_ONLY
-
-/* **************************************************************
-*  Tuning parameters
-****************************************************************/
-/*!MEMORY_USAGE :
-*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
-*  Increasing memory usage improves compression ratio
-*  Reduced memory usage can improve speed, due to cache effect
-*  Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */
-#define FSE_MAX_MEMORY_USAGE 14
-#define FSE_DEFAULT_MEMORY_USAGE 13
-
-/*!FSE_MAX_SYMBOL_VALUE :
-*  Maximum symbol value authorized.
-*  Required for proper stack allocation */
-#define FSE_MAX_SYMBOL_VALUE 255
-
-
-/* **************************************************************
-*  template functions type & suffix
-****************************************************************/
-#define FSE_FUNCTION_TYPE BYTE
-#define FSE_FUNCTION_EXTENSION
-#define FSE_DECODE_TYPE FSE_decode_t
-
-
-#endif   /* !FSE_COMMONDEFS_ONLY */
-
-
-/* ***************************************************************
-*  Constants
-*****************************************************************/
-#define FSE_MAX_TABLELOG  (FSE_MAX_MEMORY_USAGE-2)
-#define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELOG)
-#define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESIZE-1)
-#define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMORY_USAGE-2)
-#define FSE_MIN_TABLELOG 5
-
-#define FSE_TABLELOG_ABSOLUTE_MAX 15
-#if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX
-#error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported"
-#endif
-
-#define FSE_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3)
-
-
+ 
+#ifndef FSE_COMMONDEFS_ONLY 
+ 
+/* ************************************************************** 
+*  Tuning parameters 
+****************************************************************/ 
+/*!MEMORY_USAGE : 
+*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.) 
+*  Increasing memory usage improves compression ratio 
+*  Reduced memory usage can improve speed, due to cache effect 
+*  Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */ 
+#define FSE_MAX_MEMORY_USAGE 14 
+#define FSE_DEFAULT_MEMORY_USAGE 13 
+ 
+/*!FSE_MAX_SYMBOL_VALUE : 
+*  Maximum symbol value authorized. 
+*  Required for proper stack allocation */ 
+#define FSE_MAX_SYMBOL_VALUE 255 
+ 
+ 
+/* ************************************************************** 
+*  template functions type & suffix 
+****************************************************************/ 
+#define FSE_FUNCTION_TYPE BYTE 
+#define FSE_FUNCTION_EXTENSION 
+#define FSE_DECODE_TYPE FSE_decode_t 
+ 
+ 
+#endif   /* !FSE_COMMONDEFS_ONLY */ 
+ 
+ 
+/* *************************************************************** 
+*  Constants 
+*****************************************************************/ 
+#define FSE_MAX_TABLELOG  (FSE_MAX_MEMORY_USAGE-2) 
+#define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELOG) 
+#define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESIZE-1) 
+#define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMORY_USAGE-2) 
+#define FSE_MIN_TABLELOG 5 
+ 
+#define FSE_TABLELOG_ABSOLUTE_MAX 15 
+#if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX 
+#error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported" 
+#endif 
+ 
+#define FSE_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3) 
+ 
+ 
 #if defined (__cplusplus)
 }
 #endif
diff --git a/contrib/libs/zstd06/common/huf.h b/contrib/libs/zstd06/common/huf.h
index d520a779ea..f375711625 100644
--- a/contrib/libs/zstd06/common/huf.h
+++ b/contrib/libs/zstd06/common/huf.h
@@ -1,98 +1,98 @@
-#include <contrib/libs/zstd06/renames.h>
-/* ******************************************************************
-   Huffman coder, part of New Generation Entropy library
-   header file
-   Copyright (C) 2013-2016, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-****************************************************************** */
-#ifndef HUF_H
-#define HUF_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* ****************************************
-*  Dependency
-******************************************/
-#include <stddef.h>    /* size_t */
-
-
-/* ****************************************
-*  HUF simple functions
-******************************************/
-size_t HUF_compress(void* dst, size_t dstCapacity,
-              const void* src, size_t srcSize);
-size_t HUF_decompress(void* dst,  size_t dstSize,
-                const void* cSrc, size_t cSrcSize);
-/*
-HUF_compress() :
-    Compress content of buffer 'src', of size 'srcSize', into destination buffer 'dst'.
-    'dst' buffer must be already allocated. Compression runs faster if dstCapacity >= HUF_compressBound(srcSize).
-    Note : srcSize must be <= 128 KB
-    @return : size of compressed data (<= dstCapacity)
-    Special values : if return == 0, srcData is not compressible => Nothing is stored within dst !!!
-                     if return == 1, srcData is a single repeated byte symbol (RLE compression).
-                     if HUF_isError(return), compression failed (more details using HUF_getErrorName())
-
-HUF_decompress() :
-    Decompress HUF data from buffer 'cSrc', of size 'cSrcSize',
-    into already allocated destination buffer 'dst', of size 'dstSize'.
-    `dstSize` : must be the **exact** size of original (uncompressed) data.
-    Note : in contrast with FSE, HUF_decompress can regenerate
-           RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data,
-           because it knows size to regenerate.
-    @return : size of regenerated data (== dstSize)
-              or an error code, which can be tested using HUF_isError()
-*/
-
-
-/* ****************************************
-*  Tool functions
-******************************************/
-size_t HUF_compressBound(size_t size);       /**< maximum compressed size */
-
-/* Error Management */
-unsigned    HUF_isError(size_t code);        /**< tells if a return value is an error code */
-const char* HUF_getErrorName(size_t code);   /**< provides error code string (useful for debugging) */
-
-
-/* ****************************************
-*  Advanced functions
-******************************************/
-size_t HUF_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif   /* HUF_H */
+#include <contrib/libs/zstd06/renames.h> 
+/* ****************************************************************** 
+   Huffman coder, part of New Generation Entropy library 
+   header file 
+   Copyright (C) 2013-2016, Yann Collet. 
+ 
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+   Redistribution and use in source and binary forms, with or without 
+   modification, are permitted provided that the following conditions are 
+   met: 
+ 
+       * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer. 
+       * Redistributions in binary form must reproduce the above 
+   copyright notice, this list of conditions and the following disclaimer 
+   in the documentation and/or other materials provided with the 
+   distribution. 
+ 
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+   You can contact the author at : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+****************************************************************** */ 
+#ifndef HUF_H 
+#define HUF_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* **************************************** 
+*  Dependency 
+******************************************/ 
+#include <stddef.h>    /* size_t */ 
+ 
+ 
+/* **************************************** 
+*  HUF simple functions 
+******************************************/ 
+size_t HUF_compress(void* dst, size_t dstCapacity, 
+              const void* src, size_t srcSize); 
+size_t HUF_decompress(void* dst,  size_t dstSize, 
+                const void* cSrc, size_t cSrcSize); 
+/* 
+HUF_compress() : 
+    Compress content of buffer 'src', of size 'srcSize', into destination buffer 'dst'. 
+    'dst' buffer must be already allocated. Compression runs faster if dstCapacity >= HUF_compressBound(srcSize). 
+    Note : srcSize must be <= 128 KB 
+    @return : size of compressed data (<= dstCapacity) 
+    Special values : if return == 0, srcData is not compressible => Nothing is stored within dst !!! 
+                     if return == 1, srcData is a single repeated byte symbol (RLE compression). 
+                     if HUF_isError(return), compression failed (more details using HUF_getErrorName()) 
+ 
+HUF_decompress() : 
+    Decompress HUF data from buffer 'cSrc', of size 'cSrcSize', 
+    into already allocated destination buffer 'dst', of size 'dstSize'. 
+    `dstSize` : must be the **exact** size of original (uncompressed) data. 
+    Note : in contrast with FSE, HUF_decompress can regenerate 
+           RLE (cSrcSize==1) and uncompressed (cSrcSize==dstSize) data, 
+           because it knows size to regenerate. 
+    @return : size of regenerated data (== dstSize) 
+              or an error code, which can be tested using HUF_isError() 
+*/ 
+ 
+ 
+/* **************************************** 
+*  Tool functions 
+******************************************/ 
+size_t HUF_compressBound(size_t size);       /**< maximum compressed size */ 
+ 
+/* Error Management */ 
+unsigned    HUF_isError(size_t code);        /**< tells if a return value is an error code */ 
+const char* HUF_getErrorName(size_t code);   /**< provides error code string (useful for debugging) */ 
+ 
+ 
+/* **************************************** 
+*  Advanced functions 
+******************************************/ 
+size_t HUF_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog); 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif   /* HUF_H */ 
diff --git a/contrib/libs/zstd06/common/huf_static.h b/contrib/libs/zstd06/common/huf_static.h
index 8c81b6a503..68a238e3ab 100644
--- a/contrib/libs/zstd06/common/huf_static.h
+++ b/contrib/libs/zstd06/common/huf_static.h
@@ -1,228 +1,228 @@
-#include <contrib/libs/zstd06/renames.h>
-/* ******************************************************************
-   Huffman codec, part of New Generation Entropy library
-   header file, for static linking only
-   Copyright (C) 2013-2016, Yann Collet
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-****************************************************************** */
-#ifndef HUF_STATIC_H
-#define HUF_STATIC_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* ****************************************
-*  Dependency
-******************************************/
-#include "huf.h"
-#include "fse.h"
-#include "bitstream.h"
-
-
-/* ****************************************
-*  Static allocation
-******************************************/
-/* HUF buffer bounds */
-#define HUF_CTABLEBOUND 129
-#define HUF_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true if incompressible pre-filtered with fast heuristic */
-#define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
-
-/* static allocation of HUF's Compression Table */
-#define HUF_CREATE_STATIC_CTABLE(name, maxSymbolValue) \
-    U32 name##hb[maxSymbolValue+1]; \
-    void* name##hv = &(name##hb); \
-    HUF_CElt* name = (HUF_CElt*)(name##hv)   /* no final ; */
-
-/* static allocation of HUF's DTable */
-#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog))
-#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
-        unsigned short DTable[HUF_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
-#define HUF_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \
-        unsigned int DTable[HUF_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
-#define HUF_CREATE_STATIC_DTABLEX6(DTable, maxTableLog) \
-        unsigned int DTable[HUF_DTABLE_SIZE(maxTableLog) * 3 / 2] = { maxTableLog }
-
-
-/* ****************************************
-*  Advanced decompression functions
-******************************************/
-size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
-size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */
-size_t HUF_decompress4X6 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* quad-symbols decoder, only works for dstSize >= 64 */
-
-
-/* ****************************************
-*  HUF detailed API
-******************************************/
-/*!
-HUF_compress() does the following:
-1. count symbol occurrence from source[] into table count[] using FSE_count()
-2. build Huffman table from count using HUF_buildCTable()
-3. save Huffman table to memory buffer using HUF_writeCTable()
-4. encode the data stream using HUF_compress4X_usingCTable()
-
-The following API allows targeting specific sub-functions for advanced tasks.
-For example, it's possible to compress several blocks using the same 'CTable',
-or to save and regenerate 'CTable' using external methods.
-*/
-/* FSE_count() : find it within "fse.h" */
-typedef struct HUF_CElt_s HUF_CElt;   /* incomplete type */
-size_t HUF_buildCTable (HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue, unsigned maxNbBits);
-size_t HUF_writeCTable (void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog);
-size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
-
-
-/*!
-HUF_decompress() does the following:
-1. select the decompression algorithm (X2, X4, X6) based on pre-computed heuristics
-2. build Huffman table from save, using HUF_readDTableXn()
-3. decode 1 or 4 segments in parallel using HUF_decompressSXn_usingDTable
-*/
-size_t HUF_readDTableX2 (unsigned short* DTable, const void* src, size_t srcSize);
-size_t HUF_readDTableX4 (unsigned* DTable, const void* src, size_t srcSize);
-size_t HUF_readDTableX6 (unsigned* DTable, const void* src, size_t srcSize);
-
-size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable);
-size_t HUF_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable);
-size_t HUF_decompress4X6_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable);
-
-
-/* single stream variants */
-
-size_t HUF_compress1X (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);
-size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
-
-size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
-size_t HUF_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */
-size_t HUF_decompress1X6 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* quad-symbols decoder, only works for dstSize >= 64 */
-
-size_t HUF_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable);
-size_t HUF_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable);
-size_t HUF_decompress1X6_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable);
-
-
-/* Loading a CTable saved with HUF_writeCTable() */
-
-size_t HUF_readCTable (HUF_CElt* CTable, unsigned maxSymbolValue, const void* src, size_t srcSize);
-
-
-/* **************************************************************
-*  Constants
-****************************************************************/
-#define HUF_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */
-#define HUF_MAX_TABLELOG  12           /* max configured tableLog (for static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */
-#define HUF_DEFAULT_TABLELOG  HUF_MAX_TABLELOG   /* tableLog by default, when not specified */
-#define HUF_MAX_SYMBOL_VALUE 255
-#if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG)
-#  error "HUF_MAX_TABLELOG is too large !"
-#endif
-
-
-
-/*! HUF_readStats() :
-    Read compact Huffman tree, saved by HUF_writeCTable().
-    `huffWeight` is destination buffer.
-    @return : size read from `src`
-*/
-MEM_STATIC size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                            U32* nbSymbolsPtr, U32* tableLogPtr,
-                            const void* src, size_t srcSize)
-{
-    U32 weightTotal;
-    const BYTE* ip = (const BYTE*) src;
-    size_t iSize = ip[0];
-    size_t oSize;
-
-    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */
-
-    if (iSize >= 128)  { /* special header */
-        if (iSize >= (242)) {  /* RLE */
-            static U32 l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };
-            oSize = l[iSize-242];
-            memset(huffWeight, 1, hwSize);
-            iSize = 0;
-        }
-        else {   /* Incompressible */
-            oSize = iSize - 127;
-            iSize = ((oSize+1)/2);
-            if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
-            if (oSize >= hwSize) return ERROR(corruption_detected);
-            ip += 1;
-            {   U32 n;
-                for (n=0; n<oSize; n+=2) {
-                    huffWeight[n]   = ip[n/2] >> 4;
-                    huffWeight[n+1] = ip[n/2] & 15;
-    }   }   }   }
-    else  {   /* header compressed with FSE (normal case) */
-        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
-        oSize = FSE_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */
-        if (FSE_isError(oSize)) return oSize;
-    }
-
-    /* collect weight stats */
-    memset(rankStats, 0, (HUF_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32));
-    weightTotal = 0;
-    {   U32 n; for (n=0; n<oSize; n++) {
-            if (huffWeight[n] >= HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
-            rankStats[huffWeight[n]]++;
-            weightTotal += (1 << huffWeight[n]) >> 1;
-    }   }
-
-    /* get last non-null symbol weight (implied, total must be 2^n) */
-    {   U32 const tableLog = BIT_highbit32(weightTotal) + 1;
-        if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
-        *tableLogPtr = tableLog;
-        /* determine last weight */
-        {   U32 const total = 1 << tableLog;
-            U32 const rest = total - weightTotal;
-            U32 const verif = 1 << BIT_highbit32(rest);
-            U32 const lastWeight = BIT_highbit32(rest) + 1;
-            if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */
-            huffWeight[oSize] = (BYTE)lastWeight;
-            rankStats[lastWeight]++;
-    }   }
-
-    /* check tree construction validity */
-    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */
-
-    /* results */
-    *nbSymbolsPtr = (U32)(oSize+1);
-    return iSize+1;
-}
-
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* HUF_STATIC_H */
+#include <contrib/libs/zstd06/renames.h> 
+/* ****************************************************************** 
+   Huffman codec, part of New Generation Entropy library 
+   header file, for static linking only 
+   Copyright (C) 2013-2016, Yann Collet 
+ 
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+   Redistribution and use in source and binary forms, with or without 
+   modification, are permitted provided that the following conditions are 
+   met: 
+ 
+       * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer. 
+       * Redistributions in binary form must reproduce the above 
+   copyright notice, this list of conditions and the following disclaimer 
+   in the documentation and/or other materials provided with the 
+   distribution. 
+ 
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+   You can contact the author at : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+****************************************************************** */ 
+#ifndef HUF_STATIC_H 
+#define HUF_STATIC_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* **************************************** 
+*  Dependency 
+******************************************/ 
+#include "huf.h" 
+#include "fse.h" 
+#include "bitstream.h" 
+ 
+ 
+/* **************************************** 
+*  Static allocation 
+******************************************/ 
+/* HUF buffer bounds */ 
+#define HUF_CTABLEBOUND 129 
+#define HUF_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true if incompressible pre-filtered with fast heuristic */ 
+#define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size))   /* Macro version, useful for static allocation */ 
+ 
+/* static allocation of HUF's Compression Table */ 
+#define HUF_CREATE_STATIC_CTABLE(name, maxSymbolValue) \ 
+    U32 name##hb[maxSymbolValue+1]; \ 
+    void* name##hv = &(name##hb); \ 
+    HUF_CElt* name = (HUF_CElt*)(name##hv)   /* no final ; */ 
+ 
+/* static allocation of HUF's DTable */ 
+#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog)) 
+#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \ 
+        unsigned short DTable[HUF_DTABLE_SIZE(maxTableLog)] = { maxTableLog } 
+#define HUF_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \ 
+        unsigned int DTable[HUF_DTABLE_SIZE(maxTableLog)] = { maxTableLog } 
+#define HUF_CREATE_STATIC_DTABLEX6(DTable, maxTableLog) \ 
+        unsigned int DTable[HUF_DTABLE_SIZE(maxTableLog) * 3 / 2] = { maxTableLog } 
+ 
+ 
+/* **************************************** 
+*  Advanced decompression functions 
+******************************************/ 
+size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */ 
+size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */ 
+size_t HUF_decompress4X6 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* quad-symbols decoder, only works for dstSize >= 64 */ 
+ 
+ 
+/* **************************************** 
+*  HUF detailed API 
+******************************************/ 
+/*! 
+HUF_compress() does the following: 
+1. count symbol occurrence from source[] into table count[] using FSE_count() 
+2. build Huffman table from count using HUF_buildCTable() 
+3. save Huffman table to memory buffer using HUF_writeCTable() 
+4. encode the data stream using HUF_compress4X_usingCTable() 
+ 
+The following API allows targeting specific sub-functions for advanced tasks. 
+For example, it's possible to compress several blocks using the same 'CTable', 
+or to save and regenerate 'CTable' using external methods. 
+*/ 
+/* FSE_count() : find it within "fse.h" */ 
+typedef struct HUF_CElt_s HUF_CElt;   /* incomplete type */ 
+size_t HUF_buildCTable (HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue, unsigned maxNbBits); 
+size_t HUF_writeCTable (void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog); 
+size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable); 
+ 
+ 
+/*! 
+HUF_decompress() does the following: 
+1. select the decompression algorithm (X2, X4, X6) based on pre-computed heuristics 
+2. build Huffman table from save, using HUF_readDTableXn() 
+3. decode 1 or 4 segments in parallel using HUF_decompressSXn_usingDTable 
+*/ 
+size_t HUF_readDTableX2 (unsigned short* DTable, const void* src, size_t srcSize); 
+size_t HUF_readDTableX4 (unsigned* DTable, const void* src, size_t srcSize); 
+size_t HUF_readDTableX6 (unsigned* DTable, const void* src, size_t srcSize); 
+ 
+size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable); 
+size_t HUF_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable); 
+size_t HUF_decompress4X6_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable); 
+ 
+ 
+/* single stream variants */ 
+ 
+size_t HUF_compress1X (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog); 
+size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable); 
+ 
+size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */ 
+size_t HUF_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */ 
+size_t HUF_decompress1X6 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* quad-symbols decoder, only works for dstSize >= 64 */ 
+ 
+size_t HUF_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable); 
+size_t HUF_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable); 
+size_t HUF_decompress1X6_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable); 
+ 
+ 
+/* Loading a CTable saved with HUF_writeCTable() */ 
+ 
+size_t HUF_readCTable (HUF_CElt* CTable, unsigned maxSymbolValue, const void* src, size_t srcSize); 
+ 
+ 
+/* ************************************************************** 
+*  Constants 
+****************************************************************/ 
+#define HUF_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */ 
+#define HUF_MAX_TABLELOG  12           /* max configured tableLog (for static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */ 
+#define HUF_DEFAULT_TABLELOG  HUF_MAX_TABLELOG   /* tableLog by default, when not specified */ 
+#define HUF_MAX_SYMBOL_VALUE 255 
+#if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG) 
+#  error "HUF_MAX_TABLELOG is too large !" 
+#endif 
+ 
+ 
+ 
+/*! HUF_readStats() : 
+    Read compact Huffman tree, saved by HUF_writeCTable(). 
+    `huffWeight` is destination buffer. 
+    @return : size read from `src` 
+*/ 
+MEM_STATIC size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats, 
+                            U32* nbSymbolsPtr, U32* tableLogPtr, 
+                            const void* src, size_t srcSize) 
+{ 
+    U32 weightTotal; 
+    const BYTE* ip = (const BYTE*) src; 
+    size_t iSize = ip[0]; 
+    size_t oSize; 
+ 
+    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    if (iSize >= 128)  { /* special header */ 
+        if (iSize >= (242)) {  /* RLE */ 
+            static U32 l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 }; 
+            oSize = l[iSize-242]; 
+            memset(huffWeight, 1, hwSize); 
+            iSize = 0; 
+        } 
+        else {   /* Incompressible */ 
+            oSize = iSize - 127; 
+            iSize = ((oSize+1)/2); 
+            if (iSize+1 > srcSize) return ERROR(srcSize_wrong); 
+            if (oSize >= hwSize) return ERROR(corruption_detected); 
+            ip += 1; 
+            {   U32 n; 
+                for (n=0; n<oSize; n+=2) { 
+                    huffWeight[n]   = ip[n/2] >> 4; 
+                    huffWeight[n+1] = ip[n/2] & 15; 
+    }   }   }   } 
+    else  {   /* header compressed with FSE (normal case) */ 
+        if (iSize+1 > srcSize) return ERROR(srcSize_wrong); 
+        oSize = FSE_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */ 
+        if (FSE_isError(oSize)) return oSize; 
+    } 
+ 
+    /* collect weight stats */ 
+    memset(rankStats, 0, (HUF_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32)); 
+    weightTotal = 0; 
+    {   U32 n; for (n=0; n<oSize; n++) { 
+            if (huffWeight[n] >= HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected); 
+            rankStats[huffWeight[n]]++; 
+            weightTotal += (1 << huffWeight[n]) >> 1; 
+    }   } 
+ 
+    /* get last non-null symbol weight (implied, total must be 2^n) */ 
+    {   U32 const tableLog = BIT_highbit32(weightTotal) + 1; 
+        if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected); 
+        *tableLogPtr = tableLog; 
+        /* determine last weight */ 
+        {   U32 const total = 1 << tableLog; 
+            U32 const rest = total - weightTotal; 
+            U32 const verif = 1 << BIT_highbit32(rest); 
+            U32 const lastWeight = BIT_highbit32(rest) + 1; 
+            if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */ 
+            huffWeight[oSize] = (BYTE)lastWeight; 
+            rankStats[lastWeight]++; 
+    }   } 
+ 
+    /* check tree construction validity */ 
+    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */ 
+ 
+    /* results */ 
+    *nbSymbolsPtr = (U32)(oSize+1); 
+    return iSize+1; 
+} 
+ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* HUF_STATIC_H */ 
diff --git a/contrib/libs/zstd06/common/mem.h b/contrib/libs/zstd06/common/mem.h
index 85d78c84c1..67a0f66842 100644
--- a/contrib/libs/zstd06/common/mem.h
+++ b/contrib/libs/zstd06/common/mem.h
@@ -1,4 +1,4 @@
-#include <contrib/libs/zstd06/renames.h>
+#include <contrib/libs/zstd06/renames.h> 
 /* ******************************************************************
    mem.h
    low-level memory access routines
@@ -43,17 +43,17 @@ extern "C" {
 /*-****************************************
 *  Dependencies
 ******************************************/
-#include <stddef.h>     /* size_t, ptrdiff_t */
-#include <string.h>     /* memcpy */
+#include <stddef.h>     /* size_t, ptrdiff_t */ 
+#include <string.h>     /* memcpy */ 
 
 
 /*-****************************************
 *  Compiler specifics
 ******************************************/
-#if defined(_MSC_VER)   /* Visual Studio */
-#   include <stdlib.h>  /* _byteswap_ulong */
-#   include <intrin.h>  /* _byteswap_* */
-#endif
+#if defined(_MSC_VER)   /* Visual Studio */ 
+#   include <stdlib.h>  /* _byteswap_ulong */ 
+#   include <intrin.h>  /* _byteswap_* */ 
+#endif 
 #if defined(__GNUC__)
 #  define MEM_STATIC static __attribute__((unused))
 #elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
@@ -64,15 +64,15 @@ extern "C" {
 #  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
 #endif
 
-/* code only tested on 32 and 64 bits systems */
-#define MEM_STATIC_ASSERT(c)   { enum { XXH_static_assert = 1/(int)(!!(c)) }; }
-MEM_STATIC void MEM_check(void) { MEM_STATIC_ASSERT((sizeof(size_t)==4) || (sizeof(size_t)==8)); }
-
+/* code only tested on 32 and 64 bits systems */ 
+#define MEM_STATIC_ASSERT(c)   { enum { XXH_static_assert = 1/(int)(!!(c)) }; } 
+MEM_STATIC void MEM_check(void) { MEM_STATIC_ASSERT((sizeof(size_t)==4) || (sizeof(size_t)==8)); } 
 
+ 
 /*-**************************************************************
 *  Basic Types
 *****************************************************************/
-#if  !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+#if  !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) ) 
 # include <stdint.h>
   typedef  uint8_t BYTE;
   typedef uint16_t U16;
@@ -117,8 +117,8 @@ MEM_STATIC void MEM_check(void) { MEM_STATIC_ASSERT((sizeof(size_t)==4) || (size
 #  endif
 #endif
 
-MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; }
-MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; }
+MEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; } 
+MEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; } 
 
 MEM_STATIC unsigned MEM_isLittleEndian(void)
 {
@@ -196,48 +196,48 @@ MEM_STATIC void MEM_write64(void* memPtr, U64 value)
 
 #endif /* MEM_FORCE_MEMORY_ACCESS */
 
-MEM_STATIC U32 MEM_swap32(U32 in)
-{
-#if defined(_MSC_VER)     /* Visual Studio */
-    return _byteswap_ulong(in);
-#elif defined (__GNUC__)
-    return __builtin_bswap32(in);
-#else
-    return  ((in << 24) & 0xff000000 ) |
-            ((in <<  8) & 0x00ff0000 ) |
-            ((in >>  8) & 0x0000ff00 ) |
-            ((in >> 24) & 0x000000ff );
-#endif
-}
-
-MEM_STATIC U64 MEM_swap64(U64 in)
-{
-#if defined(_MSC_VER)     /* Visual Studio */
-    return _byteswap_uint64(in);
-#elif defined (__GNUC__)
-    return __builtin_bswap64(in);
-#else
-    return  ((in << 56) & 0xff00000000000000ULL) |
-            ((in << 40) & 0x00ff000000000000ULL) |
-            ((in << 24) & 0x0000ff0000000000ULL) |
-            ((in << 8)  & 0x000000ff00000000ULL) |
-            ((in >> 8)  & 0x00000000ff000000ULL) |
-            ((in >> 24) & 0x0000000000ff0000ULL) |
-            ((in >> 40) & 0x000000000000ff00ULL) |
-            ((in >> 56) & 0x00000000000000ffULL);
-#endif
-}
-
-MEM_STATIC size_t MEM_swapST(size_t in)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_swap32((U32)in);
-    else
-        return (size_t)MEM_swap64((U64)in);
-}
-
-/*=== Little endian r/w ===*/
-
+MEM_STATIC U32 MEM_swap32(U32 in) 
+{ 
+#if defined(_MSC_VER)     /* Visual Studio */ 
+    return _byteswap_ulong(in); 
+#elif defined (__GNUC__) 
+    return __builtin_bswap32(in); 
+#else 
+    return  ((in << 24) & 0xff000000 ) | 
+            ((in <<  8) & 0x00ff0000 ) | 
+            ((in >>  8) & 0x0000ff00 ) | 
+            ((in >> 24) & 0x000000ff ); 
+#endif 
+} 
+ 
+MEM_STATIC U64 MEM_swap64(U64 in) 
+{ 
+#if defined(_MSC_VER)     /* Visual Studio */ 
+    return _byteswap_uint64(in); 
+#elif defined (__GNUC__) 
+    return __builtin_bswap64(in); 
+#else 
+    return  ((in << 56) & 0xff00000000000000ULL) | 
+            ((in << 40) & 0x00ff000000000000ULL) | 
+            ((in << 24) & 0x0000ff0000000000ULL) | 
+            ((in << 8)  & 0x000000ff00000000ULL) | 
+            ((in >> 8)  & 0x00000000ff000000ULL) | 
+            ((in >> 24) & 0x0000000000ff0000ULL) | 
+            ((in >> 40) & 0x000000000000ff00ULL) | 
+            ((in >> 56) & 0x00000000000000ffULL); 
+#endif 
+} 
+ 
+MEM_STATIC size_t MEM_swapST(size_t in) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_swap32((U32)in); 
+    else 
+        return (size_t)MEM_swap64((U64)in); 
+} 
+ 
+/*=== Little endian r/w ===*/ 
+ 
 MEM_STATIC U16 MEM_readLE16(const void* memPtr)
 {
     if (MEM_isLittleEndian())
@@ -259,47 +259,47 @@ MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
     }
 }
 
-MEM_STATIC U32 MEM_readLE24(const void* memPtr)
-{
-    return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);
-}
-
-MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val)
-{
-    MEM_writeLE16(memPtr, (U16)val);
-    ((BYTE*)memPtr)[2] = (BYTE)(val>>16);
-}
-
+MEM_STATIC U32 MEM_readLE24(const void* memPtr) 
+{ 
+    return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16); 
+} 
+ 
+MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val) 
+{ 
+    MEM_writeLE16(memPtr, (U16)val); 
+    ((BYTE*)memPtr)[2] = (BYTE)(val>>16); 
+} 
+ 
 MEM_STATIC U32 MEM_readLE32(const void* memPtr)
 {
     if (MEM_isLittleEndian())
         return MEM_read32(memPtr);
-    else
-        return MEM_swap32(MEM_read32(memPtr));
+    else 
+        return MEM_swap32(MEM_read32(memPtr)); 
 }
 
 MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)
 {
-    if (MEM_isLittleEndian())
+    if (MEM_isLittleEndian()) 
         MEM_write32(memPtr, val32);
-    else
-        MEM_write32(memPtr, MEM_swap32(val32));
+    else 
+        MEM_write32(memPtr, MEM_swap32(val32)); 
 }
 
 MEM_STATIC U64 MEM_readLE64(const void* memPtr)
 {
     if (MEM_isLittleEndian())
         return MEM_read64(memPtr);
-    else
-        return MEM_swap64(MEM_read64(memPtr));
+    else 
+        return MEM_swap64(MEM_read64(memPtr)); 
 }
 
 MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)
 {
-    if (MEM_isLittleEndian())
+    if (MEM_isLittleEndian()) 
         MEM_write64(memPtr, val64);
-    else
-        MEM_write64(memPtr, MEM_swap64(val64));
+    else 
+        MEM_write64(memPtr, MEM_swap64(val64)); 
 }
 
 MEM_STATIC size_t MEM_readLEST(const void* memPtr)
@@ -318,58 +318,58 @@ MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val)
         MEM_writeLE64(memPtr, (U64)val);
 }
 
-/*=== Big endian r/w ===*/
-
-MEM_STATIC U32 MEM_readBE32(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_swap32(MEM_read32(memPtr));
-    else
-        return MEM_read32(memPtr);
-}
-
-MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32)
-{
-    if (MEM_isLittleEndian())
-        MEM_write32(memPtr, MEM_swap32(val32));
-    else
-        MEM_write32(memPtr, val32);
-}
-
-MEM_STATIC U64 MEM_readBE64(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_swap64(MEM_read64(memPtr));
-    else
-        return MEM_read64(memPtr);
-}
-
-MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64)
-{
-    if (MEM_isLittleEndian())
-        MEM_write64(memPtr, MEM_swap64(val64));
-    else
-        MEM_write64(memPtr, val64);
-}
-
-MEM_STATIC size_t MEM_readBEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readBE32(memPtr);
-    else
-        return (size_t)MEM_readBE64(memPtr);
-}
-
-MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val)
-{
-    if (MEM_32bits())
-        MEM_writeBE32(memPtr, (U32)val);
-    else
-        MEM_writeBE64(memPtr, (U64)val);
-}
-
-
-/* function safe only for comparisons */
+/*=== Big endian r/w ===*/ 
+ 
+MEM_STATIC U32 MEM_readBE32(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_swap32(MEM_read32(memPtr)); 
+    else 
+        return MEM_read32(memPtr); 
+} 
+ 
+MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32) 
+{ 
+    if (MEM_isLittleEndian()) 
+        MEM_write32(memPtr, MEM_swap32(val32)); 
+    else 
+        MEM_write32(memPtr, val32); 
+} 
+ 
+MEM_STATIC U64 MEM_readBE64(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_swap64(MEM_read64(memPtr)); 
+    else 
+        return MEM_read64(memPtr); 
+} 
+ 
+MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64) 
+{ 
+    if (MEM_isLittleEndian()) 
+        MEM_write64(memPtr, MEM_swap64(val64)); 
+    else 
+        MEM_write64(memPtr, val64); 
+} 
+ 
+MEM_STATIC size_t MEM_readBEST(const void* memPtr) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_readBE32(memPtr); 
+    else 
+        return (size_t)MEM_readBE64(memPtr); 
+} 
+ 
+MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val) 
+{ 
+    if (MEM_32bits()) 
+        MEM_writeBE32(memPtr, (U32)val); 
+    else 
+        MEM_writeBE64(memPtr, (U64)val); 
+} 
+ 
+ 
+/* function safe only for comparisons */ 
 MEM_STATIC U32 MEM_readMINMATCH(const void* memPtr, U32 length)
 {
     switch (length)
diff --git a/contrib/libs/zstd06/common/xxhash.c b/contrib/libs/zstd06/common/xxhash.c
index e175ae96eb..ab1be712e1 100644
--- a/contrib/libs/zstd06/common/xxhash.c
+++ b/contrib/libs/zstd06/common/xxhash.c
@@ -1,854 +1,854 @@
-/*
-*  xxHash - Fast Hash algorithm
-*  Copyright (C) 2012-2016, Yann Collet
-*
-*  BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-*
-*  Redistribution and use in source and binary forms, with or without
-*  modification, are permitted provided that the following conditions are
-*  met:
-*
-*  * Redistributions of source code must retain the above copyright
-*  notice, this list of conditions and the following disclaimer.
-*  * Redistributions in binary form must reproduce the above
-*  copyright notice, this list of conditions and the following disclaimer
-*  in the documentation and/or other materials provided with the
-*  distribution.
-*
-*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-*  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-*  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*
-*  You can contact the author at :
-*  - xxHash homepage: http://www.xxhash.com
-*  - xxHash source repository : https://github.com/Cyan4973/xxHash
-*/
-
-
-/* *************************************
-*  Tuning parameters
-***************************************/
-/*!XXH_FORCE_MEMORY_ACCESS :
- * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
- * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
- * The below switch allow to select different access method for improved performance.
- * Method 0 (default) : use `memcpy()`. Safe and portable.
- * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
- *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
- * Method 2 : direct access. This method doesn't depend on compiler but violate C standard.
- *            It can generate buggy code on targets which do not support unaligned memory accesses.
- *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
- * See http://stackoverflow.com/a/32095106/646947 for details.
- * Prefer these methods in priority order (0 > 1 > 2)
- */
-#ifndef XXH_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
-#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
-#    define XXH_FORCE_MEMORY_ACCESS 2
-#  elif defined(__INTEL_COMPILER) || \
-  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) ))
-#    define XXH_FORCE_MEMORY_ACCESS 1
-#  endif
-#endif
-
-/*!XXH_ACCEPT_NULL_INPUT_POINTER :
- * If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer.
- * When this option is enabled, xxHash output for null input pointers will be the same as a null-length input.
- * By default, this option is disabled. To enable it, uncomment below define :
- */
-/* #define XXH_ACCEPT_NULL_INPUT_POINTER 1 */
-
-/*!XXH_FORCE_NATIVE_FORMAT :
- * By default, xxHash library provides endian-independant Hash values, based on little-endian convention.
- * Results are therefore identical for little-endian and big-endian CPU.
- * This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format.
- * Should endian-independance be of no importance for your application, you may set the #define below to 1,
- * to improve speed for Big-endian CPU.
- * This option has no impact on Little_Endian CPU.
- */
-#ifndef XXH_FORCE_NATIVE_FORMAT   /* can be defined externally */
-#  define XXH_FORCE_NATIVE_FORMAT 0
-#endif
-
-/*!XXH_FORCE_ALIGN_CHECK :
- * This is a minor performance trick, only useful with lots of very small keys.
- * It means : check for aligned/unaligned input.
- * The check costs one initial branch per hash; set to 0 when the input data
- * is guaranteed to be aligned.
- */
-#ifndef XXH_FORCE_ALIGN_CHECK /* can be defined externally */
-#  if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
-#    define XXH_FORCE_ALIGN_CHECK 0
-#  else
-#    define XXH_FORCE_ALIGN_CHECK 1
-#  endif
-#endif
-
-
-/* *************************************
-*  Includes & Memory related functions
-***************************************/
-/* Modify the local functions below should you wish to use some other memory routines */
-/* for malloc(), free() */
-#include <stdlib.h>
-static void* XXH_malloc(size_t s) { return malloc(s); }
-static void  XXH_free  (void* p)  { free(p); }
-/* for memcpy() */
-#include <string.h>
-static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); }
-
-#define XXH_STATIC_LINKING_ONLY
-#include "xxhash.h"
-
-
-/* *************************************
-*  Compiler Specific Options
-***************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  pragma warning(disable : 4127)      /* disable: C4127: conditional expression is constant */
-#  define FORCE_INLINE static __forceinline
-#else
-#  if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-#    ifdef __GNUC__
-#      define FORCE_INLINE static inline __attribute__((always_inline))
-#    else
-#      define FORCE_INLINE static inline
-#    endif
-#  else
-#    define FORCE_INLINE static
-#  endif /* __STDC_VERSION__ */
-#endif
-
-
-/* *************************************
-*  Basic Types
-***************************************/
-#ifndef MEM_MODULE
-# define MEM_MODULE
-# if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-#   include <stdint.h>
-    typedef uint8_t  BYTE;
-    typedef uint16_t U16;
-    typedef uint32_t U32;
-    typedef  int32_t S32;
-    typedef uint64_t U64;
-#  else
-    typedef unsigned char      BYTE;
-    typedef unsigned short     U16;
-    typedef unsigned int       U32;
-    typedef   signed int       S32;
-    typedef unsigned long long U64;
-#  endif
-#endif
-
-
-#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))
-
-/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */
-static U32 XXH_read32(const void* memPtr) { return *(const U32*) memPtr; }
-static U64 XXH_read64(const void* memPtr) { return *(const U64*) memPtr; }
-
-#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))
-
-/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
-/* currently only defined for gcc and icc */
-typedef union { U32 u32; U64 u64; } __attribute__((packed)) unalign;
-
-static U32 XXH_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
-static U64 XXH_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
-
-#else
-
-/* portable and safe solution. Generally efficient.
- * see : http://stackoverflow.com/a/32095106/646947
- */
-
-static U32 XXH_read32(const void* memPtr)
-{
-    U32 val;
-    memcpy(&val, memPtr, sizeof(val));
-    return val;
-}
-
-static U64 XXH_read64(const void* memPtr)
-{
-    U64 val;
-    memcpy(&val, memPtr, sizeof(val));
-    return val;
-}
-
-#endif   /* XXH_FORCE_DIRECT_MEMORY_ACCESS */
-
-
-/* ****************************************
-*  Compiler-specific Functions and Macros
-******************************************/
-#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-
-/* Note : although _rotl exists for minGW (GCC under windows), performance seems poor */
-#if defined(_MSC_VER)
-#  define XXH_rotl32(x,r) _rotl(x,r)
-#  define XXH_rotl64(x,r) _rotl64(x,r)
-#else
-#  define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r)))
-#  define XXH_rotl64(x,r) ((x << r) | (x >> (64 - r)))
-#endif
-
-#if defined(_MSC_VER)     /* Visual Studio */
-#  define XXH_swap32 _byteswap_ulong
-#  define XXH_swap64 _byteswap_uint64
-#elif GCC_VERSION >= 403
-#  define XXH_swap32 __builtin_bswap32
-#  define XXH_swap64 __builtin_bswap64
-#else
-static U32 XXH_swap32 (U32 x)
-{
-    return  ((x << 24) & 0xff000000 ) |
-            ((x <<  8) & 0x00ff0000 ) |
-            ((x >>  8) & 0x0000ff00 ) |
-            ((x >> 24) & 0x000000ff );
-}
-static U64 XXH_swap64 (U64 x)
-{
-    return  ((x << 56) & 0xff00000000000000ULL) |
-            ((x << 40) & 0x00ff000000000000ULL) |
-            ((x << 24) & 0x0000ff0000000000ULL) |
-            ((x << 8)  & 0x000000ff00000000ULL) |
-            ((x >> 8)  & 0x00000000ff000000ULL) |
-            ((x >> 24) & 0x0000000000ff0000ULL) |
-            ((x >> 40) & 0x000000000000ff00ULL) |
-            ((x >> 56) & 0x00000000000000ffULL);
-}
-#endif
-
-
-/* *************************************
-*  Architecture Macros
-***************************************/
-typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;
-
-/* XXH_CPU_LITTLE_ENDIAN can be defined externally, for example on the compiler command line */
-#ifndef XXH_CPU_LITTLE_ENDIAN
-    static const int g_one = 1;
-#   define XXH_CPU_LITTLE_ENDIAN   (*(const char*)(&g_one))
-#endif
-
-
-/* ***************************
-*  Memory reads
-*****************************/
-typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;
-
-FORCE_INLINE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
-{
-    if (align==XXH_unaligned)
-        return endian==XXH_littleEndian ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr));
-    else
-        return endian==XXH_littleEndian ? *(const U32*)ptr : XXH_swap32(*(const U32*)ptr);
-}
-
-FORCE_INLINE U32 XXH_readLE32(const void* ptr, XXH_endianess endian)
-{
-    return XXH_readLE32_align(ptr, endian, XXH_unaligned);
-}
-
-static U32 XXH_readBE32(const void* ptr)
-{
-    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr);
-}
-
-FORCE_INLINE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
-{
-    if (align==XXH_unaligned)
-        return endian==XXH_littleEndian ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr));
-    else
-        return endian==XXH_littleEndian ? *(const U64*)ptr : XXH_swap64(*(const U64*)ptr);
-}
-
-FORCE_INLINE U64 XXH_readLE64(const void* ptr, XXH_endianess endian)
-{
-    return XXH_readLE64_align(ptr, endian, XXH_unaligned);
-}
-
-static U64 XXH_readBE64(const void* ptr)
-{
-    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr);
-}
-
-
-/* *************************************
-*  Macros
-***************************************/
-#define XXH_STATIC_ASSERT(c)   { enum { XXH_static_assert = 1/(int)(!!(c)) }; }    /* use only *after* variable declarations */
-
-
-/* *************************************
-*  Constants
-***************************************/
-static const U32 PRIME32_1 = 2654435761U;
-static const U32 PRIME32_2 = 2246822519U;
-static const U32 PRIME32_3 = 3266489917U;
-static const U32 PRIME32_4 =  668265263U;
-static const U32 PRIME32_5 =  374761393U;
-
-static const U64 PRIME64_1 = 11400714785074694791ULL;
-static const U64 PRIME64_2 = 14029467366897019727ULL;
-static const U64 PRIME64_3 =  1609587929392839161ULL;
-static const U64 PRIME64_4 =  9650029242287828579ULL;
-static const U64 PRIME64_5 =  2870177450012600261ULL;
-
-XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; }
-
-
-/* ***************************
-*  Simple Hash Functions
-*****************************/
-
-static U32 XXH32_round(U32 seed, U32 input)
-{
-    seed += input * PRIME32_2;
-    seed  = XXH_rotl32(seed, 13);
-    seed *= PRIME32_1;
-    return seed;
-}
-
-FORCE_INLINE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align)
-{
-    const BYTE* p = (const BYTE*)input;
-    const BYTE* bEnd = p + len;
-    U32 h32;
-#define XXH_get32bits(p) XXH_readLE32_align(p, endian, align)
-
-#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
-    if (p==NULL) {
-        len=0;
-        bEnd=p=(const BYTE*)(size_t)16;
-    }
-#endif
-
-    if (len>=16) {
-        const BYTE* const limit = bEnd - 16;
-        U32 v1 = seed + PRIME32_1 + PRIME32_2;
-        U32 v2 = seed + PRIME32_2;
-        U32 v3 = seed + 0;
-        U32 v4 = seed - PRIME32_1;
-
-        do {
-            v1 = XXH32_round(v1, XXH_get32bits(p)); p+=4;
-            v2 = XXH32_round(v2, XXH_get32bits(p)); p+=4;
-            v3 = XXH32_round(v3, XXH_get32bits(p)); p+=4;
-            v4 = XXH32_round(v4, XXH_get32bits(p)); p+=4;
-        } while (p<=limit);
-
-        h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);
-    } else {
-        h32  = seed + PRIME32_5;
-    }
-
-    h32 += (U32) len;
-
-    while (p+4<=bEnd) {
-        h32 += XXH_get32bits(p) * PRIME32_3;
-        h32  = XXH_rotl32(h32, 17) * PRIME32_4 ;
-        p+=4;
-    }
-
-    while (p<bEnd) {
-        h32 += (*p) * PRIME32_5;
-        h32 = XXH_rotl32(h32, 11) * PRIME32_1 ;
-        p++;
-    }
-
-    h32 ^= h32 >> 15;
-    h32 *= PRIME32_2;
-    h32 ^= h32 >> 13;
-    h32 *= PRIME32_3;
-    h32 ^= h32 >> 16;
-
-    return h32;
-}
-
-
-XXH_PUBLIC_API unsigned int XXH32 (const void* input, size_t len, unsigned int seed)
-{
-#if 0
-    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
-    XXH32_CREATESTATE_STATIC(state);
-    XXH32_reset(state, seed);
-    XXH32_update(state, input, len);
-    return XXH32_digest(state);
-#else
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if (XXH_FORCE_ALIGN_CHECK) {
-        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */
-            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-                return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
-            else
-                return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
-    }   }
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
-    else
-        return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
-#endif
-}
-
-
-static U64 XXH64_round(U64 acc, U64 input)
-{
-    acc += input * PRIME64_2;
-    acc  = XXH_rotl64(acc, 31);
-    acc *= PRIME64_1;
-    return acc;
-}
-
-static U64 XXH64_mergeRound(U64 acc, U64 val)
-{
-    val  = XXH64_round(0, val);
-    acc ^= val;
-    acc  = acc * PRIME64_1 + PRIME64_4;
-    return acc;
-}
-
-FORCE_INLINE U64 XXH64_endian_align(const void* input, size_t len, U64 seed, XXH_endianess endian, XXH_alignment align)
-{
-    const BYTE* p = (const BYTE*)input;
-    const BYTE* const bEnd = p + len;
-    U64 h64;
-#define XXH_get64bits(p) XXH_readLE64_align(p, endian, align)
-
-#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
-    if (p==NULL) {
-        len=0;
-        bEnd=p=(const BYTE*)(size_t)32;
-    }
-#endif
-
-    if (len>=32) {
-        const BYTE* const limit = bEnd - 32;
-        U64 v1 = seed + PRIME64_1 + PRIME64_2;
-        U64 v2 = seed + PRIME64_2;
-        U64 v3 = seed + 0;
-        U64 v4 = seed - PRIME64_1;
-
-        do {
-            v1 = XXH64_round(v1, XXH_get64bits(p)); p+=8;
-            v2 = XXH64_round(v2, XXH_get64bits(p)); p+=8;
-            v3 = XXH64_round(v3, XXH_get64bits(p)); p+=8;
-            v4 = XXH64_round(v4, XXH_get64bits(p)); p+=8;
-        } while (p<=limit);
-
-        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
-        h64 = XXH64_mergeRound(h64, v1);
-        h64 = XXH64_mergeRound(h64, v2);
-        h64 = XXH64_mergeRound(h64, v3);
-        h64 = XXH64_mergeRound(h64, v4);
-
-    } else {
-        h64  = seed + PRIME64_5;
-    }
-
-    h64 += (U64) len;
-
-    while (p+8<=bEnd) {
-        U64 const k1 = XXH64_round(0, XXH_get64bits(p));
-        h64 ^= k1;
-        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
-        p+=8;
-    }
-
-    if (p+4<=bEnd) {
-        h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
-        h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
-        p+=4;
-    }
-
-    while (p<bEnd) {
-        h64 ^= (*p) * PRIME64_5;
-        h64 = XXH_rotl64(h64, 11) * PRIME64_1;
-        p++;
-    }
-
-    h64 ^= h64 >> 33;
-    h64 *= PRIME64_2;
-    h64 ^= h64 >> 29;
-    h64 *= PRIME64_3;
-    h64 ^= h64 >> 32;
-
-    return h64;
-}
-
-
-XXH_PUBLIC_API unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed)
-{
-#if 0
-    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
-    XXH64_CREATESTATE_STATIC(state);
-    XXH64_reset(state, seed);
-    XXH64_update(state, input, len);
-    return XXH64_digest(state);
-#else
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if (XXH_FORCE_ALIGN_CHECK) {
-        if ((((size_t)input) & 7)==0) {  /* Input is aligned, let's leverage the speed advantage */
-            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-                return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
-            else
-                return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
-    }   }
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
-    else
-        return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
-#endif
-}
-
-
-/* **************************************************
-*  Advanced Hash Functions
-****************************************************/
-
-XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)
-{
-    return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));
-}
-XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)
-{
-    XXH_free(statePtr);
-    return XXH_OK;
-}
-
-XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void)
-{
-    return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t));
-}
-XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)
-{
-    XXH_free(statePtr);
-    return XXH_OK;
-}
-
-
-/*** Hash feed ***/
-
-XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed)
-{
-    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
-    memset(&state, 0, sizeof(state));
-    state.seed = seed;
-    state.v1 = seed + PRIME32_1 + PRIME32_2;
-    state.v2 = seed + PRIME32_2;
-    state.v3 = seed + 0;
-    state.v4 = seed - PRIME32_1;
-    memcpy(statePtr, &state, sizeof(state));
-    return XXH_OK;
-}
-
-
-XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed)
-{
-    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
-    memset(&state, 0, sizeof(state));
-    state.seed = seed;
-    state.v1 = seed + PRIME64_1 + PRIME64_2;
-    state.v2 = seed + PRIME64_2;
-    state.v3 = seed + 0;
-    state.v4 = seed - PRIME64_1;
-    memcpy(statePtr, &state, sizeof(state));
-    return XXH_OK;
-}
-
-
-FORCE_INLINE XXH_errorcode XXH32_update_endian (XXH32_state_t* state, const void* input, size_t len, XXH_endianess endian)
-{
-    const BYTE* p = (const BYTE*)input;
-    const BYTE* const bEnd = p + len;
-
-#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
-    if (input==NULL) return XXH_ERROR;
-#endif
-
-    state->total_len += len;
-
-    if (state->memsize + len < 16)  {   /* fill in tmp buffer */
-        XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len);
-        state->memsize += (U32)len;
-        return XXH_OK;
-    }
-
-    if (state->memsize) {   /* some data left from previous update */
-        XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize);
-        {   const U32* p32 = state->mem32;
-            state->v1 = XXH32_round(state->v1, XXH_readLE32(p32, endian)); p32++;
-            state->v2 = XXH32_round(state->v2, XXH_readLE32(p32, endian)); p32++;
-            state->v3 = XXH32_round(state->v3, XXH_readLE32(p32, endian)); p32++;
-            state->v4 = XXH32_round(state->v4, XXH_readLE32(p32, endian)); p32++;
-        }
-        p += 16-state->memsize;
-        state->memsize = 0;
-    }
-
-    if (p <= bEnd-16) {
-        const BYTE* const limit = bEnd - 16;
-        U32 v1 = state->v1;
-        U32 v2 = state->v2;
-        U32 v3 = state->v3;
-        U32 v4 = state->v4;
-
-        do {
-            v1 = XXH32_round(v1, XXH_readLE32(p, endian)); p+=4;
-            v2 = XXH32_round(v2, XXH_readLE32(p, endian)); p+=4;
-            v3 = XXH32_round(v3, XXH_readLE32(p, endian)); p+=4;
-            v4 = XXH32_round(v4, XXH_readLE32(p, endian)); p+=4;
-        } while (p<=limit);
-
-        state->v1 = v1;
-        state->v2 = v2;
-        state->v3 = v3;
-        state->v4 = v4;
-    }
-
-    if (p < bEnd) {
-        XXH_memcpy(state->mem32, p, bEnd-p);
-        state->memsize = (int)(bEnd-p);
-    }
-
-    return XXH_OK;
-}
-
-XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void* input, size_t len)
-{
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH32_update_endian(state_in, input, len, XXH_littleEndian);
-    else
-        return XXH32_update_endian(state_in, input, len, XXH_bigEndian);
-}
-
-
-
-FORCE_INLINE U32 XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian)
-{
-    const BYTE * p = (const BYTE*)state->mem32;
-    const BYTE* const bEnd = (const BYTE*)(state->mem32) + state->memsize;
-    U32 h32;
-
-    if (state->total_len >= 16) {
-        h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18);
-    } else {
-        h32 = state->seed + PRIME32_5;
-    }
-
-    h32 += (U32) state->total_len;
-
-    while (p+4<=bEnd) {
-        h32 += XXH_readLE32(p, endian) * PRIME32_3;
-        h32  = XXH_rotl32(h32, 17) * PRIME32_4;
-        p+=4;
-    }
-
-    while (p<bEnd) {
-        h32 += (*p) * PRIME32_5;
-        h32  = XXH_rotl32(h32, 11) * PRIME32_1;
-        p++;
-    }
-
-    h32 ^= h32 >> 15;
-    h32 *= PRIME32_2;
-    h32 ^= h32 >> 13;
-    h32 *= PRIME32_3;
-    h32 ^= h32 >> 16;
-
-    return h32;
-}
-
-
-XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in)
-{
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH32_digest_endian(state_in, XXH_littleEndian);
-    else
-        return XXH32_digest_endian(state_in, XXH_bigEndian);
-}
-
-
-
-/* **** XXH64 **** */
-
-FORCE_INLINE XXH_errorcode XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianess endian)
-{
-    const BYTE* p = (const BYTE*)input;
-    const BYTE* const bEnd = p + len;
-
-#ifdef XXH_ACCEPT_NULL_INPUT_POINTER
-    if (input==NULL) return XXH_ERROR;
-#endif
-
-    state->total_len += len;
-
-    if (state->memsize + len < 32) {  /* fill in tmp buffer */
-        XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len);
-        state->memsize += (U32)len;
-        return XXH_OK;
-    }
-
-    if (state->memsize) {   /* tmp buffer is full */
-        XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize);
-        state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0, endian));
-        state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1, endian));
-        state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2, endian));
-        state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3, endian));
-        p += 32-state->memsize;
-        state->memsize = 0;
-    }
-
-    if (p+32 <= bEnd) {
-        const BYTE* const limit = bEnd - 32;
-        U64 v1 = state->v1;
-        U64 v2 = state->v2;
-        U64 v3 = state->v3;
-        U64 v4 = state->v4;
-
-        do {
-            v1 = XXH64_round(v1, XXH_readLE64(p, endian)); p+=8;
-            v2 = XXH64_round(v2, XXH_readLE64(p, endian)); p+=8;
-            v3 = XXH64_round(v3, XXH_readLE64(p, endian)); p+=8;
-            v4 = XXH64_round(v4, XXH_readLE64(p, endian)); p+=8;
-        } while (p<=limit);
-
-        state->v1 = v1;
-        state->v2 = v2;
-        state->v3 = v3;
-        state->v4 = v4;
-    }
-
-    if (p < bEnd) {
-        XXH_memcpy(state->mem64, p, bEnd-p);
-        state->memsize = (int)(bEnd-p);
-    }
-
-    return XXH_OK;
-}
-
-XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t len)
-{
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH64_update_endian(state_in, input, len, XXH_littleEndian);
-    else
-        return XXH64_update_endian(state_in, input, len, XXH_bigEndian);
-}
-
-
-
-FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianess endian)
-{
-    const BYTE * p = (const BYTE*)state->mem64;
-    const BYTE* const bEnd = (const BYTE*)state->mem64 + state->memsize;
-    U64 h64;
-
-    if (state->total_len >= 32) {
-        U64 const v1 = state->v1;
-        U64 const v2 = state->v2;
-        U64 const v3 = state->v3;
-        U64 const v4 = state->v4;
-
-        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
-        h64 = XXH64_mergeRound(h64, v1);
-        h64 = XXH64_mergeRound(h64, v2);
-        h64 = XXH64_mergeRound(h64, v3);
-        h64 = XXH64_mergeRound(h64, v4);
-    } else {
-        h64  = state->seed + PRIME64_5;
-    }
-
-    h64 += (U64) state->total_len;
-
-    while (p+8<=bEnd) {
-        U64 const k1 = XXH64_round(0, XXH_readLE64(p, endian));
-        h64 ^= k1;
-        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
-        p+=8;
-    }
-
-    if (p+4<=bEnd) {
-        h64 ^= (U64)(XXH_readLE32(p, endian)) * PRIME64_1;
-        h64  = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
-        p+=4;
-    }
-
-    while (p<bEnd) {
-        h64 ^= (*p) * PRIME64_5;
-        h64  = XXH_rotl64(h64, 11) * PRIME64_1;
-        p++;
-    }
-
-    h64 ^= h64 >> 33;
-    h64 *= PRIME64_2;
-    h64 ^= h64 >> 29;
-    h64 *= PRIME64_3;
-    h64 ^= h64 >> 32;
-
-    return h64;
-}
-
-
-XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in)
-{
-    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH64_digest_endian(state_in, XXH_littleEndian);
-    else
-        return XXH64_digest_endian(state_in, XXH_bigEndian);
-}
-
-
-/* **************************
-*  Canonical representation
-****************************/
-
-/*! Default XXH result types are basic unsigned 32 and 64 bits.
-*   The canonical representation follows human-readable write convention, aka big-endian (large digits first).
-*   These functions allow transformation of hash result into and from its canonical format.
-*   This way, hash values can be written into a file or buffer, and remain comparable across different systems and programs.
-*/
-
-XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash)
-{
-    XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t));
-    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash);
-    memcpy(dst, &hash, sizeof(*dst));
-}
-
-XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash)
-{
-    XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t));
-    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash);
-    memcpy(dst, &hash, sizeof(*dst));
-}
-
-XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src)
-{
-    return XXH_readBE32(src);
-}
-
-XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src)
-{
-    return XXH_readBE64(src);
-}
+/* 
+*  xxHash - Fast Hash algorithm 
+*  Copyright (C) 2012-2016, Yann Collet 
+* 
+*  BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+* 
+*  Redistribution and use in source and binary forms, with or without 
+*  modification, are permitted provided that the following conditions are 
+*  met: 
+* 
+*  * Redistributions of source code must retain the above copyright 
+*  notice, this list of conditions and the following disclaimer. 
+*  * Redistributions in binary form must reproduce the above 
+*  copyright notice, this list of conditions and the following disclaimer 
+*  in the documentation and/or other materials provided with the 
+*  distribution. 
+* 
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+*  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+*  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+* 
+*  You can contact the author at : 
+*  - xxHash homepage: http://www.xxhash.com 
+*  - xxHash source repository : https://github.com/Cyan4973/xxHash 
+*/ 
+ 
+ 
+/* ************************************* 
+*  Tuning parameters 
+***************************************/ 
+/*!XXH_FORCE_MEMORY_ACCESS : 
+ * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable. 
+ * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal. 
+ * The below switch allow to select different access method for improved performance. 
+ * Method 0 (default) : use `memcpy()`. Safe and portable. 
+ * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable). 
+ *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`. 
+ * Method 2 : direct access. This method doesn't depend on compiler but violate C standard. 
+ *            It can generate buggy code on targets which do not support unaligned memory accesses. 
+ *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) 
+ * See http://stackoverflow.com/a/32095106/646947 for details. 
+ * Prefer these methods in priority order (0 > 1 > 2) 
+ */ 
+#ifndef XXH_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */ 
+#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) ) 
+#    define XXH_FORCE_MEMORY_ACCESS 2 
+#  elif defined(__INTEL_COMPILER) || \ 
+  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__) )) 
+#    define XXH_FORCE_MEMORY_ACCESS 1 
+#  endif 
+#endif 
+ 
+/*!XXH_ACCEPT_NULL_INPUT_POINTER : 
+ * If the input pointer is a null pointer, xxHash default behavior is to trigger a memory access error, since it is a bad pointer. 
+ * When this option is enabled, xxHash output for null input pointers will be the same as a null-length input. 
+ * By default, this option is disabled. To enable it, uncomment below define : 
+ */ 
+/* #define XXH_ACCEPT_NULL_INPUT_POINTER 1 */ 
+ 
+/*!XXH_FORCE_NATIVE_FORMAT : 
+ * By default, xxHash library provides endian-independant Hash values, based on little-endian convention. 
+ * Results are therefore identical for little-endian and big-endian CPU. 
+ * This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format. 
+ * Should endian-independance be of no importance for your application, you may set the #define below to 1, 
+ * to improve speed for Big-endian CPU. 
+ * This option has no impact on Little_Endian CPU. 
+ */ 
+#ifndef XXH_FORCE_NATIVE_FORMAT   /* can be defined externally */ 
+#  define XXH_FORCE_NATIVE_FORMAT 0 
+#endif 
+ 
+/*!XXH_FORCE_ALIGN_CHECK : 
+ * This is a minor performance trick, only useful with lots of very small keys. 
+ * It means : check for aligned/unaligned input. 
+ * The check costs one initial branch per hash; set to 0 when the input data 
+ * is guaranteed to be aligned. 
+ */ 
+#ifndef XXH_FORCE_ALIGN_CHECK /* can be defined externally */ 
+#  if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64) 
+#    define XXH_FORCE_ALIGN_CHECK 0 
+#  else 
+#    define XXH_FORCE_ALIGN_CHECK 1 
+#  endif 
+#endif 
+ 
+ 
+/* ************************************* 
+*  Includes & Memory related functions 
+***************************************/ 
+/* Modify the local functions below should you wish to use some other memory routines */ 
+/* for malloc(), free() */ 
+#include <stdlib.h> 
+static void* XXH_malloc(size_t s) { return malloc(s); } 
+static void  XXH_free  (void* p)  { free(p); } 
+/* for memcpy() */ 
+#include <string.h> 
+static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); } 
+ 
+#define XXH_STATIC_LINKING_ONLY 
+#include "xxhash.h" 
+ 
+ 
+/* ************************************* 
+*  Compiler Specific Options 
+***************************************/ 
+#ifdef _MSC_VER    /* Visual Studio */ 
+#  pragma warning(disable : 4127)      /* disable: C4127: conditional expression is constant */ 
+#  define FORCE_INLINE static __forceinline 
+#else 
+#  if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */ 
+#    ifdef __GNUC__ 
+#      define FORCE_INLINE static inline __attribute__((always_inline)) 
+#    else 
+#      define FORCE_INLINE static inline 
+#    endif 
+#  else 
+#    define FORCE_INLINE static 
+#  endif /* __STDC_VERSION__ */ 
+#endif 
+ 
+ 
+/* ************************************* 
+*  Basic Types 
+***************************************/ 
+#ifndef MEM_MODULE 
+# define MEM_MODULE 
+# if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */ 
+#   include <stdint.h> 
+    typedef uint8_t  BYTE; 
+    typedef uint16_t U16; 
+    typedef uint32_t U32; 
+    typedef  int32_t S32; 
+    typedef uint64_t U64; 
+#  else 
+    typedef unsigned char      BYTE; 
+    typedef unsigned short     U16; 
+    typedef unsigned int       U32; 
+    typedef   signed int       S32; 
+    typedef unsigned long long U64; 
+#  endif 
+#endif 
+ 
+ 
+#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2)) 
+ 
+/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */ 
+static U32 XXH_read32(const void* memPtr) { return *(const U32*) memPtr; } 
+static U64 XXH_read64(const void* memPtr) { return *(const U64*) memPtr; } 
+ 
+#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1)) 
+ 
+/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */ 
+/* currently only defined for gcc and icc */ 
+typedef union { U32 u32; U64 u64; } __attribute__((packed)) unalign; 
+ 
+static U32 XXH_read32(const void* ptr) { return ((const unalign*)ptr)->u32; } 
+static U64 XXH_read64(const void* ptr) { return ((const unalign*)ptr)->u64; } 
+ 
+#else 
+ 
+/* portable and safe solution. Generally efficient. 
+ * see : http://stackoverflow.com/a/32095106/646947 
+ */ 
+ 
+static U32 XXH_read32(const void* memPtr) 
+{ 
+    U32 val; 
+    memcpy(&val, memPtr, sizeof(val)); 
+    return val; 
+} 
+ 
+static U64 XXH_read64(const void* memPtr) 
+{ 
+    U64 val; 
+    memcpy(&val, memPtr, sizeof(val)); 
+    return val; 
+} 
+ 
+#endif   /* XXH_FORCE_DIRECT_MEMORY_ACCESS */ 
+ 
+ 
+/* **************************************** 
+*  Compiler-specific Functions and Macros 
+******************************************/ 
+#define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) 
+ 
+/* Note : although _rotl exists for minGW (GCC under windows), performance seems poor */ 
+#if defined(_MSC_VER) 
+#  define XXH_rotl32(x,r) _rotl(x,r) 
+#  define XXH_rotl64(x,r) _rotl64(x,r) 
+#else 
+#  define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r))) 
+#  define XXH_rotl64(x,r) ((x << r) | (x >> (64 - r))) 
+#endif 
+ 
+#if defined(_MSC_VER)     /* Visual Studio */ 
+#  define XXH_swap32 _byteswap_ulong 
+#  define XXH_swap64 _byteswap_uint64 
+#elif GCC_VERSION >= 403 
+#  define XXH_swap32 __builtin_bswap32 
+#  define XXH_swap64 __builtin_bswap64 
+#else 
+static U32 XXH_swap32 (U32 x) 
+{ 
+    return  ((x << 24) & 0xff000000 ) | 
+            ((x <<  8) & 0x00ff0000 ) | 
+            ((x >>  8) & 0x0000ff00 ) | 
+            ((x >> 24) & 0x000000ff ); 
+} 
+static U64 XXH_swap64 (U64 x) 
+{ 
+    return  ((x << 56) & 0xff00000000000000ULL) | 
+            ((x << 40) & 0x00ff000000000000ULL) | 
+            ((x << 24) & 0x0000ff0000000000ULL) | 
+            ((x << 8)  & 0x000000ff00000000ULL) | 
+            ((x >> 8)  & 0x00000000ff000000ULL) | 
+            ((x >> 24) & 0x0000000000ff0000ULL) | 
+            ((x >> 40) & 0x000000000000ff00ULL) | 
+            ((x >> 56) & 0x00000000000000ffULL); 
+} 
+#endif 
+ 
+ 
+/* ************************************* 
+*  Architecture Macros 
+***************************************/ 
+typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess; 
+ 
+/* XXH_CPU_LITTLE_ENDIAN can be defined externally, for example on the compiler command line */ 
+#ifndef XXH_CPU_LITTLE_ENDIAN 
+    static const int g_one = 1; 
+#   define XXH_CPU_LITTLE_ENDIAN   (*(const char*)(&g_one)) 
+#endif 
+ 
+ 
+/* *************************** 
+*  Memory reads 
+*****************************/ 
+typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment; 
+ 
+FORCE_INLINE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_alignment align) 
+{ 
+    if (align==XXH_unaligned) 
+        return endian==XXH_littleEndian ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr)); 
+    else 
+        return endian==XXH_littleEndian ? *(const U32*)ptr : XXH_swap32(*(const U32*)ptr); 
+} 
+ 
+FORCE_INLINE U32 XXH_readLE32(const void* ptr, XXH_endianess endian) 
+{ 
+    return XXH_readLE32_align(ptr, endian, XXH_unaligned); 
+} 
+ 
+static U32 XXH_readBE32(const void* ptr) 
+{ 
+    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr); 
+} 
+ 
+FORCE_INLINE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_alignment align) 
+{ 
+    if (align==XXH_unaligned) 
+        return endian==XXH_littleEndian ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr)); 
+    else 
+        return endian==XXH_littleEndian ? *(const U64*)ptr : XXH_swap64(*(const U64*)ptr); 
+} 
+ 
+FORCE_INLINE U64 XXH_readLE64(const void* ptr, XXH_endianess endian) 
+{ 
+    return XXH_readLE64_align(ptr, endian, XXH_unaligned); 
+} 
+ 
+static U64 XXH_readBE64(const void* ptr) 
+{ 
+    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr); 
+} 
+ 
+ 
+/* ************************************* 
+*  Macros 
+***************************************/ 
+#define XXH_STATIC_ASSERT(c)   { enum { XXH_static_assert = 1/(int)(!!(c)) }; }    /* use only *after* variable declarations */ 
+ 
+ 
+/* ************************************* 
+*  Constants 
+***************************************/ 
+static const U32 PRIME32_1 = 2654435761U; 
+static const U32 PRIME32_2 = 2246822519U; 
+static const U32 PRIME32_3 = 3266489917U; 
+static const U32 PRIME32_4 =  668265263U; 
+static const U32 PRIME32_5 =  374761393U; 
+ 
+static const U64 PRIME64_1 = 11400714785074694791ULL; 
+static const U64 PRIME64_2 = 14029467366897019727ULL; 
+static const U64 PRIME64_3 =  1609587929392839161ULL; 
+static const U64 PRIME64_4 =  9650029242287828579ULL; 
+static const U64 PRIME64_5 =  2870177450012600261ULL; 
+ 
+XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; } 
+ 
+ 
+/* *************************** 
+*  Simple Hash Functions 
+*****************************/ 
+ 
+static U32 XXH32_round(U32 seed, U32 input) 
+{ 
+    seed += input * PRIME32_2; 
+    seed  = XXH_rotl32(seed, 13); 
+    seed *= PRIME32_1; 
+    return seed; 
+} 
+ 
+FORCE_INLINE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align) 
+{ 
+    const BYTE* p = (const BYTE*)input; 
+    const BYTE* bEnd = p + len; 
+    U32 h32; 
+#define XXH_get32bits(p) XXH_readLE32_align(p, endian, align) 
+ 
+#ifdef XXH_ACCEPT_NULL_INPUT_POINTER 
+    if (p==NULL) { 
+        len=0; 
+        bEnd=p=(const BYTE*)(size_t)16; 
+    } 
+#endif 
+ 
+    if (len>=16) { 
+        const BYTE* const limit = bEnd - 16; 
+        U32 v1 = seed + PRIME32_1 + PRIME32_2; 
+        U32 v2 = seed + PRIME32_2; 
+        U32 v3 = seed + 0; 
+        U32 v4 = seed - PRIME32_1; 
+ 
+        do { 
+            v1 = XXH32_round(v1, XXH_get32bits(p)); p+=4; 
+            v2 = XXH32_round(v2, XXH_get32bits(p)); p+=4; 
+            v3 = XXH32_round(v3, XXH_get32bits(p)); p+=4; 
+            v4 = XXH32_round(v4, XXH_get32bits(p)); p+=4; 
+        } while (p<=limit); 
+ 
+        h32 = XXH_rotl32(v1, 1) + XXH_rotl32(v2, 7) + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18); 
+    } else { 
+        h32  = seed + PRIME32_5; 
+    } 
+ 
+    h32 += (U32) len; 
+ 
+    while (p+4<=bEnd) { 
+        h32 += XXH_get32bits(p) * PRIME32_3; 
+        h32  = XXH_rotl32(h32, 17) * PRIME32_4 ; 
+        p+=4; 
+    } 
+ 
+    while (p<bEnd) { 
+        h32 += (*p) * PRIME32_5; 
+        h32 = XXH_rotl32(h32, 11) * PRIME32_1 ; 
+        p++; 
+    } 
+ 
+    h32 ^= h32 >> 15; 
+    h32 *= PRIME32_2; 
+    h32 ^= h32 >> 13; 
+    h32 *= PRIME32_3; 
+    h32 ^= h32 >> 16; 
+ 
+    return h32; 
+} 
+ 
+ 
+XXH_PUBLIC_API unsigned int XXH32 (const void* input, size_t len, unsigned int seed) 
+{ 
+#if 0 
+    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */ 
+    XXH32_CREATESTATE_STATIC(state); 
+    XXH32_reset(state, seed); 
+    XXH32_update(state, input, len); 
+    return XXH32_digest(state); 
+#else 
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; 
+ 
+    if (XXH_FORCE_ALIGN_CHECK) { 
+        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */ 
+            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) 
+                return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned); 
+            else 
+                return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned); 
+    }   } 
+ 
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) 
+        return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned); 
+    else 
+        return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned); 
+#endif 
+} 
+ 
+ 
+static U64 XXH64_round(U64 acc, U64 input) 
+{ 
+    acc += input * PRIME64_2; 
+    acc  = XXH_rotl64(acc, 31); 
+    acc *= PRIME64_1; 
+    return acc; 
+} 
+ 
+static U64 XXH64_mergeRound(U64 acc, U64 val) 
+{ 
+    val  = XXH64_round(0, val); 
+    acc ^= val; 
+    acc  = acc * PRIME64_1 + PRIME64_4; 
+    return acc; 
+} 
+ 
+FORCE_INLINE U64 XXH64_endian_align(const void* input, size_t len, U64 seed, XXH_endianess endian, XXH_alignment align) 
+{ 
+    const BYTE* p = (const BYTE*)input; 
+    const BYTE* const bEnd = p + len; 
+    U64 h64; 
+#define XXH_get64bits(p) XXH_readLE64_align(p, endian, align) 
+ 
+#ifdef XXH_ACCEPT_NULL_INPUT_POINTER 
+    if (p==NULL) { 
+        len=0; 
+        bEnd=p=(const BYTE*)(size_t)32; 
+    } 
+#endif 
+ 
+    if (len>=32) { 
+        const BYTE* const limit = bEnd - 32; 
+        U64 v1 = seed + PRIME64_1 + PRIME64_2; 
+        U64 v2 = seed + PRIME64_2; 
+        U64 v3 = seed + 0; 
+        U64 v4 = seed - PRIME64_1; 
+ 
+        do { 
+            v1 = XXH64_round(v1, XXH_get64bits(p)); p+=8; 
+            v2 = XXH64_round(v2, XXH_get64bits(p)); p+=8; 
+            v3 = XXH64_round(v3, XXH_get64bits(p)); p+=8; 
+            v4 = XXH64_round(v4, XXH_get64bits(p)); p+=8; 
+        } while (p<=limit); 
+ 
+        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18); 
+        h64 = XXH64_mergeRound(h64, v1); 
+        h64 = XXH64_mergeRound(h64, v2); 
+        h64 = XXH64_mergeRound(h64, v3); 
+        h64 = XXH64_mergeRound(h64, v4); 
+ 
+    } else { 
+        h64  = seed + PRIME64_5; 
+    } 
+ 
+    h64 += (U64) len; 
+ 
+    while (p+8<=bEnd) { 
+        U64 const k1 = XXH64_round(0, XXH_get64bits(p)); 
+        h64 ^= k1; 
+        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4; 
+        p+=8; 
+    } 
+ 
+    if (p+4<=bEnd) { 
+        h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1; 
+        h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3; 
+        p+=4; 
+    } 
+ 
+    while (p<bEnd) { 
+        h64 ^= (*p) * PRIME64_5; 
+        h64 = XXH_rotl64(h64, 11) * PRIME64_1; 
+        p++; 
+    } 
+ 
+    h64 ^= h64 >> 33; 
+    h64 *= PRIME64_2; 
+    h64 ^= h64 >> 29; 
+    h64 *= PRIME64_3; 
+    h64 ^= h64 >> 32; 
+ 
+    return h64; 
+} 
+ 
+ 
+XXH_PUBLIC_API unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed) 
+{ 
+#if 0 
+    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */ 
+    XXH64_CREATESTATE_STATIC(state); 
+    XXH64_reset(state, seed); 
+    XXH64_update(state, input, len); 
+    return XXH64_digest(state); 
+#else 
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; 
+ 
+    if (XXH_FORCE_ALIGN_CHECK) { 
+        if ((((size_t)input) & 7)==0) {  /* Input is aligned, let's leverage the speed advantage */ 
+            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) 
+                return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned); 
+            else 
+                return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned); 
+    }   } 
+ 
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) 
+        return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned); 
+    else 
+        return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned); 
+#endif 
+} 
+ 
+ 
+/* ************************************************** 
+*  Advanced Hash Functions 
+****************************************************/ 
+ 
+XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void) 
+{ 
+    return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t)); 
+} 
+XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr) 
+{ 
+    XXH_free(statePtr); 
+    return XXH_OK; 
+} 
+ 
+XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void) 
+{ 
+    return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t)); 
+} 
+XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr) 
+{ 
+    XXH_free(statePtr); 
+    return XXH_OK; 
+} 
+ 
+ 
+/*** Hash feed ***/ 
+ 
+XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed) 
+{ 
+    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */ 
+    memset(&state, 0, sizeof(state)); 
+    state.seed = seed; 
+    state.v1 = seed + PRIME32_1 + PRIME32_2; 
+    state.v2 = seed + PRIME32_2; 
+    state.v3 = seed + 0; 
+    state.v4 = seed - PRIME32_1; 
+    memcpy(statePtr, &state, sizeof(state)); 
+    return XXH_OK; 
+} 
+ 
+ 
+XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed) 
+{ 
+    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */ 
+    memset(&state, 0, sizeof(state)); 
+    state.seed = seed; 
+    state.v1 = seed + PRIME64_1 + PRIME64_2; 
+    state.v2 = seed + PRIME64_2; 
+    state.v3 = seed + 0; 
+    state.v4 = seed - PRIME64_1; 
+    memcpy(statePtr, &state, sizeof(state)); 
+    return XXH_OK; 
+} 
+ 
+ 
+FORCE_INLINE XXH_errorcode XXH32_update_endian (XXH32_state_t* state, const void* input, size_t len, XXH_endianess endian) 
+{ 
+    const BYTE* p = (const BYTE*)input; 
+    const BYTE* const bEnd = p + len; 
+ 
+#ifdef XXH_ACCEPT_NULL_INPUT_POINTER 
+    if (input==NULL) return XXH_ERROR; 
+#endif 
+ 
+    state->total_len += len; 
+ 
+    if (state->memsize + len < 16)  {   /* fill in tmp buffer */ 
+        XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len); 
+        state->memsize += (U32)len; 
+        return XXH_OK; 
+    } 
+ 
+    if (state->memsize) {   /* some data left from previous update */ 
+        XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize); 
+        {   const U32* p32 = state->mem32; 
+            state->v1 = XXH32_round(state->v1, XXH_readLE32(p32, endian)); p32++; 
+            state->v2 = XXH32_round(state->v2, XXH_readLE32(p32, endian)); p32++; 
+            state->v3 = XXH32_round(state->v3, XXH_readLE32(p32, endian)); p32++; 
+            state->v4 = XXH32_round(state->v4, XXH_readLE32(p32, endian)); p32++; 
+        } 
+        p += 16-state->memsize; 
+        state->memsize = 0; 
+    } 
+ 
+    if (p <= bEnd-16) { 
+        const BYTE* const limit = bEnd - 16; 
+        U32 v1 = state->v1; 
+        U32 v2 = state->v2; 
+        U32 v3 = state->v3; 
+        U32 v4 = state->v4; 
+ 
+        do { 
+            v1 = XXH32_round(v1, XXH_readLE32(p, endian)); p+=4; 
+            v2 = XXH32_round(v2, XXH_readLE32(p, endian)); p+=4; 
+            v3 = XXH32_round(v3, XXH_readLE32(p, endian)); p+=4; 
+            v4 = XXH32_round(v4, XXH_readLE32(p, endian)); p+=4; 
+        } while (p<=limit); 
+ 
+        state->v1 = v1; 
+        state->v2 = v2; 
+        state->v3 = v3; 
+        state->v4 = v4; 
+    } 
+ 
+    if (p < bEnd) { 
+        XXH_memcpy(state->mem32, p, bEnd-p); 
+        state->memsize = (int)(bEnd-p); 
+    } 
+ 
+    return XXH_OK; 
+} 
+ 
+XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void* input, size_t len) 
+{ 
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; 
+ 
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) 
+        return XXH32_update_endian(state_in, input, len, XXH_littleEndian); 
+    else 
+        return XXH32_update_endian(state_in, input, len, XXH_bigEndian); 
+} 
+ 
+ 
+ 
+FORCE_INLINE U32 XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian) 
+{ 
+    const BYTE * p = (const BYTE*)state->mem32; 
+    const BYTE* const bEnd = (const BYTE*)(state->mem32) + state->memsize; 
+    U32 h32; 
+ 
+    if (state->total_len >= 16) { 
+        h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18); 
+    } else { 
+        h32 = state->seed + PRIME32_5; 
+    } 
+ 
+    h32 += (U32) state->total_len; 
+ 
+    while (p+4<=bEnd) { 
+        h32 += XXH_readLE32(p, endian) * PRIME32_3; 
+        h32  = XXH_rotl32(h32, 17) * PRIME32_4; 
+        p+=4; 
+    } 
+ 
+    while (p<bEnd) { 
+        h32 += (*p) * PRIME32_5; 
+        h32  = XXH_rotl32(h32, 11) * PRIME32_1; 
+        p++; 
+    } 
+ 
+    h32 ^= h32 >> 15; 
+    h32 *= PRIME32_2; 
+    h32 ^= h32 >> 13; 
+    h32 *= PRIME32_3; 
+    h32 ^= h32 >> 16; 
+ 
+    return h32; 
+} 
+ 
+ 
+XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in) 
+{ 
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; 
+ 
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) 
+        return XXH32_digest_endian(state_in, XXH_littleEndian); 
+    else 
+        return XXH32_digest_endian(state_in, XXH_bigEndian); 
+} 
+ 
+ 
+ 
+/* **** XXH64 **** */ 
+ 
+FORCE_INLINE XXH_errorcode XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianess endian) 
+{ 
+    const BYTE* p = (const BYTE*)input; 
+    const BYTE* const bEnd = p + len; 
+ 
+#ifdef XXH_ACCEPT_NULL_INPUT_POINTER 
+    if (input==NULL) return XXH_ERROR; 
+#endif 
+ 
+    state->total_len += len; 
+ 
+    if (state->memsize + len < 32) {  /* fill in tmp buffer */ 
+        XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len); 
+        state->memsize += (U32)len; 
+        return XXH_OK; 
+    } 
+ 
+    if (state->memsize) {   /* tmp buffer is full */ 
+        XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize); 
+        state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0, endian)); 
+        state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1, endian)); 
+        state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2, endian)); 
+        state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3, endian)); 
+        p += 32-state->memsize; 
+        state->memsize = 0; 
+    } 
+ 
+    if (p+32 <= bEnd) { 
+        const BYTE* const limit = bEnd - 32; 
+        U64 v1 = state->v1; 
+        U64 v2 = state->v2; 
+        U64 v3 = state->v3; 
+        U64 v4 = state->v4; 
+ 
+        do { 
+            v1 = XXH64_round(v1, XXH_readLE64(p, endian)); p+=8; 
+            v2 = XXH64_round(v2, XXH_readLE64(p, endian)); p+=8; 
+            v3 = XXH64_round(v3, XXH_readLE64(p, endian)); p+=8; 
+            v4 = XXH64_round(v4, XXH_readLE64(p, endian)); p+=8; 
+        } while (p<=limit); 
+ 
+        state->v1 = v1; 
+        state->v2 = v2; 
+        state->v3 = v3; 
+        state->v4 = v4; 
+    } 
+ 
+    if (p < bEnd) { 
+        XXH_memcpy(state->mem64, p, bEnd-p); 
+        state->memsize = (int)(bEnd-p); 
+    } 
+ 
+    return XXH_OK; 
+} 
+ 
+XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t len) 
+{ 
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; 
+ 
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) 
+        return XXH64_update_endian(state_in, input, len, XXH_littleEndian); 
+    else 
+        return XXH64_update_endian(state_in, input, len, XXH_bigEndian); 
+} 
+ 
+ 
+ 
+FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianess endian) 
+{ 
+    const BYTE * p = (const BYTE*)state->mem64; 
+    const BYTE* const bEnd = (const BYTE*)state->mem64 + state->memsize; 
+    U64 h64; 
+ 
+    if (state->total_len >= 32) { 
+        U64 const v1 = state->v1; 
+        U64 const v2 = state->v2; 
+        U64 const v3 = state->v3; 
+        U64 const v4 = state->v4; 
+ 
+        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18); 
+        h64 = XXH64_mergeRound(h64, v1); 
+        h64 = XXH64_mergeRound(h64, v2); 
+        h64 = XXH64_mergeRound(h64, v3); 
+        h64 = XXH64_mergeRound(h64, v4); 
+    } else { 
+        h64  = state->seed + PRIME64_5; 
+    } 
+ 
+    h64 += (U64) state->total_len; 
+ 
+    while (p+8<=bEnd) { 
+        U64 const k1 = XXH64_round(0, XXH_readLE64(p, endian)); 
+        h64 ^= k1; 
+        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4; 
+        p+=8; 
+    } 
+ 
+    if (p+4<=bEnd) { 
+        h64 ^= (U64)(XXH_readLE32(p, endian)) * PRIME64_1; 
+        h64  = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3; 
+        p+=4; 
+    } 
+ 
+    while (p<bEnd) { 
+        h64 ^= (*p) * PRIME64_5; 
+        h64  = XXH_rotl64(h64, 11) * PRIME64_1; 
+        p++; 
+    } 
+ 
+    h64 ^= h64 >> 33; 
+    h64 *= PRIME64_2; 
+    h64 ^= h64 >> 29; 
+    h64 *= PRIME64_3; 
+    h64 ^= h64 >> 32; 
+ 
+    return h64; 
+} 
+ 
+ 
+XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in) 
+{ 
+    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN; 
+ 
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT) 
+        return XXH64_digest_endian(state_in, XXH_littleEndian); 
+    else 
+        return XXH64_digest_endian(state_in, XXH_bigEndian); 
+} 
+ 
+ 
+/* ************************** 
+*  Canonical representation 
+****************************/ 
+ 
+/*! Default XXH result types are basic unsigned 32 and 64 bits. 
+*   The canonical representation follows human-readable write convention, aka big-endian (large digits first). 
+*   These functions allow transformation of hash result into and from its canonical format. 
+*   This way, hash values can be written into a file or buffer, and remain comparable across different systems and programs. 
+*/ 
+ 
+XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash) 
+{ 
+    XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t)); 
+    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash); 
+    memcpy(dst, &hash, sizeof(*dst)); 
+} 
+ 
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash) 
+{ 
+    XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t)); 
+    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash); 
+    memcpy(dst, &hash, sizeof(*dst)); 
+} 
+ 
+XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src) 
+{ 
+    return XXH_readBE32(src); 
+} 
+ 
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src) 
+{ 
+    return XXH_readBE64(src); 
+} 
diff --git a/contrib/libs/zstd06/common/xxhash.h b/contrib/libs/zstd06/common/xxhash.h
index b940b4fa9a..ae77e981b5 100644
--- a/contrib/libs/zstd06/common/xxhash.h
+++ b/contrib/libs/zstd06/common/xxhash.h
@@ -1,274 +1,274 @@
-#include <contrib/libs/zstd06/renames.h>
-/*
-   xxHash - Extremely Fast Hash algorithm
-   Header File
-   Copyright (C) 2012-2016, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-   - xxHash source repository : https://github.com/Cyan4973/xxHash
-*/
-
-/* Notice extracted from xxHash homepage :
-
-xxHash is an extremely fast Hash algorithm, running at RAM speed limits.
-It also successfully passes all tests from the SMHasher suite.
-
-Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz)
-
-Name            Speed       Q.Score   Author
-xxHash          5.4 GB/s     10
-CrapWow         3.2 GB/s      2       Andrew
-MumurHash 3a    2.7 GB/s     10       Austin Appleby
-SpookyHash      2.0 GB/s     10       Bob Jenkins
-SBox            1.4 GB/s      9       Bret Mulvey
-Lookup3         1.2 GB/s      9       Bob Jenkins
-SuperFastHash   1.2 GB/s      1       Paul Hsieh
-CityHash64      1.05 GB/s    10       Pike & Alakuijala
-FNV             0.55 GB/s     5       Fowler, Noll, Vo
-CRC32           0.43 GB/s     9
-MD5-32          0.33 GB/s    10       Ronald L. Rivest
-SHA1-32         0.28 GB/s    10
-
-Q.Score is a measure of quality of the hash function.
-It depends on successfully passing SMHasher test set.
-10 is a perfect score.
-
-A 64-bits version, named XXH64, is available since r35.
-It offers much better speed, but for 64-bits applications only.
-Name     Speed on 64 bits    Speed on 32 bits
-XXH64       13.8 GB/s            1.9 GB/s
-XXH32        6.8 GB/s            6.0 GB/s
-*/
-
-#ifndef XXHASH_H_5627135585666179
-#define XXHASH_H_5627135585666179 1
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* ****************************
-*  Definitions
-******************************/
-#include <stddef.h>   /* size_t */
-typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
-
-
-/* ****************************
-*  API modifier
-******************************/
-/*!XXH_PRIVATE_API
-*  Transforms all publics symbols within `xxhash.c` into private ones.
-*  Methodology :
-*  instead of : #include "xxhash.h"
-*  do :
-*     #define XXH_PRIVATE_API
-*     #include "xxhash.c"   // note the .c , instead of .h
-*  also : don't compile and link xxhash.c separately
-*/
-#ifdef XXH_PRIVATE_API
-#  if defined(__GNUC__)
-#    define XXH_PUBLIC_API static __attribute__((unused))
-#  elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#    define XXH_PUBLIC_API static inline
-#  elif defined(_MSC_VER)
-#    define XXH_PUBLIC_API static __inline
-#  else
-#    define XXH_PUBLIC_API static   /* this version may generate warnings for unused static functions; disable the relevant warning */
-#  endif
-#else
-#  define XXH_PUBLIC_API   /* do nothing */
-#endif
-
-/*!XXH_NAMESPACE, aka Namespace Emulation :
-
-If you want to include _and expose_ xxHash functions from within your own library,
-but also want to avoid symbol collisions with another library which also includes xxHash,
-
-you can use XXH_NAMESPACE, to automatically prefix any public symbol from `xxhash.c`
-with the value of XXH_NAMESPACE (so avoid to keep it NULL and avoid numeric values).
-
-Note that no change is required within the calling program as long as it also includes `xxhash.h` :
-regular symbol name will be automatically translated by this header.
-*/
-#ifdef XXH_NAMESPACE
-#  define XXH_CAT(A,B) A##B
-#  define XXH_NAME2(A,B) XXH_CAT(A,B)
-#  define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)
-#  define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)
-#  define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)
-#  define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)
-#  define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)
-#  define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)
-#  define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)
-#  define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)
-#  define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)
-#  define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)
-#  define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)
-#  define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)
-#  define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)
-#endif
-
-
-/* *************************************
-*  Version
-***************************************/
-#define XXH_VERSION_MAJOR    0
-#define XXH_VERSION_MINOR    6
-#define XXH_VERSION_RELEASE  0
-#define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)
-XXH_PUBLIC_API unsigned XXH_versionNumber (void);
-
-
-/* ****************************
-*  Simple Hash Functions
-******************************/
-typedef unsigned int       XXH32_hash_t;
-typedef unsigned long long XXH64_hash_t;
-
-XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed);
-XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed);
-
-/*!
-XXH32() :
-    Calculate the 32-bits hash of sequence "length" bytes stored at memory address "input".
-    The memory between input & input+length must be valid (allocated and read-accessible).
-    "seed" can be used to alter the result predictably.
-    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s
-XXH64() :
-    Calculate the 64-bits hash of sequence of length "len" stored at memory address "input".
-    "seed" can be used to alter the result predictably.
-    This function runs faster on 64-bits systems, but slower on 32-bits systems (see benchmark).
-*/
-
-
-/* ****************************
-*  Streaming Hash Functions
-******************************/
-typedef struct XXH32_state_s XXH32_state_t;   /* incomplete type */
-typedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */
-
-/*! Dynamic allocation of states
-    Compatible with dynamic libraries */
-
-XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void);
-XXH_PUBLIC_API XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);
-
-XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
-XXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
-
-
-/* hash streaming */
-
-XXH_PUBLIC_API XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, unsigned int seed);
-XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
-XXH_PUBLIC_API XXH32_hash_t  XXH32_digest (const XXH32_state_t* statePtr);
-
-XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH64_state_t* statePtr, unsigned long long seed);
-XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
-XXH_PUBLIC_API XXH64_hash_t  XXH64_digest (const XXH64_state_t* statePtr);
-
-/*!
-These functions generate the xxHash of an input provided in multiple segments,
-as opposed to provided as a single block.
-
-XXH state must first be allocated, using either static or dynamic method provided above.
-
-Start a new hash by initializing state with a seed, using XXHnn_reset().
-
-Then, feed the hash state by calling XXHnn_update() as many times as necessary.
-Obviously, input must be valid, hence allocated and read accessible.
-The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
-
-Finally, a hash value can be produced anytime, by using XXHnn_digest().
-This function returns the nn-bits hash as an int or long long.
-
-It's still possible to continue inserting input into the hash state after a digest,
-and later on generate some new hashes, by calling again XXHnn_digest().
-
-When done, free XXH state space if it was allocated dynamically.
-*/
-
-
-/* **************************
-*  Canonical representation
-****************************/
-typedef struct { unsigned char digest[4]; } XXH32_canonical_t;
-typedef struct { unsigned char digest[8]; } XXH64_canonical_t;
-
-XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);
-XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
-
-XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
-XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
-
-/*! Default result type for XXH functions are primitive unsigned 32 and 64 bits.
-*   The canonical representation uses human-readable write convention, aka big-endian (large digits first).
-*   These functions allow transformation of hash result into and from its canonical format.
-*   This way, hash values can be written into a file / memory, and remain comparable on different systems and programs.
-*/
-
-
-#ifdef XXH_STATIC_LINKING_ONLY
-
-/* This part contains definition which shall only be used with static linking.
-   The prototypes / types defined here are not guaranteed to remain stable.
-   They could change in a future version, becoming incompatible with a different version of the library */
-
-   struct XXH32_state_s {
-       unsigned long long total_len;
-       unsigned seed;
-       unsigned v1;
-       unsigned v2;
-       unsigned v3;
-       unsigned v4;
-       unsigned mem32[4];   /* buffer defined as U32 for alignment */
-       unsigned memsize;
-   };   /* typedef'd to XXH32_state_t */
-
-   struct XXH64_state_s {
-       unsigned long long total_len;
-       unsigned long long seed;
-       unsigned long long v1;
-       unsigned long long v2;
-       unsigned long long v3;
-       unsigned long long v4;
-       unsigned long long mem64[4];   /* buffer defined as U64 for alignment */
-       unsigned memsize;
-   };   /* typedef'd to XXH64_state_t */
-
-
-#endif
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* XXHASH_H_5627135585666179 */
+#include <contrib/libs/zstd06/renames.h> 
+/* 
+   xxHash - Extremely Fast Hash algorithm 
+   Header File 
+   Copyright (C) 2012-2016, Yann Collet. 
+ 
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+   Redistribution and use in source and binary forms, with or without 
+   modification, are permitted provided that the following conditions are 
+   met: 
+ 
+       * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer. 
+       * Redistributions in binary form must reproduce the above 
+   copyright notice, this list of conditions and the following disclaimer 
+   in the documentation and/or other materials provided with the 
+   distribution. 
+ 
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+   You can contact the author at : 
+   - xxHash source repository : https://github.com/Cyan4973/xxHash 
+*/ 
+ 
+/* Notice extracted from xxHash homepage : 
+ 
+xxHash is an extremely fast Hash algorithm, running at RAM speed limits. 
+It also successfully passes all tests from the SMHasher suite. 
+ 
+Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz) 
+ 
+Name            Speed       Q.Score   Author 
+xxHash          5.4 GB/s     10 
+CrapWow         3.2 GB/s      2       Andrew 
+MumurHash 3a    2.7 GB/s     10       Austin Appleby 
+SpookyHash      2.0 GB/s     10       Bob Jenkins 
+SBox            1.4 GB/s      9       Bret Mulvey 
+Lookup3         1.2 GB/s      9       Bob Jenkins 
+SuperFastHash   1.2 GB/s      1       Paul Hsieh 
+CityHash64      1.05 GB/s    10       Pike & Alakuijala 
+FNV             0.55 GB/s     5       Fowler, Noll, Vo 
+CRC32           0.43 GB/s     9 
+MD5-32          0.33 GB/s    10       Ronald L. Rivest 
+SHA1-32         0.28 GB/s    10 
+ 
+Q.Score is a measure of quality of the hash function. 
+It depends on successfully passing SMHasher test set. 
+10 is a perfect score. 
+ 
+A 64-bits version, named XXH64, is available since r35. 
+It offers much better speed, but for 64-bits applications only. 
+Name     Speed on 64 bits    Speed on 32 bits 
+XXH64       13.8 GB/s            1.9 GB/s 
+XXH32        6.8 GB/s            6.0 GB/s 
+*/ 
+ 
+#ifndef XXHASH_H_5627135585666179 
+#define XXHASH_H_5627135585666179 1 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* **************************** 
+*  Definitions 
+******************************/ 
+#include <stddef.h>   /* size_t */ 
+typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode; 
+ 
+ 
+/* **************************** 
+*  API modifier 
+******************************/ 
+/*!XXH_PRIVATE_API 
+*  Transforms all publics symbols within `xxhash.c` into private ones. 
+*  Methodology : 
+*  instead of : #include "xxhash.h" 
+*  do : 
+*     #define XXH_PRIVATE_API 
+*     #include "xxhash.c"   // note the .c , instead of .h 
+*  also : don't compile and link xxhash.c separately 
+*/ 
+#ifdef XXH_PRIVATE_API 
+#  if defined(__GNUC__) 
+#    define XXH_PUBLIC_API static __attribute__((unused)) 
+#  elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+#    define XXH_PUBLIC_API static inline 
+#  elif defined(_MSC_VER) 
+#    define XXH_PUBLIC_API static __inline 
+#  else 
+#    define XXH_PUBLIC_API static   /* this version may generate warnings for unused static functions; disable the relevant warning */ 
+#  endif 
+#else 
+#  define XXH_PUBLIC_API   /* do nothing */ 
+#endif 
+ 
+/*!XXH_NAMESPACE, aka Namespace Emulation : 
+ 
+If you want to include _and expose_ xxHash functions from within your own library, 
+but also want to avoid symbol collisions with another library which also includes xxHash, 
+ 
+you can use XXH_NAMESPACE, to automatically prefix any public symbol from `xxhash.c` 
+with the value of XXH_NAMESPACE (so avoid to keep it NULL and avoid numeric values). 
+ 
+Note that no change is required within the calling program as long as it also includes `xxhash.h` : 
+regular symbol name will be automatically translated by this header. 
+*/ 
+#ifdef XXH_NAMESPACE 
+#  define XXH_CAT(A,B) A##B 
+#  define XXH_NAME2(A,B) XXH_CAT(A,B) 
+#  define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32) 
+#  define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64) 
+#  define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber) 
+#  define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState) 
+#  define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState) 
+#  define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState) 
+#  define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState) 
+#  define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset) 
+#  define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset) 
+#  define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update) 
+#  define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update) 
+#  define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest) 
+#  define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest) 
+#endif 
+ 
+ 
+/* ************************************* 
+*  Version 
+***************************************/ 
+#define XXH_VERSION_MAJOR    0 
+#define XXH_VERSION_MINOR    6 
+#define XXH_VERSION_RELEASE  0 
+#define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE) 
+XXH_PUBLIC_API unsigned XXH_versionNumber (void); 
+ 
+ 
+/* **************************** 
+*  Simple Hash Functions 
+******************************/ 
+typedef unsigned int       XXH32_hash_t; 
+typedef unsigned long long XXH64_hash_t; 
+ 
+XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed); 
+XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed); 
+ 
+/*! 
+XXH32() : 
+    Calculate the 32-bits hash of sequence "length" bytes stored at memory address "input". 
+    The memory between input & input+length must be valid (allocated and read-accessible). 
+    "seed" can be used to alter the result predictably. 
+    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s 
+XXH64() : 
+    Calculate the 64-bits hash of sequence of length "len" stored at memory address "input". 
+    "seed" can be used to alter the result predictably. 
+    This function runs faster on 64-bits systems, but slower on 32-bits systems (see benchmark). 
+*/ 
+ 
+ 
+/* **************************** 
+*  Streaming Hash Functions 
+******************************/ 
+typedef struct XXH32_state_s XXH32_state_t;   /* incomplete type */ 
+typedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */ 
+ 
+/*! Dynamic allocation of states 
+    Compatible with dynamic libraries */ 
+ 
+XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void); 
+XXH_PUBLIC_API XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr); 
+ 
+XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void); 
+XXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr); 
+ 
+ 
+/* hash streaming */ 
+ 
+XXH_PUBLIC_API XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, unsigned int seed); 
+XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length); 
+XXH_PUBLIC_API XXH32_hash_t  XXH32_digest (const XXH32_state_t* statePtr); 
+ 
+XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH64_state_t* statePtr, unsigned long long seed); 
+XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length); 
+XXH_PUBLIC_API XXH64_hash_t  XXH64_digest (const XXH64_state_t* statePtr); 
+ 
+/*! 
+These functions generate the xxHash of an input provided in multiple segments, 
+as opposed to provided as a single block. 
+ 
+XXH state must first be allocated, using either static or dynamic method provided above. 
+ 
+Start a new hash by initializing state with a seed, using XXHnn_reset(). 
+ 
+Then, feed the hash state by calling XXHnn_update() as many times as necessary. 
+Obviously, input must be valid, hence allocated and read accessible. 
+The function returns an error code, with 0 meaning OK, and any other value meaning there is an error. 
+ 
+Finally, a hash value can be produced anytime, by using XXHnn_digest(). 
+This function returns the nn-bits hash as an int or long long. 
+ 
+It's still possible to continue inserting input into the hash state after a digest, 
+and later on generate some new hashes, by calling again XXHnn_digest(). 
+ 
+When done, free XXH state space if it was allocated dynamically. 
+*/ 
+ 
+ 
+/* ************************** 
+*  Canonical representation 
+****************************/ 
+typedef struct { unsigned char digest[4]; } XXH32_canonical_t; 
+typedef struct { unsigned char digest[8]; } XXH64_canonical_t; 
+ 
+XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash); 
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash); 
+ 
+XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src); 
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src); 
+ 
+/*! Default result type for XXH functions are primitive unsigned 32 and 64 bits. 
+*   The canonical representation uses human-readable write convention, aka big-endian (large digits first). 
+*   These functions allow transformation of hash result into and from its canonical format. 
+*   This way, hash values can be written into a file / memory, and remain comparable on different systems and programs. 
+*/ 
+ 
+ 
+#ifdef XXH_STATIC_LINKING_ONLY 
+ 
+/* This part contains definition which shall only be used with static linking. 
+   The prototypes / types defined here are not guaranteed to remain stable. 
+   They could change in a future version, becoming incompatible with a different version of the library */ 
+ 
+   struct XXH32_state_s { 
+       unsigned long long total_len; 
+       unsigned seed; 
+       unsigned v1; 
+       unsigned v2; 
+       unsigned v3; 
+       unsigned v4; 
+       unsigned mem32[4];   /* buffer defined as U32 for alignment */ 
+       unsigned memsize; 
+   };   /* typedef'd to XXH32_state_t */ 
+ 
+   struct XXH64_state_s { 
+       unsigned long long total_len; 
+       unsigned long long seed; 
+       unsigned long long v1; 
+       unsigned long long v2; 
+       unsigned long long v3; 
+       unsigned long long v4; 
+       unsigned long long mem64[4];   /* buffer defined as U64 for alignment */ 
+       unsigned memsize; 
+   };   /* typedef'd to XXH64_state_t */ 
+ 
+ 
+#endif 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* XXHASH_H_5627135585666179 */ 
diff --git a/contrib/libs/zstd06/common/zbuff.h b/contrib/libs/zstd06/common/zbuff.h
index 54c40b47ca..5f49fe57ed 100644
--- a/contrib/libs/zstd06/common/zbuff.h
+++ b/contrib/libs/zstd06/common/zbuff.h
@@ -1,4 +1,4 @@
-#include <contrib/libs/zstd06/renames.h>
+#include <contrib/libs/zstd06/renames.h> 
 /*
     Buffered version of Zstd compression library
     Copyright (C) 2015-2016, Yann Collet.
@@ -154,7 +154,7 @@ ZSTDLIB_API unsigned ZBUFF_isError(size_t errorCode);
 ZSTDLIB_API const char* ZBUFF_getErrorName(size_t errorCode);
 
 /** Functions below provide recommended buffer sizes for Compression or Decompression operations.
-*   These sizes are just hints, they tend to offer better latency */
+*   These sizes are just hints, they tend to offer better latency */ 
 ZSTDLIB_API size_t ZBUFF_recommendedCInSize(void);
 ZSTDLIB_API size_t ZBUFF_recommendedCOutSize(void);
 ZSTDLIB_API size_t ZBUFF_recommendedDInSize(void);
diff --git a/contrib/libs/zstd06/common/zbuff_static.h b/contrib/libs/zstd06/common/zbuff_static.h
index e06404f646..2676bc4012 100644
--- a/contrib/libs/zstd06/common/zbuff_static.h
+++ b/contrib/libs/zstd06/common/zbuff_static.h
@@ -1,4 +1,4 @@
-#include <contrib/libs/zstd06/renames.h>
+#include <contrib/libs/zstd06/renames.h> 
 /*
     zstd - buffered version of compression library
     experimental complementary API, for static linking only
@@ -47,7 +47,7 @@ extern "C" {
 ***************************************/
 #include "zstd_static.h"     /* ZSTD_parameters */
 #include "zbuff.h"
-#include "zstd_internal.h"  /* MIN  */
+#include "zstd_internal.h"  /* MIN  */ 
 
 
 /* *************************************
@@ -57,14 +57,14 @@ ZSTDLIB_API size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* cctx,
                                                const void* dict, size_t dictSize,
                                                ZSTD_parameters params, U64 pledgedSrcSize);
 
-MEM_STATIC size_t ZBUFF_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    size_t length = MIN(dstCapacity, srcSize);
-    memcpy(dst, src, length);
-    return length;
-}
-
+MEM_STATIC size_t ZBUFF_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    size_t length = MIN(dstCapacity, srcSize); 
+    memcpy(dst, src, length); 
+    return length; 
+} 
 
+ 
 #if defined (__cplusplus)
 }
 #endif
diff --git a/contrib/libs/zstd06/common/zstd.h b/contrib/libs/zstd06/common/zstd.h
index 3574a82ec0..44ee62586b 100644
--- a/contrib/libs/zstd06/common/zstd.h
+++ b/contrib/libs/zstd06/common/zstd.h
@@ -1,4 +1,4 @@
-#include <contrib/libs/zstd06/renames.h>
+#include <contrib/libs/zstd06/renames.h> 
 /*
     zstd - standard compression library
     Header File
@@ -60,15 +60,15 @@ extern "C" {
 /* *************************************
 *  Version
 ***************************************/
-#define ZSTD_VERSION_MAJOR    0
-#define ZSTD_VERSION_MINOR    6
-#define ZSTD_VERSION_RELEASE  2
-
-#define ZSTD_LIB_VERSION ZSTD_VERSION_MAJOR.ZSTD_VERSION_MINOR.ZSTD_VERSION_RELEASE
-#define ZSTD_QUOTE(str) #str
-#define ZSTD_EXPAND_AND_QUOTE(str) ZSTD_QUOTE(str)
-#define ZSTD_VERSION_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_LIB_VERSION)
-
+#define ZSTD_VERSION_MAJOR    0 
+#define ZSTD_VERSION_MINOR    6 
+#define ZSTD_VERSION_RELEASE  2 
+ 
+#define ZSTD_LIB_VERSION ZSTD_VERSION_MAJOR.ZSTD_VERSION_MINOR.ZSTD_VERSION_RELEASE 
+#define ZSTD_QUOTE(str) #str 
+#define ZSTD_EXPAND_AND_QUOTE(str) ZSTD_QUOTE(str) 
+#define ZSTD_VERSION_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_LIB_VERSION) 
+ 
 #define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
 ZSTDLIB_API unsigned ZSTD_versionNumber (void);
 
diff --git a/contrib/libs/zstd06/common/zstd_common.c b/contrib/libs/zstd06/common/zstd_common.c
index 8812c03885..ea7b0dd025 100644
--- a/contrib/libs/zstd06/common/zstd_common.c
+++ b/contrib/libs/zstd06/common/zstd_common.c
@@ -1,72 +1,72 @@
-/*
-    Common functions of Zstd compression library
-    Copyright (C) 2015-2016, Yann Collet.
-
-    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are
-    met:
-    * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-    copyright notice, this list of conditions and the following disclaimer
-    in the documentation and/or other materials provided with the
-    distribution.
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    You can contact the author at :
-    - zstd homepage : http://www.zstd.net/
-*/
-
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include "error_private.h"
-#include "zstd.h"           /* declaration of ZSTD_isError, ZSTD_getErrorName */
-#include "zbuff.h"          /* declaration of ZBUFF_isError, ZBUFF_getErrorName */
-
-
-/*-****************************************
-*  Version
-******************************************/
-unsigned ZSTD_versionNumber (void) { return ZSTD_VERSION_NUMBER; }
-
-
-/*-****************************************
-*  ZSTD Error Management
-******************************************/
-/*! ZSTD_isError() :
-*   tells if a return value is an error code */
-unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }
-
-/*! ZSTD_getErrorName() :
-*   provides error code string from function result (useful for debugging) */
-const char* ZSTD_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-/*! ZSTD_getError() :
-*   convert a `size_t` function result into a proper ZSTD_errorCode enum */
-ZSTD_ErrorCode ZSTD_getErrorCode(size_t code) { return ERR_getErrorCode(code); }
-
-/*! ZSTD_getErrorString() :
-*   provides error code string from enum */
-const char* ZSTD_getErrorString(ZSTD_ErrorCode code) { return ERR_getErrorName(code); }
-
-
-/* **************************************************************
-*  ZBUFF Error Management
-****************************************************************/
-unsigned ZBUFF_isError(size_t errorCode) { return ERR_isError(errorCode); }
-
-const char* ZBUFF_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
+/* 
+    Common functions of Zstd compression library 
+    Copyright (C) 2015-2016, Yann Collet. 
+ 
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+    Redistribution and use in source and binary forms, with or without 
+    modification, are permitted provided that the following conditions are 
+    met: 
+    * Redistributions of source code must retain the above copyright 
+    notice, this list of conditions and the following disclaimer. 
+    * Redistributions in binary form must reproduce the above 
+    copyright notice, this list of conditions and the following disclaimer 
+    in the documentation and/or other materials provided with the 
+    distribution. 
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+    You can contact the author at : 
+    - zstd homepage : http://www.zstd.net/ 
+*/ 
+ 
+ 
+/*-************************************* 
+*  Dependencies 
+***************************************/ 
+#include "error_private.h" 
+#include "zstd.h"           /* declaration of ZSTD_isError, ZSTD_getErrorName */ 
+#include "zbuff.h"          /* declaration of ZBUFF_isError, ZBUFF_getErrorName */ 
+ 
+ 
+/*-**************************************** 
+*  Version 
+******************************************/ 
+unsigned ZSTD_versionNumber (void) { return ZSTD_VERSION_NUMBER; } 
+ 
+ 
+/*-**************************************** 
+*  ZSTD Error Management 
+******************************************/ 
+/*! ZSTD_isError() : 
+*   tells if a return value is an error code */ 
+unsigned ZSTD_isError(size_t code) { return ERR_isError(code); } 
+ 
+/*! ZSTD_getErrorName() : 
+*   provides error code string from function result (useful for debugging) */ 
+const char* ZSTD_getErrorName(size_t code) { return ERR_getErrorName(code); } 
+ 
+/*! ZSTD_getError() : 
+*   convert a `size_t` function result into a proper ZSTD_errorCode enum */ 
+ZSTD_ErrorCode ZSTD_getErrorCode(size_t code) { return ERR_getErrorCode(code); } 
+ 
+/*! ZSTD_getErrorString() : 
+*   provides error code string from enum */ 
+const char* ZSTD_getErrorString(ZSTD_ErrorCode code) { return ERR_getErrorName(code); } 
+ 
+ 
+/* ************************************************************** 
+*  ZBUFF Error Management 
+****************************************************************/ 
+unsigned ZBUFF_isError(size_t errorCode) { return ERR_isError(errorCode); } 
+ 
+const char* ZBUFF_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); } 
diff --git a/contrib/libs/zstd06/common/zstd_internal.h b/contrib/libs/zstd06/common/zstd_internal.h
index 2ce2b18cf1..663ccbe430 100644
--- a/contrib/libs/zstd06/common/zstd_internal.h
+++ b/contrib/libs/zstd06/common/zstd_internal.h
@@ -1,4 +1,4 @@
-#include <contrib/libs/zstd06/renames.h>
+#include <contrib/libs/zstd06/renames.h> 
 /*
     zstd_internal - common functions to include
     Header File for include
@@ -200,15 +200,15 @@ typedef struct {
     U32 rep[ZSTD_REP_INIT];
 } ZSTD_optimal_t;
 
-//#if ZSTD_OPT_DEBUG == 3
-//    #include ".debug/zstd_stats.h"
-//#else
+//#if ZSTD_OPT_DEBUG == 3 
+//    #include ".debug/zstd_stats.h" 
+//#else 
     typedef struct { U32  unused; } ZSTD_stats_t;
-    MEM_STATIC void ZSTD_statsPrint(ZSTD_stats_t* stats, U32 searchLength) { (void)stats; (void)searchLength; }
-    MEM_STATIC void ZSTD_statsInit(ZSTD_stats_t* stats) { (void)stats; }
-    MEM_STATIC void ZSTD_statsResetFreqs(ZSTD_stats_t* stats) { (void)stats; }
-    MEM_STATIC void ZSTD_statsUpdatePrices(ZSTD_stats_t* stats, size_t litLength, const BYTE* literals, size_t offset, size_t matchLength) { (void)stats; (void)litLength; (void)literals; (void)offset; (void)matchLength; }
-//#endif
+    MEM_STATIC void ZSTD_statsPrint(ZSTD_stats_t* stats, U32 searchLength) { (void)stats; (void)searchLength; } 
+    MEM_STATIC void ZSTD_statsInit(ZSTD_stats_t* stats) { (void)stats; } 
+    MEM_STATIC void ZSTD_statsResetFreqs(ZSTD_stats_t* stats) { (void)stats; } 
+    MEM_STATIC void ZSTD_statsUpdatePrices(ZSTD_stats_t* stats, size_t litLength, const BYTE* literals, size_t offset, size_t matchLength) { (void)stats; (void)litLength; (void)literals; (void)offset; (void)matchLength; } 
+//#endif 
 
 typedef struct {
     void* buffer;
@@ -243,9 +243,9 @@ typedef struct {
     U32  log2litSum;
     U32  log2offCodeSum;
     U32  factor;
-    U32  cachedPrice;
-    U32  cachedLitLength;
-    const BYTE* cachedLiterals;
+    U32  cachedPrice; 
+    U32  cachedLitLength; 
+    const BYTE* cachedLiterals; 
     ZSTD_stats_t stats;
 } seqStore_t;
 
diff --git a/contrib/libs/zstd06/common/zstd_static.h b/contrib/libs/zstd06/common/zstd_static.h
index a1dae42094..3118761987 100644
--- a/contrib/libs/zstd06/common/zstd_static.h
+++ b/contrib/libs/zstd06/common/zstd_static.h
@@ -1,4 +1,4 @@
-#include <contrib/libs/zstd06/renames.h>
+#include <contrib/libs/zstd06/renames.h> 
 /*
     zstd - standard compression library
     Header File for static linking only
@@ -104,7 +104,7 @@ ZSTDLIB_API unsigned ZSTD_maxCLevel (void);
 /*! ZSTD_getCParams() :
 *   @return ZSTD_compressionParameters structure for a selected compression level and srcSize.
 *   `srcSize` value is optional, select 0 if not known */
-ZSTDLIB_API ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, U64 srcSize, size_t dictSize);
+ZSTDLIB_API ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, U64 srcSize, size_t dictSize); 
 
 /*! ZSTD_checkParams() :
 *   Ensure param values remain within authorized range */
@@ -251,8 +251,8 @@ ZSTDLIB_API size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t ds
 */
 
 #define ZSTD_BLOCKSIZE_MAX (128 * 1024)   /* define, for static allocation */
-ZSTDLIB_API size_t ZSTD_compressBlock  (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-ZSTDLIB_API size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+ZSTDLIB_API size_t ZSTD_compressBlock  (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); 
+ZSTDLIB_API size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); 
 
 
 /*-*************************************
@@ -262,8 +262,8 @@ ZSTDLIB_API size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, void* dst, size_t dstCa
 /*! ZSTD_getErrorCode() :
     convert a `size_t` function result into a `ZSTD_ErrorCode` enum type,
     which can be used to compare directly with enum list published into "error_public.h" */
-ZSTDLIB_API ZSTD_ErrorCode ZSTD_getErrorCode(size_t functionResult);
-ZSTDLIB_API const char* ZSTD_getErrorString(ZSTD_ErrorCode code);
+ZSTDLIB_API ZSTD_ErrorCode ZSTD_getErrorCode(size_t functionResult); 
+ZSTDLIB_API const char* ZSTD_getErrorString(ZSTD_ErrorCode code); 
 
 
 #if defined (__cplusplus)