Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 1 of 2.

32 files changed, 27398 insertions, 27398 deletions

diff --git a/contrib/libs/zstd06/LICENSE b/contrib/libs/zstd06/LICENSE
index 35495850f2..29c8670589 100755
--- a/contrib/libs/zstd06/LICENSE
+++ b/contrib/libs/zstd06/LICENSE
@@ -1,26 +1,26 @@
-ZSTD Library
-Copyright (c) 2014-2015, Yann Collet
-All rights reserved.
-
-BSD License
-
-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 HOLDER 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.
+ZSTD Library 
+Copyright (c) 2014-2015, Yann Collet 
+All rights reserved. 
+ 
+BSD License 
+ 
+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 HOLDER 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. 
diff --git a/contrib/libs/zstd06/common/bitstream.h b/contrib/libs/zstd06/common/bitstream.h
index 97fc621579..5d89872904 100644
--- a/contrib/libs/zstd06/common/bitstream.h
+++ b/contrib/libs/zstd06/common/bitstream.h
@@ -1,417 +1,417 @@
 #include <contrib/libs/zstd06/renames.h>
-/* ******************************************************************
-   bitstream
-   Part of FSE library
-   header file (to include)
-   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 BITSTREAM_H_MODULE
-#define BITSTREAM_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/*
-*  This API consists of small unitary functions, which must be inlined for best performance.
-*  Since link-time-optimization is not available for all compilers,
-*  these functions are defined into a .h to be included.
-*/
-
-/*-****************************************
-*  Dependencies
-******************************************/
-#include "mem.h"            /* unaligned access routines */
-#include "error_private.h"  /* error codes and messages */
-
-
-/*=========================================
-*  Target specific
-=========================================*/
-#if defined(__BMI__) && defined(__GNUC__)
-#  include <immintrin.h>   /* support for bextr (experimental) */
-#endif
-
-
-/*-******************************************
-*  bitStream encoding API (write forward)
-********************************************/
-/* bitStream can mix input from multiple sources.
-*  A critical property of these streams is that they encode and decode in **reverse** direction.
-*  So the first bit sequence you add will be the last to be read, like a LIFO stack.
-*/
-typedef struct
-{
-    size_t bitContainer;
-    int    bitPos;
-    char*  startPtr;
-    char*  ptr;
-    char*  endPtr;
-} BIT_CStream_t;
-
-MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* dstBuffer, size_t dstCapacity);
-MEM_STATIC void   BIT_addBits(BIT_CStream_t* bitC, size_t value, unsigned nbBits);
-MEM_STATIC void   BIT_flushBits(BIT_CStream_t* bitC);
-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.
+/* ****************************************************************** 
+   bitstream 
+   Part of FSE library 
+   header file (to include) 
+   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 BITSTREAM_H_MODULE 
+#define BITSTREAM_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* 
+*  This API consists of small unitary functions, which must be inlined for best performance. 
+*  Since link-time-optimization is not available for all compilers, 
+*  these functions are defined into a .h to be included. 
+*/ 
+ 
+/*-**************************************** 
+*  Dependencies 
+******************************************/ 
+#include "mem.h"            /* unaligned access routines */ 
+#include "error_private.h"  /* error codes and messages */ 
+ 
+ 
+/*========================================= 
+*  Target specific 
+=========================================*/ 
+#if defined(__BMI__) && defined(__GNUC__) 
+#  include <immintrin.h>   /* support for bextr (experimental) */ 
+#endif 
+ 
+ 
+/*-****************************************** 
+*  bitStream encoding API (write forward) 
+********************************************/ 
+/* bitStream can mix input from multiple sources. 
+*  A critical property of these streams is that they encode and decode in **reverse** direction. 
+*  So the first bit sequence you add will be the last to be read, like a LIFO stack. 
+*/ 
+typedef struct 
+{ 
+    size_t bitContainer; 
+    int    bitPos; 
+    char*  startPtr; 
+    char*  ptr; 
+    char*  endPtr; 
+} BIT_CStream_t; 
+ 
+MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* dstBuffer, size_t dstCapacity); 
+MEM_STATIC void   BIT_addBits(BIT_CStream_t* bitC, size_t value, unsigned nbBits); 
+MEM_STATIC void   BIT_flushBits(BIT_CStream_t* bitC); 
+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.
-*
-*  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.
-*  Writing data into memory is an explicit operation, performed by the flushBits function.
-*  Hence keep track how many bits are potentially stored into local register to avoid register overflow.
-*  After a flushBits, a maximum of 7 bits might still be stored into local register.
-*
-*  Avoid storing elements of more than 24 bits if you want compatibility with 32-bits bitstream readers.
-*
-*  Last operation is to close the bitStream.
-*  The function returns the final size of CStream in bytes.
-*  If data couldn't fit into `dstBuffer`, it will return a 0 ( == not storable)
-*/
-
-
-/*-********************************************
-*  bitStream decoding API (read backward)
-**********************************************/
-typedef struct
-{
-    size_t   bitContainer;
-    unsigned bitsConsumed;
-    const char* ptr;
-    const char* start;
-} BIT_DStream_t;
-
-typedef enum { BIT_DStream_unfinished = 0,
-               BIT_DStream_endOfBuffer = 1,
-               BIT_DStream_completed = 2,
-               BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */
-               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
-
-MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
-MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
-MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
-MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
-
-
-/* Start by invoking BIT_initDStream().
-*  A chunk of the bitStream is then stored into a local register.
-*  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.
+* 
+*  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. 
+*  Writing data into memory is an explicit operation, performed by the flushBits function. 
+*  Hence keep track how many bits are potentially stored into local register to avoid register overflow. 
+*  After a flushBits, a maximum of 7 bits might still be stored into local register. 
+* 
+*  Avoid storing elements of more than 24 bits if you want compatibility with 32-bits bitstream readers. 
+* 
+*  Last operation is to close the bitStream. 
+*  The function returns the final size of CStream in bytes. 
+*  If data couldn't fit into `dstBuffer`, it will return a 0 ( == not storable) 
+*/ 
+ 
+ 
+/*-******************************************** 
+*  bitStream decoding API (read backward) 
+**********************************************/ 
+typedef struct 
+{ 
+    size_t   bitContainer; 
+    unsigned bitsConsumed; 
+    const char* ptr; 
+    const char* start; 
+} BIT_DStream_t; 
+ 
+typedef enum { BIT_DStream_unfinished = 0, 
+               BIT_DStream_endOfBuffer = 1, 
+               BIT_DStream_completed = 2, 
+               BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */ 
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */ 
+ 
+MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize); 
+MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits); 
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD); 
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD); 
+ 
+ 
+/* Start by invoking BIT_initDStream(). 
+*  A chunk of the bitStream is then stored into a local register. 
+*  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.
-*  Otherwise, it can be less than that, so proceed accordingly.
-*  Checking if DStream has reached its end can be performed with BIT_endOfDStream().
-*/
-
-
-/*-****************************************
-*  unsafe API
-******************************************/
-MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits);
-/* faster, but works only if value is "clean", meaning all high bits above nbBits are 0 */
-
-MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC);
-/* unsafe version; does not check buffer overflow */
-
-MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
-/* faster, but works only if nbBits >= 1 */
-
-
-
-/*-**************************************************************
-*  Internal functions
-****************************************************************/
-MEM_STATIC unsigned BIT_highbit32 (register U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
-    unsigned long r=0;
-    _BitScanReverse ( &r, val );
-    return (unsigned) r;
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
-    return 31 - __builtin_clz (val);
-#   else   /* Software version */
-    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
-    U32 v = val;
-    unsigned r;
-    v |= v >> 1;
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
-    return r;
-#   endif
-}
-
-/*=====    Local Constants   =====*/
-static const unsigned BIT_mask[] = { 0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF, 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF,  0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF };   /* up to 26 bits */
-
-
-/*-**************************************************************
-*  bitStream encoding
-****************************************************************/
-/*! BIT_initCStream() :
- *  `dstCapacity` must be > sizeof(void*)
- *  @return : 0 if success,
-              otherwise an error code (can be tested using ERR_isError() ) */
-MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* startPtr, size_t dstCapacity)
-{
-    bitC->bitContainer = 0;
-    bitC->bitPos = 0;
-    bitC->startPtr = (char*)startPtr;
-    bitC->ptr = bitC->startPtr;
-    bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->ptr);
-    if (dstCapacity <= sizeof(bitC->ptr)) return ERROR(dstSize_tooSmall);
-    return 0;
-}
-
-/*! BIT_addBits() :
-    can add up to 26 bits into `bitC`.
-    Does not check for register overflow ! */
-MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC, size_t value, unsigned nbBits)
-{
-    bitC->bitContainer |= (value & BIT_mask[nbBits]) << bitC->bitPos;
-    bitC->bitPos += nbBits;
-}
-
-/*! BIT_addBitsFast() :
- *  works only if `value` is _clean_, meaning all high bits above nbBits are 0 */
-MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits)
-{
-    bitC->bitContainer |= value << bitC->bitPos;
-    bitC->bitPos += nbBits;
-}
-
-/*! BIT_flushBitsFast() :
- *  unsafe version; does not check buffer overflow */
-MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC)
-{
-    size_t const nbBytes = bitC->bitPos >> 3;
-    MEM_writeLEST(bitC->ptr, bitC->bitContainer);
-    bitC->ptr += nbBytes;
-    bitC->bitPos &= 7;
-    bitC->bitContainer >>= nbBytes*8;   /* if bitPos >= sizeof(bitContainer)*8 --> undefined behavior */
-}
-
-/*! BIT_flushBits() :
- *  safe version; check for buffer overflow, and prevents it.
- *  note : does not signal buffer overflow. This will be revealed later on using BIT_closeCStream() */
-MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC)
-{
-    size_t const nbBytes = bitC->bitPos >> 3;
-    MEM_writeLEST(bitC->ptr, bitC->bitContainer);
-    bitC->ptr += nbBytes;
-    if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr;
-    bitC->bitPos &= 7;
-    bitC->bitContainer >>= nbBytes*8;   /* if bitPos >= sizeof(bitContainer)*8 --> undefined behavior */
-}
-
-/*! BIT_closeCStream() :
- *  @return : size of CStream, in bytes,
-              or 0 if it could not fit into dstBuffer */
-MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC)
-{
-    BIT_addBitsFast(bitC, 1, 1);   /* endMark */
-    BIT_flushBits(bitC);
-
-    if (bitC->ptr >= bitC->endPtr) return 0; /* doesn't fit within authorized budget : cancel */
-
-    return (bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0);
-}
-
-
-/*-********************************************************
-* bitStream decoding
-**********************************************************/
-/*! BIT_initDStream() :
-*   Initialize a BIT_DStream_t.
-*   `bitD` : a pointer to an already allocated BIT_DStream_t structure.
-*   `srcSize` must be the *exact* size of the bitStream, in bytes.
-*   @return : size of stream (== srcSize) or an errorCode if a problem is detected
-*/
-MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
-{
-    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
-
+*  Otherwise, it can be less than that, so proceed accordingly. 
+*  Checking if DStream has reached its end can be performed with BIT_endOfDStream(). 
+*/ 
+ 
+ 
+/*-**************************************** 
+*  unsafe API 
+******************************************/ 
+MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits); 
+/* faster, but works only if value is "clean", meaning all high bits above nbBits are 0 */ 
+ 
+MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC); 
+/* unsafe version; does not check buffer overflow */ 
+ 
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits); 
+/* faster, but works only if nbBits >= 1 */ 
+ 
+ 
+ 
+/*-************************************************************** 
+*  Internal functions 
+****************************************************************/ 
+MEM_STATIC unsigned BIT_highbit32 (register U32 val) 
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
+    unsigned long r=0; 
+    _BitScanReverse ( &r, val ); 
+    return (unsigned) r; 
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */ 
+    return 31 - __builtin_clz (val); 
+#   else   /* Software version */ 
+    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 }; 
+    U32 v = val; 
+    unsigned r; 
+    v |= v >> 1; 
+    v |= v >> 2; 
+    v |= v >> 4; 
+    v |= v >> 8; 
+    v |= v >> 16; 
+    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27]; 
+    return r; 
+#   endif 
+} 
+ 
+/*=====    Local Constants   =====*/ 
+static const unsigned BIT_mask[] = { 0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF, 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF,  0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF };   /* up to 26 bits */ 
+ 
+ 
+/*-************************************************************** 
+*  bitStream encoding 
+****************************************************************/ 
+/*! BIT_initCStream() : 
+ *  `dstCapacity` must be > sizeof(void*) 
+ *  @return : 0 if success, 
+              otherwise an error code (can be tested using ERR_isError() ) */ 
+MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* startPtr, size_t dstCapacity) 
+{ 
+    bitC->bitContainer = 0; 
+    bitC->bitPos = 0; 
+    bitC->startPtr = (char*)startPtr; 
+    bitC->ptr = bitC->startPtr; 
+    bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->ptr); 
+    if (dstCapacity <= sizeof(bitC->ptr)) return ERROR(dstSize_tooSmall); 
+    return 0; 
+} 
+ 
+/*! BIT_addBits() : 
+    can add up to 26 bits into `bitC`. 
+    Does not check for register overflow ! */ 
+MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC, size_t value, unsigned nbBits) 
+{ 
+    bitC->bitContainer |= (value & BIT_mask[nbBits]) << bitC->bitPos; 
+    bitC->bitPos += nbBits; 
+} 
+ 
+/*! BIT_addBitsFast() : 
+ *  works only if `value` is _clean_, meaning all high bits above nbBits are 0 */ 
+MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits) 
+{ 
+    bitC->bitContainer |= value << bitC->bitPos; 
+    bitC->bitPos += nbBits; 
+} 
+ 
+/*! BIT_flushBitsFast() : 
+ *  unsafe version; does not check buffer overflow */ 
+MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC) 
+{ 
+    size_t const nbBytes = bitC->bitPos >> 3; 
+    MEM_writeLEST(bitC->ptr, bitC->bitContainer); 
+    bitC->ptr += nbBytes; 
+    bitC->bitPos &= 7; 
+    bitC->bitContainer >>= nbBytes*8;   /* if bitPos >= sizeof(bitContainer)*8 --> undefined behavior */ 
+} 
+ 
+/*! BIT_flushBits() : 
+ *  safe version; check for buffer overflow, and prevents it. 
+ *  note : does not signal buffer overflow. This will be revealed later on using BIT_closeCStream() */ 
+MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC) 
+{ 
+    size_t const nbBytes = bitC->bitPos >> 3; 
+    MEM_writeLEST(bitC->ptr, bitC->bitContainer); 
+    bitC->ptr += nbBytes; 
+    if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr; 
+    bitC->bitPos &= 7; 
+    bitC->bitContainer >>= nbBytes*8;   /* if bitPos >= sizeof(bitContainer)*8 --> undefined behavior */ 
+} 
+ 
+/*! BIT_closeCStream() : 
+ *  @return : size of CStream, in bytes, 
+              or 0 if it could not fit into dstBuffer */ 
+MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC) 
+{ 
+    BIT_addBitsFast(bitC, 1, 1);   /* endMark */ 
+    BIT_flushBits(bitC); 
+ 
+    if (bitC->ptr >= bitC->endPtr) return 0; /* doesn't fit within authorized budget : cancel */ 
+ 
+    return (bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0); 
+} 
+ 
+ 
+/*-******************************************************** 
+* bitStream decoding 
+**********************************************************/ 
+/*! BIT_initDStream() : 
+*   Initialize a BIT_DStream_t. 
+*   `bitD` : a pointer to an already allocated BIT_DStream_t structure. 
+*   `srcSize` must be the *exact* size of the bitStream, in bytes. 
+*   @return : size of stream (== srcSize) or an errorCode if a problem is detected 
+*/ 
+MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize) 
+{ 
+    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); } 
+ 
     if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */
-        bitD->start = (const char*)srcBuffer;
+        bitD->start = (const char*)srcBuffer; 
         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 */
-          bitD->bitsConsumed = 8 - BIT_highbit32(lastByte); }
-    } else {
-        bitD->start = (const char*)srcBuffer;
-        bitD->ptr   = bitD->start;
-        bitD->bitContainer = *(const BYTE*)(bitD->start);
-        switch(srcSize)
-        {
+        bitD->bitContainer = MEM_readLEST(bitD->ptr); 
+        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; 
+          if (lastByte == 0) return ERROR(GENERIC);   /* endMark not present */ 
+          bitD->bitsConsumed = 8 - BIT_highbit32(lastByte); } 
+    } else { 
+        bitD->start = (const char*)srcBuffer; 
+        bitD->ptr   = bitD->start; 
+        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;
-            default:;
-        }
-        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
-          if (lastByte == 0) return ERROR(GENERIC);   /* endMark not present */
-          bitD->bitsConsumed = 8 - BIT_highbit32(lastByte); }
+            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;
-    }
-
-    return srcSize;
-}
-
+    } 
+ 
+    return srcSize; 
+} 
+ 
 MEM_STATIC size_t BIT_getUpperBits(size_t bitContainer, U32 const start)
-{
+{ 
     return bitContainer >> start;
-}
-
+} 
+ 
 MEM_STATIC size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 const nbBits)
-{
-#if defined(__BMI__) && defined(__GNUC__)   /* experimental */
+{ 
+#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);
-#else
+#else 
     return (bitContainer >> start) & BIT_mask[nbBits];
-#endif
-}
-
+#endif 
+} 
+ 
 MEM_STATIC size_t BIT_getLowerBits(size_t bitContainer, U32 const nbBits)
-{
+{ 
     return bitContainer & BIT_mask[nbBits];
-}
-
-/*! BIT_lookBits() :
- *  Provides next n bits from local register.
+} 
+ 
+/*! BIT_lookBits() : 
+ *  Provides next n bits from local register. 
  *  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)
-{
+ *  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);
-#else
-    U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;
-    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
-#endif
-}
-
-/*! BIT_lookBitsFast() :
-*   unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits)
-{
-    U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;
-    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);
-}
-
-MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
-{
-    bitD->bitsConsumed += nbBits;
-}
-
-/*! BIT_readBits() :
- *  Read (consume) next n bits from local register and update.
- *  Pay attention to not read more than nbBits contained into local register.
- *  @return : extracted value.
- */
-MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
-{
-    size_t const value = BIT_lookBits(bitD, nbBits);
-    BIT_skipBits(bitD, nbBits);
-    return value;
-}
-
-/*! BIT_readBitsFast() :
-*   unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)
-{
-    size_t const value = BIT_lookBitsFast(bitD, nbBits);
-    BIT_skipBits(bitD, nbBits);
-    return value;
-}
-
-/*! BIT_reloadDStream() :
-*   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.
+#else 
+    U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1; 
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask); 
+#endif 
+} 
+ 
+/*! BIT_lookBitsFast() : 
+*   unsafe version; only works only if nbBits >= 1 */ 
+MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1; 
+    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask); 
+} 
+ 
+MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    bitD->bitsConsumed += nbBits; 
+} 
+ 
+/*! BIT_readBits() : 
+ *  Read (consume) next n bits from local register and update. 
+ *  Pay attention to not read more than nbBits contained into local register. 
+ *  @return : extracted value. 
+ */ 
+MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t const value = BIT_lookBits(bitD, nbBits); 
+    BIT_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+/*! BIT_readBitsFast() : 
+*   unsafe version; only works only if nbBits >= 1 */ 
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t const value = BIT_lookBitsFast(bitD, nbBits); 
+    BIT_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+/*! BIT_reloadDStream() : 
+*   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 */
-MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
-{
-	if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
-		return BIT_DStream_overflow;
-
-    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) {
-        bitD->ptr -= bitD->bitsConsumed >> 3;
-        bitD->bitsConsumed &= 7;
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);
-        return BIT_DStream_unfinished;
-    }
-    if (bitD->ptr == bitD->start) {
-        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
-        return BIT_DStream_completed;
-    }
-    {   U32 nbBytes = bitD->bitsConsumed >> 3;
-        BIT_DStream_status result = BIT_DStream_unfinished;
-        if (bitD->ptr - nbBytes < bitD->start) {
-            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
-            result = BIT_DStream_endOfBuffer;
-        }
-        bitD->ptr -= nbBytes;
-        bitD->bitsConsumed -= nbBytes*8;
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
-        return result;
-    }
-}
-
-/*! BIT_endOfDStream() :
-*   @return Tells if DStream has exactly reached its end (all bits consumed).
-*/
-MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
-{
-    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
-}
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* BITSTREAM_H_MODULE */
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD) 
+{ 
+	if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */ 
+		return BIT_DStream_overflow; 
+ 
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) { 
+        bitD->ptr -= bitD->bitsConsumed >> 3; 
+        bitD->bitsConsumed &= 7; 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr); 
+        return BIT_DStream_unfinished; 
+    } 
+    if (bitD->ptr == bitD->start) { 
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer; 
+        return BIT_DStream_completed; 
+    } 
+    {   U32 nbBytes = bitD->bitsConsumed >> 3; 
+        BIT_DStream_status result = BIT_DStream_unfinished; 
+        if (bitD->ptr - nbBytes < bitD->start) { 
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */ 
+            result = BIT_DStream_endOfBuffer; 
+        } 
+        bitD->ptr -= nbBytes; 
+        bitD->bitsConsumed -= nbBytes*8; 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */ 
+        return result; 
+    } 
+} 
+ 
+/*! BIT_endOfDStream() : 
+*   @return Tells if DStream has exactly reached its end (all bits consumed). 
+*/ 
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream) 
+{ 
+    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8)); 
+} 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* BITSTREAM_H_MODULE */ 
diff --git a/contrib/libs/zstd06/common/error_private.h b/contrib/libs/zstd06/common/error_private.h
index d8d1ef24b3..f2cd35dd15 100644
--- a/contrib/libs/zstd06/common/error_private.h
+++ b/contrib/libs/zstd06/common/error_private.h
@@ -1,124 +1,124 @@
 #include <contrib/libs/zstd06/renames.h>
-/* ******************************************************************
-   Error codes and messages
-   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 :
-   - Homepage : http://www.zstd.net
-****************************************************************** */
-/* Note : this module is expected to remain private, do not expose it */
-
-#ifndef ERROR_H_MODULE
-#define ERROR_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* ****************************************
-*  Dependencies
-******************************************/
-#include <stddef.h>        /* size_t */
-#include "error_public.h"  /* enum list */
-
-
-/* ****************************************
-*  Compiler-specific
-******************************************/
-#if defined(__GNUC__)
-#  define ERR_STATIC static __attribute__((unused))
-#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#  define ERR_STATIC static inline
-#elif defined(_MSC_VER)
-#  define ERR_STATIC static __inline
-#else
-#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
-#endif
-
-
-/*-****************************************
-*  Customization (error_public.h)
-******************************************/
-typedef ZSTD_ErrorCode ERR_enum;
-#define PREFIX(name) ZSTD_error_##name
-
-
-/*-****************************************
-*  Error codes handling
-******************************************/
-#ifdef ERROR
-#  undef ERROR   /* reported already defined on VS 2015 (Rich Geldreich) */
-#endif
-#define ERROR(name) ((size_t)-PREFIX(name))
-
-ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }
-
+/* ****************************************************************** 
+   Error codes and messages 
+   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 : 
+   - Homepage : http://www.zstd.net 
+****************************************************************** */ 
+/* Note : this module is expected to remain private, do not expose it */ 
+ 
+#ifndef ERROR_H_MODULE 
+#define ERROR_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* **************************************** 
+*  Dependencies 
+******************************************/ 
+#include <stddef.h>        /* size_t */ 
+#include "error_public.h"  /* enum list */ 
+ 
+ 
+/* **************************************** 
+*  Compiler-specific 
+******************************************/ 
+#if defined(__GNUC__) 
+#  define ERR_STATIC static __attribute__((unused)) 
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+#  define ERR_STATIC static inline 
+#elif defined(_MSC_VER) 
+#  define ERR_STATIC static __inline 
+#else 
+#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */ 
+#endif 
+ 
+ 
+/*-**************************************** 
+*  Customization (error_public.h) 
+******************************************/ 
+typedef ZSTD_ErrorCode ERR_enum; 
+#define PREFIX(name) ZSTD_error_##name 
+ 
+ 
+/*-**************************************** 
+*  Error codes handling 
+******************************************/ 
+#ifdef ERROR 
+#  undef ERROR   /* reported already defined on VS 2015 (Rich Geldreich) */ 
+#endif 
+#define ERROR(name) ((size_t)-PREFIX(name)) 
+ 
+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); }
-
-
-/*-****************************************
-*  Error Strings
-******************************************/
-
+ 
+ 
+/*-**************************************** 
+*  Error Strings 
+******************************************/ 
+ 
 ERR_STATIC const char* ERR_getErrorString(ERR_enum code)
-{
-    static const char* notErrorCode = "Unspecified error code";
+{ 
+    static const char* notErrorCode = "Unspecified error code"; 
     switch( code )
-    {
-    case PREFIX(no_error): return "No error detected";
-    case PREFIX(GENERIC):  return "Error (generic)";
-    case PREFIX(prefix_unknown): return "Unknown frame descriptor";
-    case PREFIX(frameParameter_unsupported): return "Unsupported frame parameter";
-    case PREFIX(frameParameter_unsupportedBy32bits): return "Frame parameter unsupported in 32-bits mode";
-    case PREFIX(compressionParameter_unsupported): return "Compression parameter is out of bound";
-    case PREFIX(init_missing): return "Context should be init first";
-    case PREFIX(memory_allocation): return "Allocation error : not enough memory";
-    case PREFIX(stage_wrong): return "Operation not authorized at current processing stage";
-    case PREFIX(dstSize_tooSmall): return "Destination buffer is too small";
-    case PREFIX(srcSize_wrong): return "Src size incorrect";
-    case PREFIX(corruption_detected): return "Corrupted block detected";
-    case PREFIX(tableLog_tooLarge): return "tableLog requires too much memory : unsupported";
-    case PREFIX(maxSymbolValue_tooLarge): return "Unsupported max Symbol Value : too large";
-    case PREFIX(maxSymbolValue_tooSmall): return "Specified maxSymbolValue is too small";
-    case PREFIX(dictionary_corrupted): return "Dictionary is corrupted";
-    case PREFIX(maxCode):
+    { 
+    case PREFIX(no_error): return "No error detected"; 
+    case PREFIX(GENERIC):  return "Error (generic)"; 
+    case PREFIX(prefix_unknown): return "Unknown frame descriptor"; 
+    case PREFIX(frameParameter_unsupported): return "Unsupported frame parameter"; 
+    case PREFIX(frameParameter_unsupportedBy32bits): return "Frame parameter unsupported in 32-bits mode"; 
+    case PREFIX(compressionParameter_unsupported): return "Compression parameter is out of bound"; 
+    case PREFIX(init_missing): return "Context should be init first"; 
+    case PREFIX(memory_allocation): return "Allocation error : not enough memory"; 
+    case PREFIX(stage_wrong): return "Operation not authorized at current processing stage"; 
+    case PREFIX(dstSize_tooSmall): return "Destination buffer is too small"; 
+    case PREFIX(srcSize_wrong): return "Src size incorrect"; 
+    case PREFIX(corruption_detected): return "Corrupted block detected"; 
+    case PREFIX(tableLog_tooLarge): return "tableLog requires too much memory : unsupported"; 
+    case PREFIX(maxSymbolValue_tooLarge): return "Unsupported max Symbol Value : too large"; 
+    case PREFIX(maxSymbolValue_tooSmall): return "Specified maxSymbolValue is too small"; 
+    case PREFIX(dictionary_corrupted): return "Dictionary is corrupted"; 
+    case PREFIX(maxCode): 
     default: return notErrorCode;
-    }
-}
-
+    } 
+} 
+ 
 ERR_STATIC const char* ERR_getErrorName(size_t code)
 {
     return ERR_getErrorString(ERR_getErrorCode(code));
 }
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* ERROR_H_MODULE */
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* ERROR_H_MODULE */ 
diff --git a/contrib/libs/zstd06/common/error_public.h b/contrib/libs/zstd06/common/error_public.h
index 1d8f03995f..20c04de531 100644
--- a/contrib/libs/zstd06/common/error_public.h
+++ b/contrib/libs/zstd06/common/error_public.h
@@ -1,72 +1,72 @@
 #include <contrib/libs/zstd06/renames.h>
-/* ******************************************************************
-   Error codes list
-   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 :
-   - Homepage : http://www.zstd.net
-****************************************************************** */
-#ifndef ERROR_PUBLIC_H_MODULE
-#define ERROR_PUBLIC_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* ****************************************
-*  error codes list
-******************************************/
-typedef enum {
-  ZSTD_error_no_error,
-  ZSTD_error_GENERIC,
-  ZSTD_error_prefix_unknown,
-  ZSTD_error_frameParameter_unsupported,
-  ZSTD_error_frameParameter_unsupportedBy32bits,
-  ZSTD_error_compressionParameter_unsupported,
-  ZSTD_error_init_missing,
-  ZSTD_error_memory_allocation,
-  ZSTD_error_stage_wrong,
-  ZSTD_error_dstSize_tooSmall,
-  ZSTD_error_srcSize_wrong,
-  ZSTD_error_corruption_detected,
-  ZSTD_error_tableLog_tooLarge,
-  ZSTD_error_maxSymbolValue_tooLarge,
-  ZSTD_error_maxSymbolValue_tooSmall,
-  ZSTD_error_dictionary_corrupted,
-  ZSTD_error_maxCode
-} ZSTD_ErrorCode;
-
-/* note : compare with size_t function results using ZSTD_getError() */
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* ERROR_PUBLIC_H_MODULE */
+/* ****************************************************************** 
+   Error codes list 
+   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 : 
+   - Homepage : http://www.zstd.net 
+****************************************************************** */ 
+#ifndef ERROR_PUBLIC_H_MODULE 
+#define ERROR_PUBLIC_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* **************************************** 
+*  error codes list 
+******************************************/ 
+typedef enum { 
+  ZSTD_error_no_error, 
+  ZSTD_error_GENERIC, 
+  ZSTD_error_prefix_unknown, 
+  ZSTD_error_frameParameter_unsupported, 
+  ZSTD_error_frameParameter_unsupportedBy32bits, 
+  ZSTD_error_compressionParameter_unsupported, 
+  ZSTD_error_init_missing, 
+  ZSTD_error_memory_allocation, 
+  ZSTD_error_stage_wrong, 
+  ZSTD_error_dstSize_tooSmall, 
+  ZSTD_error_srcSize_wrong, 
+  ZSTD_error_corruption_detected, 
+  ZSTD_error_tableLog_tooLarge, 
+  ZSTD_error_maxSymbolValue_tooLarge, 
+  ZSTD_error_maxSymbolValue_tooSmall, 
+  ZSTD_error_dictionary_corrupted, 
+  ZSTD_error_maxCode 
+} ZSTD_ErrorCode; 
+ 
+/* note : compare with size_t function results using ZSTD_getError() */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* ERROR_PUBLIC_H_MODULE */ 
diff --git a/contrib/libs/zstd06/common/fse.h b/contrib/libs/zstd06/common/fse.h
index 1cc6992951..fcd0216f10 100644
--- a/contrib/libs/zstd06/common/fse.h
+++ b/contrib/libs/zstd06/common/fse.h
@@ -1,280 +1,280 @@
 #include <contrib/libs/zstd06/renames.h>
-/* ******************************************************************
-   FSE : Finite State Entropy codec
-   Public Prototypes declaration
-   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 FSE_H
-#define FSE_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/*-*****************************************
-*  Dependencies
-******************************************/
-#include <stddef.h>    /* size_t, ptrdiff_t */
-
-
-/*-****************************************
-*  FSE simple functions
-******************************************/
-/*! FSE_compress() :
-    Compress content of buffer 'src', of size 'srcSize', into destination buffer 'dst'.
-    'dst' buffer must be already allocated. Compression runs faster is dstCapacity >= FSE_compressBound(srcSize).
-    @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 byte symbol * srcSize times. Use RLE compression instead.
-                     if FSE_isError(return), compression failed (more details using FSE_getErrorName())
-*/
-size_t FSE_compress(void* dst, size_t dstCapacity,
-              const void* src, size_t srcSize);
-
-/*! FSE_decompress():
-    Decompress FSE data from buffer 'cSrc', of size 'cSrcSize',
-    into already allocated destination buffer 'dst', of size 'dstCapacity'.
-    @return : size of regenerated data (<= maxDstSize),
-              or an error code, which can be tested using FSE_isError() .
-
-    ** Important ** : FSE_decompress() does not decompress non-compressible nor RLE data !!!
-    Why ? : making this distinction requires a header.
-    Header management is intentionally delegated to the user layer, which can better manage special cases.
-*/
-size_t FSE_decompress(void* dst,  size_t dstCapacity,
-                const void* cSrc, size_t cSrcSize);
-
-
-/*-*****************************************
-*  Tool functions
-******************************************/
-size_t FSE_compressBound(size_t size);       /* maximum compressed size */
-
-/* Error Management */
-unsigned    FSE_isError(size_t code);        /* tells if a return value is an error code */
-const char* FSE_getErrorName(size_t code);   /* provides error code string (useful for debugging) */
-
-
-/*-*****************************************
-*  FSE advanced functions
-******************************************/
-/*! FSE_compress2() :
-    Same as FSE_compress(), but allows the selection of 'maxSymbolValue' and 'tableLog'
-    Both parameters can be defined as '0' to mean : use default value
-    @return : size of compressed data
-    Special values : if return == 0, srcData is not compressible => Nothing is stored within cSrc !!!
-                     if return == 1, srcData is a single byte symbol * srcSize times. Use RLE compression.
-                     if FSE_isError(return), it's an error code.
-*/
-size_t FSE_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);
-
-
-/*-*****************************************
-*  FSE detailed API
-******************************************/
-/*!
-FSE_compress() does the following:
-1. count symbol occurrence from source[] into table count[]
-2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog)
-3. save normalized counters to memory buffer using writeNCount()
-4. build encoding table 'CTable' from normalized counters
-5. encode the data stream using encoding table 'CTable'
-
-FSE_decompress() does the following:
-1. read normalized counters with readNCount()
-2. build decoding table 'DTable' from normalized counters
-3. decode the data stream using decoding table 'DTable'
-
-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 provide normalized distribution using external method.
-*/
-
-/* *** COMPRESSION *** */
-
-/*! FSE_count():
-    Provides the precise count of each byte within a table 'count'.
-    'count' is a table of unsigned int, of minimum size (*maxSymbolValuePtr+1).
-    *maxSymbolValuePtr will be updated if detected smaller than initial value.
-    @return : the count of the most frequent symbol (which is not identified).
-              if return == srcSize, there is only one symbol.
-              Can also return an error code, which can be tested with FSE_isError(). */
-size_t FSE_count(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize);
-
-/*! FSE_optimalTableLog():
-    dynamically downsize 'tableLog' when conditions are met.
-    It saves CPU time, by using smaller tables, while preserving or even improving compression ratio.
-    @return : recommended tableLog (necessarily <= initial 'tableLog') */
-unsigned FSE_optimalTableLog(unsigned tableLog, size_t srcSize, unsigned maxSymbolValue);
-
-/*! FSE_normalizeCount():
-    normalize counts so that sum(count[]) == Power_of_2 (2^tableLog)
-    'normalizedCounter' is a table of short, of minimum size (maxSymbolValue+1).
-    @return : tableLog,
-              or an errorCode, which can be tested using FSE_isError() */
-size_t FSE_normalizeCount(short* normalizedCounter, unsigned tableLog, const unsigned* count, size_t srcSize, unsigned maxSymbolValue);
-
-/*! FSE_NCountWriteBound():
-    Provides the maximum possible size of an FSE normalized table, given 'maxSymbolValue' and 'tableLog'.
-    Typically useful for allocation purpose. */
-size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog);
-
-/*! FSE_writeNCount():
-    Compactly save 'normalizedCounter' into 'buffer'.
-    @return : size of the compressed table,
-              or an errorCode, which can be tested using FSE_isError(). */
-size_t FSE_writeNCount (void* buffer, size_t bufferSize, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
-
-
-/*! Constructor and Destructor of FSE_CTable.
-    Note that FSE_CTable size depends on 'tableLog' and 'maxSymbolValue' */
-typedef unsigned FSE_CTable;   /* don't allocate that. It's only meant to be more restrictive than void* */
-FSE_CTable* FSE_createCTable (unsigned tableLog, unsigned maxSymbolValue);
-void        FSE_freeCTable (FSE_CTable* ct);
-
-/*! FSE_buildCTable():
-    Builds `ct`, which must be already allocated, using FSE_createCTable().
-    @return : 0, or an errorCode, which can be tested using FSE_isError() */
-size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
-
-/*! FSE_compress_usingCTable():
-    Compress `src` using `ct` into `dst` which must be already allocated.
-    @return : size of compressed data (<= `dstCapacity`),
-              or 0 if compressed data could not fit into `dst`,
-              or an errorCode, which can be tested using FSE_isError() */
-size_t FSE_compress_usingCTable (void* dst, size_t dstCapacity, const void* src, size_t srcSize, const FSE_CTable* ct);
-
-/*!
-Tutorial :
-----------
-The first step is to count all symbols. FSE_count() does this job very fast.
-Result will be saved into 'count', a table of unsigned int, which must be already allocated, and have 'maxSymbolValuePtr[0]+1' cells.
-'src' is a table of bytes of size 'srcSize'. All values within 'src' MUST be <= maxSymbolValuePtr[0]
-maxSymbolValuePtr[0] will be updated, with its real value (necessarily <= original value)
-FSE_count() will return the number of occurrence of the most frequent symbol.
-This can be used to know if there is a single symbol within 'src', and to quickly evaluate its compressibility.
-If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()).
-
-The next step is to normalize the frequencies.
-FSE_normalizeCount() will ensure that sum of frequencies is == 2 ^'tableLog'.
-It also guarantees a minimum of 1 to any Symbol with frequency >= 1.
-You can use 'tableLog'==0 to mean "use default tableLog value".
-If you are unsure of which tableLog value to use, you can ask FSE_optimalTableLog(),
-which will provide the optimal valid tableLog given sourceSize, maxSymbolValue, and a user-defined maximum (0 means "default").
-
-The result of FSE_normalizeCount() will be saved into a table,
-called 'normalizedCounter', which is a table of signed short.
-'normalizedCounter' must be already allocated, and have at least 'maxSymbolValue+1' cells.
-The return value is tableLog if everything proceeded as expected.
-It is 0 if there is a single symbol within distribution.
-If there is an error (ex: invalid tableLog value), the function will return an ErrorCode (which can be tested using FSE_isError()).
-
-'normalizedCounter' can be saved in a compact manner to a memory area using FSE_writeNCount().
-'buffer' must be already allocated.
-For guaranteed success, buffer size must be at least FSE_headerBound().
-The result of the function is the number of bytes written into 'buffer'.
-If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError(); ex : buffer size too small).
-
-'normalizedCounter' can then be used to create the compression table 'CTable'.
-The space required by 'CTable' must be already allocated, using FSE_createCTable().
-You can then use FSE_buildCTable() to fill 'CTable'.
-If there is an error, both functions will return an ErrorCode (which can be tested using FSE_isError()).
-
-'CTable' can then be used to compress 'src', with FSE_compress_usingCTable().
-Similar to FSE_count(), the convention is that 'src' is assumed to be a table of char of size 'srcSize'
-The function returns the size of compressed data (without header), necessarily <= `dstCapacity`.
-If it returns '0', compressed data could not fit into 'dst'.
-If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()).
-*/
-
-
-/* *** DECOMPRESSION *** */
-
-/*! FSE_readNCount():
-    Read compactly saved 'normalizedCounter' from 'rBuffer'.
-    @return : size read from 'rBuffer',
-              or an errorCode, which can be tested using FSE_isError().
-              maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
-size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize);
-
-/*! Constructor and Destructor of FSE_DTable.
-    Note that its size depends on 'tableLog' */
-typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
-FSE_DTable* FSE_createDTable(unsigned tableLog);
-void        FSE_freeDTable(FSE_DTable* dt);
-
-/*! FSE_buildDTable():
-    Builds 'dt', which must be already allocated, using FSE_createDTable().
-    return : 0, or an errorCode, which can be tested using FSE_isError() */
-size_t FSE_buildDTable (FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
-
-/*! FSE_decompress_usingDTable():
-    Decompress compressed source `cSrc` of size `cSrcSize` using `dt`
-    into `dst` which must be already allocated.
-    @return : size of regenerated data (necessarily <= `dstCapacity`),
-              or an errorCode, which can be tested using FSE_isError() */
-size_t FSE_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt);
-
-/*!
-Tutorial :
-----------
-(Note : these functions only decompress FSE-compressed blocks.
- If block is uncompressed, use memcpy() instead
- If block is a single repeated byte, use memset() instead )
-
-The first step is to obtain the normalized frequencies of symbols.
-This can be performed by FSE_readNCount() if it was saved using FSE_writeNCount().
-'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short.
-In practice, that means it's necessary to know 'maxSymbolValue' beforehand,
-or size the table to handle worst case situations (typically 256).
-FSE_readNCount() will provide 'tableLog' and 'maxSymbolValue'.
-The result of FSE_readNCount() is the number of bytes read from 'rBuffer'.
-Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that.
-If there is an error, the function will return an error code, which can be tested using FSE_isError().
-
-The next step is to build the decompression tables 'FSE_DTable' from 'normalizedCounter'.
-This is performed by the function FSE_buildDTable().
-The space required by 'FSE_DTable' must be already allocated using FSE_createDTable().
-If there is an error, the function will return an error code, which can be tested using FSE_isError().
-
-`FSE_DTable` can then be used to decompress `cSrc`, with FSE_decompress_usingDTable().
-`cSrcSize` must be strictly correct, otherwise decompression will fail.
-FSE_decompress_usingDTable() result will tell how many bytes were regenerated (<=`dstCapacity`).
-If there is an error, the function will return an error code, which can be tested using FSE_isError(). (ex: dst buffer too small)
-*/
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* FSE_H */
+/* ****************************************************************** 
+   FSE : Finite State Entropy codec 
+   Public Prototypes declaration 
+   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 FSE_H 
+#define FSE_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/*-***************************************** 
+*  Dependencies 
+******************************************/ 
+#include <stddef.h>    /* size_t, ptrdiff_t */ 
+ 
+ 
+/*-**************************************** 
+*  FSE simple functions 
+******************************************/ 
+/*! FSE_compress() : 
+    Compress content of buffer 'src', of size 'srcSize', into destination buffer 'dst'. 
+    'dst' buffer must be already allocated. Compression runs faster is dstCapacity >= FSE_compressBound(srcSize). 
+    @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 byte symbol * srcSize times. Use RLE compression instead. 
+                     if FSE_isError(return), compression failed (more details using FSE_getErrorName()) 
+*/ 
+size_t FSE_compress(void* dst, size_t dstCapacity, 
+              const void* src, size_t srcSize); 
+ 
+/*! FSE_decompress(): 
+    Decompress FSE data from buffer 'cSrc', of size 'cSrcSize', 
+    into already allocated destination buffer 'dst', of size 'dstCapacity'. 
+    @return : size of regenerated data (<= maxDstSize), 
+              or an error code, which can be tested using FSE_isError() . 
+ 
+    ** Important ** : FSE_decompress() does not decompress non-compressible nor RLE data !!! 
+    Why ? : making this distinction requires a header. 
+    Header management is intentionally delegated to the user layer, which can better manage special cases. 
+*/ 
+size_t FSE_decompress(void* dst,  size_t dstCapacity, 
+                const void* cSrc, size_t cSrcSize); 
+ 
+ 
+/*-***************************************** 
+*  Tool functions 
+******************************************/ 
+size_t FSE_compressBound(size_t size);       /* maximum compressed size */ 
+ 
+/* Error Management */ 
+unsigned    FSE_isError(size_t code);        /* tells if a return value is an error code */ 
+const char* FSE_getErrorName(size_t code);   /* provides error code string (useful for debugging) */ 
+ 
+ 
+/*-***************************************** 
+*  FSE advanced functions 
+******************************************/ 
+/*! FSE_compress2() : 
+    Same as FSE_compress(), but allows the selection of 'maxSymbolValue' and 'tableLog' 
+    Both parameters can be defined as '0' to mean : use default value 
+    @return : size of compressed data 
+    Special values : if return == 0, srcData is not compressible => Nothing is stored within cSrc !!! 
+                     if return == 1, srcData is a single byte symbol * srcSize times. Use RLE compression. 
+                     if FSE_isError(return), it's an error code. 
+*/ 
+size_t FSE_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog); 
+ 
+ 
+/*-***************************************** 
+*  FSE detailed API 
+******************************************/ 
+/*! 
+FSE_compress() does the following: 
+1. count symbol occurrence from source[] into table count[] 
+2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog) 
+3. save normalized counters to memory buffer using writeNCount() 
+4. build encoding table 'CTable' from normalized counters 
+5. encode the data stream using encoding table 'CTable' 
+ 
+FSE_decompress() does the following: 
+1. read normalized counters with readNCount() 
+2. build decoding table 'DTable' from normalized counters 
+3. decode the data stream using decoding table 'DTable' 
+ 
+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 provide normalized distribution using external method. 
+*/ 
+ 
+/* *** COMPRESSION *** */ 
+ 
+/*! FSE_count(): 
+    Provides the precise count of each byte within a table 'count'. 
+    'count' is a table of unsigned int, of minimum size (*maxSymbolValuePtr+1). 
+    *maxSymbolValuePtr will be updated if detected smaller than initial value. 
+    @return : the count of the most frequent symbol (which is not identified). 
+              if return == srcSize, there is only one symbol. 
+              Can also return an error code, which can be tested with FSE_isError(). */ 
+size_t FSE_count(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize); 
+ 
+/*! FSE_optimalTableLog(): 
+    dynamically downsize 'tableLog' when conditions are met. 
+    It saves CPU time, by using smaller tables, while preserving or even improving compression ratio. 
+    @return : recommended tableLog (necessarily <= initial 'tableLog') */ 
+unsigned FSE_optimalTableLog(unsigned tableLog, size_t srcSize, unsigned maxSymbolValue); 
+ 
+/*! FSE_normalizeCount(): 
+    normalize counts so that sum(count[]) == Power_of_2 (2^tableLog) 
+    'normalizedCounter' is a table of short, of minimum size (maxSymbolValue+1). 
+    @return : tableLog, 
+              or an errorCode, which can be tested using FSE_isError() */ 
+size_t FSE_normalizeCount(short* normalizedCounter, unsigned tableLog, const unsigned* count, size_t srcSize, unsigned maxSymbolValue); 
+ 
+/*! FSE_NCountWriteBound(): 
+    Provides the maximum possible size of an FSE normalized table, given 'maxSymbolValue' and 'tableLog'. 
+    Typically useful for allocation purpose. */ 
+size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog); 
+ 
+/*! FSE_writeNCount(): 
+    Compactly save 'normalizedCounter' into 'buffer'. 
+    @return : size of the compressed table, 
+              or an errorCode, which can be tested using FSE_isError(). */ 
+size_t FSE_writeNCount (void* buffer, size_t bufferSize, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog); 
+ 
+ 
+/*! Constructor and Destructor of FSE_CTable. 
+    Note that FSE_CTable size depends on 'tableLog' and 'maxSymbolValue' */ 
+typedef unsigned FSE_CTable;   /* don't allocate that. It's only meant to be more restrictive than void* */ 
+FSE_CTable* FSE_createCTable (unsigned tableLog, unsigned maxSymbolValue); 
+void        FSE_freeCTable (FSE_CTable* ct); 
+ 
+/*! FSE_buildCTable(): 
+    Builds `ct`, which must be already allocated, using FSE_createCTable(). 
+    @return : 0, or an errorCode, which can be tested using FSE_isError() */ 
+size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog); 
+ 
+/*! FSE_compress_usingCTable(): 
+    Compress `src` using `ct` into `dst` which must be already allocated. 
+    @return : size of compressed data (<= `dstCapacity`), 
+              or 0 if compressed data could not fit into `dst`, 
+              or an errorCode, which can be tested using FSE_isError() */ 
+size_t FSE_compress_usingCTable (void* dst, size_t dstCapacity, const void* src, size_t srcSize, const FSE_CTable* ct); 
+ 
+/*! 
+Tutorial : 
+---------- 
+The first step is to count all symbols. FSE_count() does this job very fast. 
+Result will be saved into 'count', a table of unsigned int, which must be already allocated, and have 'maxSymbolValuePtr[0]+1' cells. 
+'src' is a table of bytes of size 'srcSize'. All values within 'src' MUST be <= maxSymbolValuePtr[0] 
+maxSymbolValuePtr[0] will be updated, with its real value (necessarily <= original value) 
+FSE_count() will return the number of occurrence of the most frequent symbol. 
+This can be used to know if there is a single symbol within 'src', and to quickly evaluate its compressibility. 
+If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()). 
+ 
+The next step is to normalize the frequencies. 
+FSE_normalizeCount() will ensure that sum of frequencies is == 2 ^'tableLog'. 
+It also guarantees a minimum of 1 to any Symbol with frequency >= 1. 
+You can use 'tableLog'==0 to mean "use default tableLog value". 
+If you are unsure of which tableLog value to use, you can ask FSE_optimalTableLog(), 
+which will provide the optimal valid tableLog given sourceSize, maxSymbolValue, and a user-defined maximum (0 means "default"). 
+ 
+The result of FSE_normalizeCount() will be saved into a table, 
+called 'normalizedCounter', which is a table of signed short. 
+'normalizedCounter' must be already allocated, and have at least 'maxSymbolValue+1' cells. 
+The return value is tableLog if everything proceeded as expected. 
+It is 0 if there is a single symbol within distribution. 
+If there is an error (ex: invalid tableLog value), the function will return an ErrorCode (which can be tested using FSE_isError()). 
+ 
+'normalizedCounter' can be saved in a compact manner to a memory area using FSE_writeNCount(). 
+'buffer' must be already allocated. 
+For guaranteed success, buffer size must be at least FSE_headerBound(). 
+The result of the function is the number of bytes written into 'buffer'. 
+If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError(); ex : buffer size too small). 
+ 
+'normalizedCounter' can then be used to create the compression table 'CTable'. 
+The space required by 'CTable' must be already allocated, using FSE_createCTable(). 
+You can then use FSE_buildCTable() to fill 'CTable'. 
+If there is an error, both functions will return an ErrorCode (which can be tested using FSE_isError()). 
+ 
+'CTable' can then be used to compress 'src', with FSE_compress_usingCTable(). 
+Similar to FSE_count(), the convention is that 'src' is assumed to be a table of char of size 'srcSize' 
+The function returns the size of compressed data (without header), necessarily <= `dstCapacity`. 
+If it returns '0', compressed data could not fit into 'dst'. 
+If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()). 
+*/ 
+ 
+ 
+/* *** DECOMPRESSION *** */ 
+ 
+/*! FSE_readNCount(): 
+    Read compactly saved 'normalizedCounter' from 'rBuffer'. 
+    @return : size read from 'rBuffer', 
+              or an errorCode, which can be tested using FSE_isError(). 
+              maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */ 
+size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize); 
+ 
+/*! Constructor and Destructor of FSE_DTable. 
+    Note that its size depends on 'tableLog' */ 
+typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */ 
+FSE_DTable* FSE_createDTable(unsigned tableLog); 
+void        FSE_freeDTable(FSE_DTable* dt); 
+ 
+/*! FSE_buildDTable(): 
+    Builds 'dt', which must be already allocated, using FSE_createDTable(). 
+    return : 0, or an errorCode, which can be tested using FSE_isError() */ 
+size_t FSE_buildDTable (FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog); 
+ 
+/*! FSE_decompress_usingDTable(): 
+    Decompress compressed source `cSrc` of size `cSrcSize` using `dt` 
+    into `dst` which must be already allocated. 
+    @return : size of regenerated data (necessarily <= `dstCapacity`), 
+              or an errorCode, which can be tested using FSE_isError() */ 
+size_t FSE_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt); 
+ 
+/*! 
+Tutorial : 
+---------- 
+(Note : these functions only decompress FSE-compressed blocks. 
+ If block is uncompressed, use memcpy() instead 
+ If block is a single repeated byte, use memset() instead ) 
+ 
+The first step is to obtain the normalized frequencies of symbols. 
+This can be performed by FSE_readNCount() if it was saved using FSE_writeNCount(). 
+'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short. 
+In practice, that means it's necessary to know 'maxSymbolValue' beforehand, 
+or size the table to handle worst case situations (typically 256). 
+FSE_readNCount() will provide 'tableLog' and 'maxSymbolValue'. 
+The result of FSE_readNCount() is the number of bytes read from 'rBuffer'. 
+Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that. 
+If there is an error, the function will return an error code, which can be tested using FSE_isError(). 
+ 
+The next step is to build the decompression tables 'FSE_DTable' from 'normalizedCounter'. 
+This is performed by the function FSE_buildDTable(). 
+The space required by 'FSE_DTable' must be already allocated using FSE_createDTable(). 
+If there is an error, the function will return an error code, which can be tested using FSE_isError(). 
+ 
+`FSE_DTable` can then be used to decompress `cSrc`, with FSE_decompress_usingDTable(). 
+`cSrcSize` must be strictly correct, otherwise decompression will fail. 
+FSE_decompress_usingDTable() result will tell how many bytes were regenerated (<=`dstCapacity`). 
+If there is an error, the function will return an error code, which can be tested using FSE_isError(). (ex: dst buffer too small) 
+*/ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* FSE_H */ 
diff --git a/contrib/libs/zstd06/common/fse_static.h b/contrib/libs/zstd06/common/fse_static.h
index d09589efee..9ecb0b2cb9 100644
--- a/contrib/libs/zstd06/common/fse_static.h
+++ b/contrib/libs/zstd06/common/fse_static.h
@@ -1,340 +1,340 @@
 #include <contrib/libs/zstd06/renames.h>
-/* ******************************************************************
-   FSE : Finite State Entropy coder
-   header file for static linking (only)
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef FSE_STATIC_H
-#define FSE_STATIC_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* *****************************************
-*  Dependencies
-*******************************************/
-#include "fse.h"
-#include "bitstream.h"
-
-
-/* *****************************************
-*  Static allocation
-*******************************************/
-/* FSE buffer bounds */
-#define FSE_NCOUNTBOUND 512
-#define FSE_BLOCKBOUND(size) (size + (size>>7))
-#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
-
-/* It is possible to statically allocate FSE CTable/DTable as a table of unsigned using below macros */
-#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))
-#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
-
-
-/* *****************************************
-*  FSE advanced API
-*******************************************/
-size_t FSE_countFast(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize);
-/* same as FSE_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr  */
-
-size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits);
-/* build a fake FSE_CTable, designed to not compress an input, where each symbol uses nbBits */
-
-size_t FSE_buildCTable_rle (FSE_CTable* ct, unsigned char symbolValue);
-/* build a fake FSE_CTable, designed to compress always the same symbolValue */
-
-size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);
-/* build a fake FSE_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */
-
-size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);
-/* build a fake FSE_DTable, designed to always generate the same symbolValue */
-
-
-/* *****************************************
-*  FSE symbol compression API
-*******************************************/
-/*!
-   This API consists of small unitary functions, which highly benefit from being inlined.
-   You will want to enable link-time-optimization to ensure these functions are properly inlined in your binary.
-   Visual seems to do it automatically.
-   For gcc or clang, you'll need to add -flto flag at compilation and linking stages.
-   If none of these solutions is applicable, include "fse.c" directly.
-*/
-typedef struct
-{
-    ptrdiff_t   value;
-    const void* stateTable;
-    const void* symbolTT;
-    unsigned    stateLog;
-} FSE_CState_t;
-
-static void FSE_initCState(FSE_CState_t* CStatePtr, const FSE_CTable* ct);
-
-static void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* CStatePtr, unsigned symbol);
-
-static void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* CStatePtr);
-
-/*!
-These functions are inner components of FSE_compress_usingCTable().
-They allow the creation of custom streams, mixing multiple tables and bit sources.
-
-A key property to keep in mind is that encoding and decoding are done **in reverse direction**.
-So the first symbol you will encode is the last you will decode, like a LIFO stack.
-
-You will need a few variables to track your CStream. They are :
-
-FSE_CTable    ct;         // Provided by FSE_buildCTable()
-BIT_CStream_t bitStream;  // bitStream tracking structure
-FSE_CState_t  state;      // State tracking structure (can have several)
-
-
-The first thing to do is to init bitStream and state.
-    size_t errorCode = BIT_initCStream(&bitStream, dstBuffer, maxDstSize);
-    FSE_initCState(&state, ct);
-
-Note that BIT_initCStream() can produce an error code, so its result should be tested, using FSE_isError();
-You can then encode your input data, byte after byte.
-FSE_encodeSymbol() outputs a maximum of 'tableLog' bits at a time.
-Remember decoding will be done in reverse direction.
-    FSE_encodeByte(&bitStream, &state, symbol);
-
-At any time, you can also add any bit sequence.
-Note : maximum allowed nbBits is 25, for compatibility with 32-bits decoders
-    BIT_addBits(&bitStream, bitField, nbBits);
-
-The above methods don't commit data to memory, they just store it into local register, for speed.
-Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
-Writing data to memory is a manual operation, performed by the flushBits function.
-    BIT_flushBits(&bitStream);
-
-Your last FSE encoding operation shall be to flush your last state value(s).
-    FSE_flushState(&bitStream, &state);
-
-Finally, you must close the bitStream.
-The function returns the size of CStream in bytes.
-If data couldn't fit into dstBuffer, it will return a 0 ( == not compressible)
-If there is an error, it returns an errorCode (which can be tested using FSE_isError()).
-    size_t size = BIT_closeCStream(&bitStream);
-*/
-
-
-/* *****************************************
-*  FSE symbol decompression API
-*******************************************/
-typedef struct
-{
-    size_t      state;
-    const void* table;   /* precise table may vary, depending on U16 */
-} FSE_DState_t;
-
-
-static void     FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);
-
-static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
-
-static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
-
-/*!
-Let's now decompose FSE_decompress_usingDTable() into its unitary components.
-You will decode FSE-encoded symbols from the bitStream,
-and also any other bitFields you put in, **in reverse order**.
-
-You will need a few variables to track your bitStream. They are :
-
-BIT_DStream_t DStream;    // Stream context
-FSE_DState_t  DState;     // State context. Multiple ones are possible
-FSE_DTable*   DTablePtr;  // Decoding table, provided by FSE_buildDTable()
-
-The first thing to do is to init the bitStream.
-    errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize);
-
-You should then retrieve your initial state(s)
-(in reverse flushing order if you have several ones) :
-    errorCode = FSE_initDState(&DState, &DStream, DTablePtr);
-
-You can then decode your data, symbol after symbol.
-For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'.
-Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
-    unsigned char symbol = FSE_decodeSymbol(&DState, &DStream);
-
-You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
-Note : maximum allowed nbBits is 25, for 32-bits compatibility
-    size_t bitField = BIT_readBits(&DStream, nbBits);
-
-All above operations only read from local register (which size depends on size_t).
-Refueling the register from memory is manually performed by the reload method.
-    endSignal = FSE_reloadDStream(&DStream);
-
-BIT_reloadDStream() result tells if there is still some more data to read from DStream.
-BIT_DStream_unfinished : there is still some data left into the DStream.
-BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
-BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
-BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted.
-
-When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
-to properly detect the exact end of stream.
-After each decoded symbol, check if DStream is fully consumed using this simple test :
-    BIT_reloadDStream(&DStream) >= BIT_DStream_completed
-
-When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
-Checking if DStream has reached its end is performed by :
-    BIT_endOfDStream(&DStream);
-Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
-    FSE_endOfDState(&DState);
-*/
-
-
-/* *****************************************
-*  FSE unsafe API
-*******************************************/
-static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
-/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
-
-
-/* *****************************************
-*  Implementation of inlined functions
-*******************************************/
-typedef struct {
-    int deltaFindState;
-    U32 deltaNbBits;
-} FSE_symbolCompressionTransform; /* total 8 bytes */
-
-MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct)
-{
-    const void* ptr = ct;
-    const U16* u16ptr = (const U16*) ptr;
-    const U32 tableLog = MEM_read16(ptr);
-    statePtr->value = (ptrdiff_t)1<<tableLog;
-    statePtr->stateTable = u16ptr+2;
-    statePtr->symbolTT = ((const U32*)ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1));
-    statePtr->stateLog = tableLog;
-}
-
-MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U32 symbol)
-{
-    FSE_initCState(statePtr, ct);
-    {
-        const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
-        const U16* stateTable = (const U16*)(statePtr->stateTable);
-        U32 nbBitsOut  = (U32)((symbolTT.deltaNbBits + (1<<15)) >> 16);
-        statePtr->value = (nbBitsOut << 16) - symbolTT.deltaNbBits;
-        statePtr->value = stateTable[(statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
-
-    }
-}
-
-MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, U32 symbol)
-{
-    const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
-    const U16* const stateTable = (const U16*)(statePtr->stateTable);
-    U32 nbBitsOut  = (U32)((statePtr->value + symbolTT.deltaNbBits) >> 16);
-    BIT_addBits(bitC, statePtr->value, nbBitsOut);
-    statePtr->value = stateTable[ (statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
-}
-
-MEM_STATIC void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* statePtr)
-{
-    BIT_addBits(bitC, statePtr->value, statePtr->stateLog);
-    BIT_flushBits(bitC);
-}
-
-/*<=====    Decompression    =====>*/
-
-typedef struct {
-    U16 tableLog;
-    U16 fastMode;
-} FSE_DTableHeader;   /* sizeof U32 */
-
-typedef struct
-{
-    unsigned short newState;
-    unsigned char  symbol;
-    unsigned char  nbBits;
-} FSE_decode_t;   /* size == U32 */
-
-MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
-{
-    const void* ptr = dt;
-    const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr;
-    DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
-    BIT_reloadDStream(bitD);
-    DStatePtr->table = dt + 1;
-}
-
-MEM_STATIC BYTE FSE_peekSymbol(const FSE_DState_t* DStatePtr)
-{
-    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    return DInfo.symbol;
-}
-
-MEM_STATIC void FSE_updateState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
-{
-    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    U32 const nbBits = DInfo.nbBits;
-    size_t const lowBits = BIT_readBits(bitD, nbBits);
-    DStatePtr->state = DInfo.newState + lowBits;
-}
-
-MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
-{
-    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    U32 const nbBits = DInfo.nbBits;
-    BYTE const symbol = DInfo.symbol;
-    size_t const lowBits = BIT_readBits(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-/*! FSE_decodeSymbolFast() :
-    unsafe, only works if no symbol has a probability > 50% */
-MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
-{
-    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    U32 const nbBits = DInfo.nbBits;
-    BYTE const symbol = DInfo.symbol;
-    size_t const lowBits = BIT_readBitsFast(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
-{
-    return DStatePtr->state == 0;
-}
-
-
+/* ****************************************************************** 
+   FSE : Finite State Entropy coder 
+   header file for static linking (only) 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef FSE_STATIC_H 
+#define FSE_STATIC_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* ***************************************** 
+*  Dependencies 
+*******************************************/ 
+#include "fse.h" 
+#include "bitstream.h" 
+ 
+ 
+/* ***************************************** 
+*  Static allocation 
+*******************************************/ 
+/* FSE buffer bounds */ 
+#define FSE_NCOUNTBOUND 512 
+#define FSE_BLOCKBOUND(size) (size + (size>>7)) 
+#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */ 
+ 
+/* It is possible to statically allocate FSE CTable/DTable as a table of unsigned using below macros */ 
+#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2)) 
+#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog)) 
+ 
+ 
+/* ***************************************** 
+*  FSE advanced API 
+*******************************************/ 
+size_t FSE_countFast(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize); 
+/* same as FSE_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr  */ 
+ 
+size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits); 
+/* build a fake FSE_CTable, designed to not compress an input, where each symbol uses nbBits */ 
+ 
+size_t FSE_buildCTable_rle (FSE_CTable* ct, unsigned char symbolValue); 
+/* build a fake FSE_CTable, designed to compress always the same symbolValue */ 
+ 
+size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits); 
+/* build a fake FSE_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */ 
+ 
+size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue); 
+/* build a fake FSE_DTable, designed to always generate the same symbolValue */ 
+ 
+ 
+/* ***************************************** 
+*  FSE symbol compression API 
+*******************************************/ 
+/*! 
+   This API consists of small unitary functions, which highly benefit from being inlined. 
+   You will want to enable link-time-optimization to ensure these functions are properly inlined in your binary. 
+   Visual seems to do it automatically. 
+   For gcc or clang, you'll need to add -flto flag at compilation and linking stages. 
+   If none of these solutions is applicable, include "fse.c" directly. 
+*/ 
+typedef struct 
+{ 
+    ptrdiff_t   value; 
+    const void* stateTable; 
+    const void* symbolTT; 
+    unsigned    stateLog; 
+} FSE_CState_t; 
+ 
+static void FSE_initCState(FSE_CState_t* CStatePtr, const FSE_CTable* ct); 
+ 
+static void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* CStatePtr, unsigned symbol); 
+ 
+static void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* CStatePtr); 
+ 
+/*! 
+These functions are inner components of FSE_compress_usingCTable(). 
+They allow the creation of custom streams, mixing multiple tables and bit sources. 
+ 
+A key property to keep in mind is that encoding and decoding are done **in reverse direction**. 
+So the first symbol you will encode is the last you will decode, like a LIFO stack. 
+ 
+You will need a few variables to track your CStream. They are : 
+ 
+FSE_CTable    ct;         // Provided by FSE_buildCTable() 
+BIT_CStream_t bitStream;  // bitStream tracking structure 
+FSE_CState_t  state;      // State tracking structure (can have several) 
+ 
+ 
+The first thing to do is to init bitStream and state. 
+    size_t errorCode = BIT_initCStream(&bitStream, dstBuffer, maxDstSize); 
+    FSE_initCState(&state, ct); 
+ 
+Note that BIT_initCStream() can produce an error code, so its result should be tested, using FSE_isError(); 
+You can then encode your input data, byte after byte. 
+FSE_encodeSymbol() outputs a maximum of 'tableLog' bits at a time. 
+Remember decoding will be done in reverse direction. 
+    FSE_encodeByte(&bitStream, &state, symbol); 
+ 
+At any time, you can also add any bit sequence. 
+Note : maximum allowed nbBits is 25, for compatibility with 32-bits decoders 
+    BIT_addBits(&bitStream, bitField, nbBits); 
+ 
+The above methods don't commit data to memory, they just store it into local register, for speed. 
+Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t). 
+Writing data to memory is a manual operation, performed by the flushBits function. 
+    BIT_flushBits(&bitStream); 
+ 
+Your last FSE encoding operation shall be to flush your last state value(s). 
+    FSE_flushState(&bitStream, &state); 
+ 
+Finally, you must close the bitStream. 
+The function returns the size of CStream in bytes. 
+If data couldn't fit into dstBuffer, it will return a 0 ( == not compressible) 
+If there is an error, it returns an errorCode (which can be tested using FSE_isError()). 
+    size_t size = BIT_closeCStream(&bitStream); 
+*/ 
+ 
+ 
+/* ***************************************** 
+*  FSE symbol decompression API 
+*******************************************/ 
+typedef struct 
+{ 
+    size_t      state; 
+    const void* table;   /* precise table may vary, depending on U16 */ 
+} FSE_DState_t; 
+ 
+ 
+static void     FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt); 
+ 
+static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD); 
+ 
+static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr); 
+ 
+/*! 
+Let's now decompose FSE_decompress_usingDTable() into its unitary components. 
+You will decode FSE-encoded symbols from the bitStream, 
+and also any other bitFields you put in, **in reverse order**. 
+ 
+You will need a few variables to track your bitStream. They are : 
+ 
+BIT_DStream_t DStream;    // Stream context 
+FSE_DState_t  DState;     // State context. Multiple ones are possible 
+FSE_DTable*   DTablePtr;  // Decoding table, provided by FSE_buildDTable() 
+ 
+The first thing to do is to init the bitStream. 
+    errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize); 
+ 
+You should then retrieve your initial state(s) 
+(in reverse flushing order if you have several ones) : 
+    errorCode = FSE_initDState(&DState, &DStream, DTablePtr); 
+ 
+You can then decode your data, symbol after symbol. 
+For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'. 
+Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out). 
+    unsigned char symbol = FSE_decodeSymbol(&DState, &DStream); 
+ 
+You can retrieve any bitfield you eventually stored into the bitStream (in reverse order) 
+Note : maximum allowed nbBits is 25, for 32-bits compatibility 
+    size_t bitField = BIT_readBits(&DStream, nbBits); 
+ 
+All above operations only read from local register (which size depends on size_t). 
+Refueling the register from memory is manually performed by the reload method. 
+    endSignal = FSE_reloadDStream(&DStream); 
+ 
+BIT_reloadDStream() result tells if there is still some more data to read from DStream. 
+BIT_DStream_unfinished : there is still some data left into the DStream. 
+BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled. 
+BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed. 
+BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted. 
+ 
+When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop, 
+to properly detect the exact end of stream. 
+After each decoded symbol, check if DStream is fully consumed using this simple test : 
+    BIT_reloadDStream(&DStream) >= BIT_DStream_completed 
+ 
+When it's done, verify decompression is fully completed, by checking both DStream and the relevant states. 
+Checking if DStream has reached its end is performed by : 
+    BIT_endOfDStream(&DStream); 
+Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible. 
+    FSE_endOfDState(&DState); 
+*/ 
+ 
+ 
+/* ***************************************** 
+*  FSE unsafe API 
+*******************************************/ 
+static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD); 
+/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */ 
+ 
+ 
+/* ***************************************** 
+*  Implementation of inlined functions 
+*******************************************/ 
+typedef struct { 
+    int deltaFindState; 
+    U32 deltaNbBits; 
+} FSE_symbolCompressionTransform; /* total 8 bytes */ 
+ 
+MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct) 
+{ 
+    const void* ptr = ct; 
+    const U16* u16ptr = (const U16*) ptr; 
+    const U32 tableLog = MEM_read16(ptr); 
+    statePtr->value = (ptrdiff_t)1<<tableLog; 
+    statePtr->stateTable = u16ptr+2; 
+    statePtr->symbolTT = ((const U32*)ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1)); 
+    statePtr->stateLog = tableLog; 
+} 
+ 
+MEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U32 symbol) 
+{ 
+    FSE_initCState(statePtr, ct); 
+    { 
+        const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol]; 
+        const U16* stateTable = (const U16*)(statePtr->stateTable); 
+        U32 nbBitsOut  = (U32)((symbolTT.deltaNbBits + (1<<15)) >> 16); 
+        statePtr->value = (nbBitsOut << 16) - symbolTT.deltaNbBits; 
+        statePtr->value = stateTable[(statePtr->value >> nbBitsOut) + symbolTT.deltaFindState]; 
+ 
+    } 
+} 
+ 
+MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, U32 symbol) 
+{ 
+    const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol]; 
+    const U16* const stateTable = (const U16*)(statePtr->stateTable); 
+    U32 nbBitsOut  = (U32)((statePtr->value + symbolTT.deltaNbBits) >> 16); 
+    BIT_addBits(bitC, statePtr->value, nbBitsOut); 
+    statePtr->value = stateTable[ (statePtr->value >> nbBitsOut) + symbolTT.deltaFindState]; 
+} 
+ 
+MEM_STATIC void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* statePtr) 
+{ 
+    BIT_addBits(bitC, statePtr->value, statePtr->stateLog); 
+    BIT_flushBits(bitC); 
+} 
+ 
+/*<=====    Decompression    =====>*/ 
+ 
+typedef struct { 
+    U16 tableLog; 
+    U16 fastMode; 
+} FSE_DTableHeader;   /* sizeof U32 */ 
+ 
+typedef struct 
+{ 
+    unsigned short newState; 
+    unsigned char  symbol; 
+    unsigned char  nbBits; 
+} FSE_decode_t;   /* size == U32 */ 
+ 
+MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt) 
+{ 
+    const void* ptr = dt; 
+    const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr; 
+    DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog); 
+    BIT_reloadDStream(bitD); 
+    DStatePtr->table = dt + 1; 
+} 
+ 
+MEM_STATIC BYTE FSE_peekSymbol(const FSE_DState_t* DStatePtr) 
+{ 
+    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    return DInfo.symbol; 
+} 
+ 
+MEM_STATIC void FSE_updateState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) 
+{ 
+    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    U32 const nbBits = DInfo.nbBits; 
+    size_t const lowBits = BIT_readBits(bitD, nbBits); 
+    DStatePtr->state = DInfo.newState + lowBits; 
+} 
+ 
+MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) 
+{ 
+    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    U32 const nbBits = DInfo.nbBits; 
+    BYTE const symbol = DInfo.symbol; 
+    size_t const lowBits = BIT_readBits(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+/*! FSE_decodeSymbolFast() : 
+    unsafe, only works if no symbol has a probability > 50% */ 
+MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) 
+{ 
+    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    U32 const nbBits = DInfo.nbBits; 
+    BYTE const symbol = DInfo.symbol; 
+    size_t const lowBits = BIT_readBitsFast(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr) 
+{ 
+    return DStatePtr->state == 0; 
+} 
+ 
+ 
 
 #ifndef FSE_COMMONDEFS_ONLY
 
@@ -383,8 +383,8 @@ MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
 #define FSE_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3)
 
 
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* FSE_STATIC_H */
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* FSE_STATIC_H */ 
diff --git a/contrib/libs/zstd06/common/mem.h b/contrib/libs/zstd06/common/mem.h
index 85d78c84c1..1b84bfdb3d 100644
--- a/contrib/libs/zstd06/common/mem.h
+++ b/contrib/libs/zstd06/common/mem.h
@@ -1,201 +1,201 @@
 #include <contrib/libs/zstd06/renames.h>
-/* ******************************************************************
-   mem.h
-   low-level memory access routines
-   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
-****************************************************************** */
-#ifndef MEM_H_MODULE
-#define MEM_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/*-****************************************
-*  Dependencies
-******************************************/
+/* ****************************************************************** 
+   mem.h 
+   low-level memory access routines 
+   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 
+****************************************************************** */ 
+#ifndef MEM_H_MODULE 
+#define MEM_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/*-**************************************** 
+*  Dependencies 
+******************************************/ 
 #include <stddef.h>     /* size_t, ptrdiff_t */
 #include <string.h>     /* memcpy */
-
-
-/*-****************************************
-*  Compiler specifics
-******************************************/
+ 
+ 
+/*-**************************************** 
+*  Compiler specifics 
+******************************************/ 
 #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 */)
-#  define MEM_STATIC static inline
-#elif defined(_MSC_VER)
-#  define MEM_STATIC static __inline
-#else
-#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
-#endif
-
+#if defined(__GNUC__) 
+#  define MEM_STATIC static __attribute__((unused)) 
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+#  define MEM_STATIC static inline 
+#elif defined(_MSC_VER) 
+#  define MEM_STATIC static __inline 
+#else 
+#  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)); }
+ 
 
-
-/*-**************************************************************
-*  Basic Types
-*****************************************************************/
+/*-************************************************************** 
+*  Basic Types 
+*****************************************************************/ 
 #if  !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
-# include <stdint.h>
-  typedef  uint8_t BYTE;
-  typedef uint16_t U16;
-  typedef  int16_t S16;
-  typedef uint32_t U32;
-  typedef  int32_t S32;
-  typedef uint64_t U64;
-  typedef  int64_t S64;
-#else
-  typedef unsigned char       BYTE;
-  typedef unsigned short      U16;
-  typedef   signed short      S16;
-  typedef unsigned int        U32;
-  typedef   signed int        S32;
-  typedef unsigned long long  U64;
-  typedef   signed long long  S64;
-#endif
-
-
-/*-**************************************************************
-*  Memory I/O
-*****************************************************************/
-/* MEM_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 is portable but violate C standard.
- *            It can generate buggy code on targets depending on alignment.
- *            In some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
- * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
- * Prefer these methods in priority order (0 > 1 > 2)
- */
-#ifndef MEM_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 MEM_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 MEM_FORCE_MEMORY_ACCESS 1
-#  endif
-#endif
-
+# include <stdint.h> 
+  typedef  uint8_t BYTE; 
+  typedef uint16_t U16; 
+  typedef  int16_t S16; 
+  typedef uint32_t U32; 
+  typedef  int32_t S32; 
+  typedef uint64_t U64; 
+  typedef  int64_t S64; 
+#else 
+  typedef unsigned char       BYTE; 
+  typedef unsigned short      U16; 
+  typedef   signed short      S16; 
+  typedef unsigned int        U32; 
+  typedef   signed int        S32; 
+  typedef unsigned long long  U64; 
+  typedef   signed long long  S64; 
+#endif 
+ 
+ 
+/*-************************************************************** 
+*  Memory I/O 
+*****************************************************************/ 
+/* MEM_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 is portable but violate C standard. 
+ *            It can generate buggy code on targets depending on alignment. 
+ *            In some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) 
+ * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details. 
+ * Prefer these methods in priority order (0 > 1 > 2) 
+ */ 
+#ifndef MEM_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 MEM_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 MEM_FORCE_MEMORY_ACCESS 1 
+#  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_isLittleEndian(void)
-{
-    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
-    return one.c[0];
-}
-
-#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)
-
-/* violates C standard, by lying on structure alignment.
-Only use if no other choice to achieve best performance on target platform */
-MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
-MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
-MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
-MEM_STATIC U64 MEM_readST(const void* memPtr) { return *(const size_t*) memPtr; }
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
-MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
-MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }
-
-#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_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 { U16 u16; U32 u32; U64 u64; size_t st; } __attribute__((packed)) unalign;
-
-MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
-MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
-MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
-MEM_STATIC U64 MEM_readST(const void* ptr) { return ((const unalign*)ptr)->st; }
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
-MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; }
-MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign*)memPtr)->u64 = value; }
-
-#else
-
-/* default method, safe and standard.
-   can sometimes prove slower */
-
-MEM_STATIC U16 MEM_read16(const void* memPtr)
-{
-    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC U32 MEM_read32(const void* memPtr)
-{
-    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC U64 MEM_read64(const void* memPtr)
-{
-    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC size_t MEM_readST(const void* memPtr)
-{
-    size_t val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-MEM_STATIC void MEM_write32(void* memPtr, U32 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-MEM_STATIC void MEM_write64(void* memPtr, U64 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-#endif /* MEM_FORCE_MEMORY_ACCESS */
-
+ 
+MEM_STATIC unsigned MEM_isLittleEndian(void) 
+{ 
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */ 
+    return one.c[0]; 
+} 
+ 
+#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2) 
+ 
+/* violates C standard, by lying on structure alignment. 
+Only use if no other choice to achieve best performance on target platform */ 
+MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; } 
+MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; } 
+MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; } 
+MEM_STATIC U64 MEM_readST(const void* memPtr) { return *(const size_t*) memPtr; } 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; } 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; } 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; } 
+ 
+#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_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 { U16 u16; U32 u32; U64 u64; size_t st; } __attribute__((packed)) unalign; 
+ 
+MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; } 
+MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; } 
+MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; } 
+MEM_STATIC U64 MEM_readST(const void* ptr) { return ((const unalign*)ptr)->st; } 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; } 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; } 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign*)memPtr)->u64 = value; } 
+ 
+#else 
+ 
+/* default method, safe and standard. 
+   can sometimes prove slower */ 
+ 
+MEM_STATIC U16 MEM_read16(const void* memPtr) 
+{ 
+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC U32 MEM_read32(const void* memPtr) 
+{ 
+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC U64 MEM_read64(const void* memPtr) 
+{ 
+    U64 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC size_t MEM_readST(const void* memPtr) 
+{ 
+    size_t val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+#endif /* MEM_FORCE_MEMORY_ACCESS */ 
+ 
 MEM_STATIC U32 MEM_swap32(U32 in)
 {
 #if defined(_MSC_VER)     /* Visual Studio */
@@ -238,27 +238,27 @@ MEM_STATIC size_t MEM_swapST(size_t in)
 
 /*=== Little endian r/w ===*/
 
-MEM_STATIC U16 MEM_readLE16(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read16(memPtr);
-    else {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U16)(p[0] + (p[1]<<8));
-    }
-}
-
-MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
-{
-    if (MEM_isLittleEndian()) {
-        MEM_write16(memPtr, val);
-    } else {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE)val;
-        p[1] = (BYTE)(val>>8);
-    }
-}
-
+MEM_STATIC U16 MEM_readLE16(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read16(memPtr); 
+    else { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U16)(p[0] + (p[1]<<8)); 
+    } 
+} 
+ 
+MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val) 
+{ 
+    if (MEM_isLittleEndian()) { 
+        MEM_write16(memPtr, val); 
+    } else { 
+        BYTE* p = (BYTE*)memPtr; 
+        p[0] = (BYTE)val; 
+        p[1] = (BYTE)(val>>8); 
+    } 
+} 
+ 
 MEM_STATIC U32 MEM_readLE24(const void* memPtr)
 {
     return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);
@@ -270,54 +270,54 @@ MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val)
     ((BYTE*)memPtr)[2] = (BYTE)(val>>16);
 }
 
-MEM_STATIC U32 MEM_readLE32(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read32(memPtr);
+MEM_STATIC U32 MEM_readLE32(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read32(memPtr); 
     else
         return MEM_swap32(MEM_read32(memPtr));
-}
-
-MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)
-{
+} 
+ 
+MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32) 
+{ 
     if (MEM_isLittleEndian())
-        MEM_write32(memPtr, val32);
+        MEM_write32(memPtr, val32); 
     else
         MEM_write32(memPtr, MEM_swap32(val32));
-}
-
-MEM_STATIC U64 MEM_readLE64(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read64(memPtr);
+} 
+ 
+MEM_STATIC U64 MEM_readLE64(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read64(memPtr); 
     else
         return MEM_swap64(MEM_read64(memPtr));
-}
-
-MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)
-{
+} 
+ 
+MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64) 
+{ 
     if (MEM_isLittleEndian())
-        MEM_write64(memPtr, val64);
+        MEM_write64(memPtr, val64); 
     else
         MEM_write64(memPtr, MEM_swap64(val64));
-}
-
-MEM_STATIC size_t MEM_readLEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readLE32(memPtr);
-    else
-        return (size_t)MEM_readLE64(memPtr);
-}
-
-MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val)
-{
-    if (MEM_32bits())
-        MEM_writeLE32(memPtr, (U32)val);
-    else
-        MEM_writeLE64(memPtr, (U64)val);
-}
-
+} 
+ 
+MEM_STATIC size_t MEM_readLEST(const void* memPtr) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_readLE32(memPtr); 
+    else 
+        return (size_t)MEM_readLE64(memPtr); 
+} 
+ 
+MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val) 
+{ 
+    if (MEM_32bits()) 
+        MEM_writeLE32(memPtr, (U32)val); 
+    else 
+        MEM_writeLE64(memPtr, (U64)val); 
+} 
+ 
 /*=== Big endian r/w ===*/
 
 MEM_STATIC U32 MEM_readBE32(const void* memPtr)
@@ -370,21 +370,21 @@ MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val)
 
 
 /* function safe only for comparisons */
-MEM_STATIC U32 MEM_readMINMATCH(const void* memPtr, U32 length)
-{
-    switch (length)
-    {
-    default :
-    case 4 : return MEM_read32(memPtr);
-    case 3 : if (MEM_isLittleEndian())
-                return MEM_read32(memPtr)<<8;
-             else
-                return MEM_read32(memPtr)>>8;
-    }
-}
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* MEM_H_MODULE */
+MEM_STATIC U32 MEM_readMINMATCH(const void* memPtr, U32 length) 
+{ 
+    switch (length) 
+    { 
+    default : 
+    case 4 : return MEM_read32(memPtr); 
+    case 3 : if (MEM_isLittleEndian()) 
+                return MEM_read32(memPtr)<<8; 
+             else 
+                return MEM_read32(memPtr)>>8; 
+    } 
+} 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* MEM_H_MODULE */ 
diff --git a/contrib/libs/zstd06/common/zbuff.h b/contrib/libs/zstd06/common/zbuff.h
index 54c40b47ca..03de2ad268 100644
--- a/contrib/libs/zstd06/common/zbuff.h
+++ b/contrib/libs/zstd06/common/zbuff.h
@@ -1,168 +1,168 @@
 #include <contrib/libs/zstd06/renames.h>
-/*
-    Buffered version 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/
-*/
-#ifndef ZSTD_BUFFERED_H
-#define ZSTD_BUFFERED_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* *************************************
-*  Dependencies
-***************************************/
-#include <stddef.h>   /* size_t */
-
-
-/* ***************************************************************
-*  Compiler specifics
-*****************************************************************/
-/*!
-*  ZSTD_DLL_EXPORT :
-*  Enable exporting of functions when building a Windows DLL
-*/
-#if defined(_WIN32) && defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
-#  define ZSTDLIB_API __declspec(dllexport)
-#else
-#  define ZSTDLIB_API
-#endif
-
-
-/* *************************************
-*  Streaming functions
-***************************************/
-typedef struct ZBUFF_CCtx_s ZBUFF_CCtx;
-ZSTDLIB_API ZBUFF_CCtx* ZBUFF_createCCtx(void);
-ZSTDLIB_API size_t      ZBUFF_freeCCtx(ZBUFF_CCtx* cctx);
-
-ZSTDLIB_API size_t ZBUFF_compressInit(ZBUFF_CCtx* cctx, int compressionLevel);
-ZSTDLIB_API size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);
-
-ZSTDLIB_API size_t ZBUFF_compressContinue(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr, const void* src, size_t* srcSizePtr);
-ZSTDLIB_API size_t ZBUFF_compressFlush(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr);
-ZSTDLIB_API size_t ZBUFF_compressEnd(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr);
-
-/*-*************************************************
-*  Streaming compression - howto
-*
-*  A ZBUFF_CCtx object is required to track streaming operation.
-*  Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources.
-*  ZBUFF_CCtx objects can be reused multiple times.
-*
-*  Start by initializing ZBUF_CCtx.
-*  Use ZBUFF_compressInit() to start a new compression operation.
-*  Use ZBUFF_compressInitDictionary() for a compression which requires a dictionary.
-*
-*  Use ZBUFF_compressContinue() repetitively to consume input stream.
-*  *srcSizePtr and *dstCapacityPtr can be any size.
-*  The function will report how many bytes were read or written within *srcSizePtr and *dstCapacityPtr.
-*  Note that it may not consume the entire input, in which case it's up to the caller to present again remaining data.
-*  The content of `dst` will be overwritten (up to *dstCapacityPtr) at each call, so save its content if it matters or change @dst .
-*  @return : a hint to preferred nb of bytes to use as input for next function call (it's just a hint, to improve latency)
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  At any moment, it's possible to flush whatever data remains within buffer, using ZBUFF_compressFlush().
-*  The nb of bytes written into `dst` will be reported into *dstCapacityPtr.
-*  Note that the function cannot output more than *dstCapacityPtr,
-*  therefore, some content might still be left into internal buffer if *dstCapacityPtr is too small.
-*  @return : nb of bytes still present into internal buffer (0 if it's empty)
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  ZBUFF_compressEnd() instructs to finish a frame.
-*  It will perform a flush and write frame epilogue.
-*  The epilogue is required for decoders to consider a frame completed.
-*  Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small.
-*  In which case, call again ZBUFF_compressFlush() to complete the flush.
-*  @return : nb of bytes still present into internal buffer (0 if it's empty)
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  Hint : recommended buffer sizes (not compulsory) : ZBUFF_recommendedCInSize / ZBUFF_recommendedCOutSize
-*  input : ZBUFF_recommendedCInSize==128 KB block size is the internal unit, it improves latency to use this value (skipped buffering).
-*  output : ZBUFF_recommendedCOutSize==ZSTD_compressBound(128 KB) + 3 + 3 : ensures it's always possible to write/flush/end a full block. Skip some buffering.
-*  By using both, it ensures that input will be entirely consumed, and output will always contain the result, reducing intermediate buffering.
-* **************************************************/
-
-
-typedef struct ZBUFF_DCtx_s ZBUFF_DCtx;
-ZSTDLIB_API ZBUFF_DCtx* ZBUFF_createDCtx(void);
-ZSTDLIB_API size_t      ZBUFF_freeDCtx(ZBUFF_DCtx* dctx);
-
-ZSTDLIB_API size_t ZBUFF_decompressInit(ZBUFF_DCtx* dctx);
-ZSTDLIB_API size_t ZBUFF_decompressInitDictionary(ZBUFF_DCtx* dctx, const void* dict, size_t dictSize);
-
-ZSTDLIB_API size_t ZBUFF_decompressContinue(ZBUFF_DCtx* dctx,
-                                            void* dst, size_t* dstCapacityPtr,
-                                      const void* src, size_t* srcSizePtr);
-
-/*-***************************************************************************
-*  Streaming decompression howto
-*
-*  A ZBUFF_DCtx object is required to track streaming operations.
-*  Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources.
-*  Use ZBUFF_decompressInit() to start a new decompression operation,
-*   or ZBUFF_decompressInitDictionary() if decompression requires a dictionary.
-*  Note that ZBUFF_DCtx objects can be re-init multiple times.
-*
-*  Use ZBUFF_decompressContinue() repetitively to consume your input.
-*  *srcSizePtr and *dstCapacityPtr can be any size.
-*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.
-*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
-*  The content of `dst` will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change `dst`.
-*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency),
-*            or 0 when a frame is completely decoded,
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  Hint : recommended buffer sizes (not compulsory) : ZBUFF_recommendedDInSize() and ZBUFF_recommendedDOutSize()
-*  output : ZBUFF_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
-*  input  : ZBUFF_recommendedDInSize == 128KB + 3;
-*           just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
-* *******************************************************************************/
-
-
-/* *************************************
-*  Tool functions
-***************************************/
-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.
+/* 
+    Buffered version 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/ 
+*/ 
+#ifndef ZSTD_BUFFERED_H 
+#define ZSTD_BUFFERED_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/* ************************************* 
+*  Dependencies 
+***************************************/ 
+#include <stddef.h>   /* size_t */ 
+ 
+ 
+/* *************************************************************** 
+*  Compiler specifics 
+*****************************************************************/ 
+/*! 
+*  ZSTD_DLL_EXPORT : 
+*  Enable exporting of functions when building a Windows DLL 
+*/ 
+#if defined(_WIN32) && defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1) 
+#  define ZSTDLIB_API __declspec(dllexport) 
+#else 
+#  define ZSTDLIB_API 
+#endif 
+ 
+ 
+/* ************************************* 
+*  Streaming functions 
+***************************************/ 
+typedef struct ZBUFF_CCtx_s ZBUFF_CCtx; 
+ZSTDLIB_API ZBUFF_CCtx* ZBUFF_createCCtx(void); 
+ZSTDLIB_API size_t      ZBUFF_freeCCtx(ZBUFF_CCtx* cctx); 
+ 
+ZSTDLIB_API size_t ZBUFF_compressInit(ZBUFF_CCtx* cctx, int compressionLevel); 
+ZSTDLIB_API size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel); 
+ 
+ZSTDLIB_API size_t ZBUFF_compressContinue(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr, const void* src, size_t* srcSizePtr); 
+ZSTDLIB_API size_t ZBUFF_compressFlush(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr); 
+ZSTDLIB_API size_t ZBUFF_compressEnd(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr); 
+ 
+/*-************************************************* 
+*  Streaming compression - howto 
+* 
+*  A ZBUFF_CCtx object is required to track streaming operation. 
+*  Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources. 
+*  ZBUFF_CCtx objects can be reused multiple times. 
+* 
+*  Start by initializing ZBUF_CCtx. 
+*  Use ZBUFF_compressInit() to start a new compression operation. 
+*  Use ZBUFF_compressInitDictionary() for a compression which requires a dictionary. 
+* 
+*  Use ZBUFF_compressContinue() repetitively to consume input stream. 
+*  *srcSizePtr and *dstCapacityPtr can be any size. 
+*  The function will report how many bytes were read or written within *srcSizePtr and *dstCapacityPtr. 
+*  Note that it may not consume the entire input, in which case it's up to the caller to present again remaining data. 
+*  The content of `dst` will be overwritten (up to *dstCapacityPtr) at each call, so save its content if it matters or change @dst . 
+*  @return : a hint to preferred nb of bytes to use as input for next function call (it's just a hint, to improve latency) 
+*            or an error code, which can be tested using ZBUFF_isError(). 
+* 
+*  At any moment, it's possible to flush whatever data remains within buffer, using ZBUFF_compressFlush(). 
+*  The nb of bytes written into `dst` will be reported into *dstCapacityPtr. 
+*  Note that the function cannot output more than *dstCapacityPtr, 
+*  therefore, some content might still be left into internal buffer if *dstCapacityPtr is too small. 
+*  @return : nb of bytes still present into internal buffer (0 if it's empty) 
+*            or an error code, which can be tested using ZBUFF_isError(). 
+* 
+*  ZBUFF_compressEnd() instructs to finish a frame. 
+*  It will perform a flush and write frame epilogue. 
+*  The epilogue is required for decoders to consider a frame completed. 
+*  Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small. 
+*  In which case, call again ZBUFF_compressFlush() to complete the flush. 
+*  @return : nb of bytes still present into internal buffer (0 if it's empty) 
+*            or an error code, which can be tested using ZBUFF_isError(). 
+* 
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFF_recommendedCInSize / ZBUFF_recommendedCOutSize 
+*  input : ZBUFF_recommendedCInSize==128 KB block size is the internal unit, it improves latency to use this value (skipped buffering). 
+*  output : ZBUFF_recommendedCOutSize==ZSTD_compressBound(128 KB) + 3 + 3 : ensures it's always possible to write/flush/end a full block. Skip some buffering. 
+*  By using both, it ensures that input will be entirely consumed, and output will always contain the result, reducing intermediate buffering. 
+* **************************************************/ 
+ 
+ 
+typedef struct ZBUFF_DCtx_s ZBUFF_DCtx; 
+ZSTDLIB_API ZBUFF_DCtx* ZBUFF_createDCtx(void); 
+ZSTDLIB_API size_t      ZBUFF_freeDCtx(ZBUFF_DCtx* dctx); 
+ 
+ZSTDLIB_API size_t ZBUFF_decompressInit(ZBUFF_DCtx* dctx); 
+ZSTDLIB_API size_t ZBUFF_decompressInitDictionary(ZBUFF_DCtx* dctx, const void* dict, size_t dictSize); 
+ 
+ZSTDLIB_API size_t ZBUFF_decompressContinue(ZBUFF_DCtx* dctx, 
+                                            void* dst, size_t* dstCapacityPtr, 
+                                      const void* src, size_t* srcSizePtr); 
+ 
+/*-*************************************************************************** 
+*  Streaming decompression howto 
+* 
+*  A ZBUFF_DCtx object is required to track streaming operations. 
+*  Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources. 
+*  Use ZBUFF_decompressInit() to start a new decompression operation, 
+*   or ZBUFF_decompressInitDictionary() if decompression requires a dictionary. 
+*  Note that ZBUFF_DCtx objects can be re-init multiple times. 
+* 
+*  Use ZBUFF_decompressContinue() repetitively to consume your input. 
+*  *srcSizePtr and *dstCapacityPtr can be any size. 
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr. 
+*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again. 
+*  The content of `dst` will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change `dst`. 
+*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency), 
+*            or 0 when a frame is completely decoded, 
+*            or an error code, which can be tested using ZBUFF_isError(). 
+* 
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFF_recommendedDInSize() and ZBUFF_recommendedDOutSize() 
+*  output : ZBUFF_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded. 
+*  input  : ZBUFF_recommendedDInSize == 128KB + 3; 
+*           just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 . 
+* *******************************************************************************/ 
+ 
+ 
+/* ************************************* 
+*  Tool functions 
+***************************************/ 
+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 */
-ZSTDLIB_API size_t ZBUFF_recommendedCInSize(void);
-ZSTDLIB_API size_t ZBUFF_recommendedCOutSize(void);
-ZSTDLIB_API size_t ZBUFF_recommendedDInSize(void);
-ZSTDLIB_API size_t ZBUFF_recommendedDOutSize(void);
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* ZSTD_BUFFERED_H */
+ZSTDLIB_API size_t ZBUFF_recommendedCInSize(void); 
+ZSTDLIB_API size_t ZBUFF_recommendedCOutSize(void); 
+ZSTDLIB_API size_t ZBUFF_recommendedDInSize(void); 
+ZSTDLIB_API size_t ZBUFF_recommendedDOutSize(void); 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* ZSTD_BUFFERED_H */ 
diff --git a/contrib/libs/zstd06/common/zbuff_static.h b/contrib/libs/zstd06/common/zbuff_static.h
index e06404f646..7aa81642f6 100644
--- a/contrib/libs/zstd06/common/zbuff_static.h
+++ b/contrib/libs/zstd06/common/zbuff_static.h
@@ -1,72 +1,72 @@
 #include <contrib/libs/zstd06/renames.h>
-/*
-    zstd - buffered version of compression library
-    experimental complementary API, for static linking only
-    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
-*/
-#ifndef ZSTD_BUFFERED_STATIC_H
-#define ZSTD_BUFFERED_STATIC_H
-
-/* The objects defined into this file should be considered experimental.
- * They are not labelled stable, as their prototype may change in the future.
- * You can use them for tests, provide feedback, or if you can endure risk of future changes.
- */
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* *************************************
-*  Includes
-***************************************/
-#include "zstd_static.h"     /* ZSTD_parameters */
-#include "zbuff.h"
+/* 
+    zstd - buffered version of compression library 
+    experimental complementary API, for static linking only 
+    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 
+*/ 
+#ifndef ZSTD_BUFFERED_STATIC_H 
+#define ZSTD_BUFFERED_STATIC_H 
+ 
+/* The objects defined into this file should be considered experimental. 
+ * They are not labelled stable, as their prototype may change in the future. 
+ * You can use them for tests, provide feedback, or if you can endure risk of future changes. 
+ */ 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/* ************************************* 
+*  Includes 
+***************************************/ 
+#include "zstd_static.h"     /* ZSTD_parameters */ 
+#include "zbuff.h" 
 #include "zstd_internal.h"  /* MIN  */
-
-
-/* *************************************
-*  Advanced Streaming functions
-***************************************/
-ZSTDLIB_API size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* cctx,
-                                               const void* dict, size_t dictSize,
-                                               ZSTD_parameters params, U64 pledgedSrcSize);
-
+ 
+ 
+/* ************************************* 
+*  Advanced Streaming functions 
+***************************************/ 
+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;
 }
+ 
 
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* ZSTD_BUFFERED_STATIC_H */
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* ZSTD_BUFFERED_STATIC_H */ 
diff --git a/contrib/libs/zstd06/common/zstd.h b/contrib/libs/zstd06/common/zstd.h
index 3574a82ec0..49ad80a8a8 100644
--- a/contrib/libs/zstd06/common/zstd.h
+++ b/contrib/libs/zstd06/common/zstd.h
@@ -1,65 +1,65 @@
 #include <contrib/libs/zstd06/renames.h>
-/*
-    zstd - standard compression library
-    Header File
-    Copyright (C) 2014-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 source repository : https://github.com/Cyan4973/zstd
-*/
-#ifndef ZSTD_H
-#define ZSTD_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include <stddef.h>   /* size_t */
-
-
-/*-***************************************************************
-*  Export parameters
-*****************************************************************/
-/*!
-*  ZSTD_DLL_EXPORT :
-*  Enable exporting of functions when building a Windows DLL
-*/
-#if defined(_WIN32) && defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1)
-#  define ZSTDLIB_API __declspec(dllexport)
-#else
-#  define ZSTDLIB_API
-#endif
-
-
-/* *************************************
-*  Version
-***************************************/
+/* 
+    zstd - standard compression library 
+    Header File 
+    Copyright (C) 2014-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 source repository : https://github.com/Cyan4973/zstd 
+*/ 
+#ifndef ZSTD_H 
+#define ZSTD_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/*-************************************* 
+*  Dependencies 
+***************************************/ 
+#include <stddef.h>   /* size_t */ 
+ 
+ 
+/*-*************************************************************** 
+*  Export parameters 
+*****************************************************************/ 
+/*! 
+*  ZSTD_DLL_EXPORT : 
+*  Enable exporting of functions when building a Windows DLL 
+*/ 
+#if defined(_WIN32) && defined(ZSTD_DLL_EXPORT) && (ZSTD_DLL_EXPORT==1) 
+#  define ZSTDLIB_API __declspec(dllexport) 
+#else 
+#  define ZSTDLIB_API 
+#endif 
+ 
+ 
+/* ************************************* 
+*  Version 
+***************************************/ 
 #define ZSTD_VERSION_MAJOR    0
 #define ZSTD_VERSION_MINOR    6
 #define ZSTD_VERSION_RELEASE  2
@@ -69,88 +69,88 @@ extern "C" {
 #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);
-
-
-/* *************************************
-*  Simple functions
-***************************************/
-/*! ZSTD_compress() :
-    Compresses `srcSize` bytes from buffer `src` into buffer `dst` of size `dstCapacity`.
-    Destination buffer must be already allocated.
-    Compression runs faster if `dstCapacity` >=  `ZSTD_compressBound(srcSize)`.
-    @return : the number of bytes written into `dst`,
-              or an error code if it fails (which can be tested using ZSTD_isError()) */
-ZSTDLIB_API size_t ZSTD_compress(   void* dst, size_t dstCapacity,
-                              const void* src, size_t srcSize,
-                                     int  compressionLevel);
-
-/*! ZSTD_decompress() :
-    `compressedSize` : is the _exact_ size of the compressed blob, otherwise decompression will fail.
-    `dstCapacity` must be large enough, equal or larger than originalSize.
-    @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),
-              or an errorCode if it fails (which can be tested using ZSTD_isError()) */
-ZSTDLIB_API size_t ZSTD_decompress( void* dst, size_t dstCapacity,
-                              const void* src, size_t compressedSize);
-
-
-/* *************************************
-*  Helper functions
-***************************************/
-ZSTDLIB_API size_t      ZSTD_compressBound(size_t srcSize); /*!< maximum compressed size (worst case scenario) */
-
-/* Error Management */
-ZSTDLIB_API unsigned    ZSTD_isError(size_t code);          /*!< tells if a `size_t` function result is an error code */
-ZSTDLIB_API const char* ZSTD_getErrorName(size_t code);     /*!< provides readable string for an error code */
-
-
-/* *************************************
-*  Explicit memory management
-***************************************/
-/** Compression context */
-typedef struct ZSTD_CCtx_s ZSTD_CCtx;                       /*< incomplete type */
-ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx(void);
-ZSTDLIB_API size_t     ZSTD_freeCCtx(ZSTD_CCtx* cctx);      /*!< @return : errorCode */
-
-/** ZSTD_compressCCtx() :
-    Same as ZSTD_compress(), but requires an already allocated ZSTD_CCtx (see ZSTD_createCCtx()) */
-ZSTDLIB_API size_t ZSTD_compressCCtx(ZSTD_CCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, int compressionLevel);
-
-/** Decompression context */
-typedef struct ZSTD_DCtx_s ZSTD_DCtx;
-ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx(void);
-ZSTDLIB_API size_t     ZSTD_freeDCtx(ZSTD_DCtx* dctx);      /*!< @return : errorCode */
-
-/** ZSTD_decompressDCtx() :
-*   Same as ZSTD_decompress(), but requires an already allocated ZSTD_DCtx (see ZSTD_createDCtx()) */
-ZSTDLIB_API size_t ZSTD_decompressDCtx(ZSTD_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-
-/*-***********************
-*  Dictionary API
-*************************/
-/*! ZSTD_compress_usingDict() :
-*   Compression using a pre-defined Dictionary content (see dictBuilder).
-*   Note : dict can be NULL, in which case, it's equivalent to ZSTD_compressCCtx() */
-ZSTDLIB_API size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx,
-                                           void* dst, size_t dstCapacity,
-                                     const void* src, size_t srcSize,
-                                     const void* dict,size_t dictSize,
-                                           int compressionLevel);
-
-/*! ZSTD_decompress_usingDict() :
-*   Decompression using a pre-defined Dictionary content (see dictBuilder).
-*   Dictionary must be identical to the one used during compression, otherwise regenerated data will be corrupted.
-*   Note : dict can be NULL, in which case, it's equivalent to ZSTD_decompressDCtx() */
-ZSTDLIB_API size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
-                                             void* dst, size_t dstCapacity,
-                                       const void* src, size_t srcSize,
-                                       const void* dict,size_t dictSize);
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* ZSTD_H */
+#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE) 
+ZSTDLIB_API unsigned ZSTD_versionNumber (void); 
+ 
+ 
+/* ************************************* 
+*  Simple functions 
+***************************************/ 
+/*! ZSTD_compress() : 
+    Compresses `srcSize` bytes from buffer `src` into buffer `dst` of size `dstCapacity`. 
+    Destination buffer must be already allocated. 
+    Compression runs faster if `dstCapacity` >=  `ZSTD_compressBound(srcSize)`. 
+    @return : the number of bytes written into `dst`, 
+              or an error code if it fails (which can be tested using ZSTD_isError()) */ 
+ZSTDLIB_API size_t ZSTD_compress(   void* dst, size_t dstCapacity, 
+                              const void* src, size_t srcSize, 
+                                     int  compressionLevel); 
+ 
+/*! ZSTD_decompress() : 
+    `compressedSize` : is the _exact_ size of the compressed blob, otherwise decompression will fail. 
+    `dstCapacity` must be large enough, equal or larger than originalSize. 
+    @return : the number of bytes decompressed into `dst` (<= `dstCapacity`), 
+              or an errorCode if it fails (which can be tested using ZSTD_isError()) */ 
+ZSTDLIB_API size_t ZSTD_decompress( void* dst, size_t dstCapacity, 
+                              const void* src, size_t compressedSize); 
+ 
+ 
+/* ************************************* 
+*  Helper functions 
+***************************************/ 
+ZSTDLIB_API size_t      ZSTD_compressBound(size_t srcSize); /*!< maximum compressed size (worst case scenario) */ 
+ 
+/* Error Management */ 
+ZSTDLIB_API unsigned    ZSTD_isError(size_t code);          /*!< tells if a `size_t` function result is an error code */ 
+ZSTDLIB_API const char* ZSTD_getErrorName(size_t code);     /*!< provides readable string for an error code */ 
+ 
+ 
+/* ************************************* 
+*  Explicit memory management 
+***************************************/ 
+/** Compression context */ 
+typedef struct ZSTD_CCtx_s ZSTD_CCtx;                       /*< incomplete type */ 
+ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx(void); 
+ZSTDLIB_API size_t     ZSTD_freeCCtx(ZSTD_CCtx* cctx);      /*!< @return : errorCode */ 
+ 
+/** ZSTD_compressCCtx() : 
+    Same as ZSTD_compress(), but requires an already allocated ZSTD_CCtx (see ZSTD_createCCtx()) */ 
+ZSTDLIB_API size_t ZSTD_compressCCtx(ZSTD_CCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, int compressionLevel); 
+ 
+/** Decompression context */ 
+typedef struct ZSTD_DCtx_s ZSTD_DCtx; 
+ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx(void); 
+ZSTDLIB_API size_t     ZSTD_freeDCtx(ZSTD_DCtx* dctx);      /*!< @return : errorCode */ 
+ 
+/** ZSTD_decompressDCtx() : 
+*   Same as ZSTD_decompress(), but requires an already allocated ZSTD_DCtx (see ZSTD_createDCtx()) */ 
+ZSTDLIB_API size_t ZSTD_decompressDCtx(ZSTD_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); 
+ 
+ 
+/*-*********************** 
+*  Dictionary API 
+*************************/ 
+/*! ZSTD_compress_usingDict() : 
+*   Compression using a pre-defined Dictionary content (see dictBuilder). 
+*   Note : dict can be NULL, in which case, it's equivalent to ZSTD_compressCCtx() */ 
+ZSTDLIB_API size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx, 
+                                           void* dst, size_t dstCapacity, 
+                                     const void* src, size_t srcSize, 
+                                     const void* dict,size_t dictSize, 
+                                           int compressionLevel); 
+ 
+/*! ZSTD_decompress_usingDict() : 
+*   Decompression using a pre-defined Dictionary content (see dictBuilder). 
+*   Dictionary must be identical to the one used during compression, otherwise regenerated data will be corrupted. 
+*   Note : dict can be NULL, in which case, it's equivalent to ZSTD_decompressDCtx() */ 
+ZSTDLIB_API size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx, 
+                                             void* dst, size_t dstCapacity, 
+                                       const void* src, size_t srcSize, 
+                                       const void* dict,size_t dictSize); 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* ZSTD_H */ 
diff --git a/contrib/libs/zstd06/common/zstd_internal.h b/contrib/libs/zstd06/common/zstd_internal.h
index 2ce2b18cf1..367c1d0335 100644
--- a/contrib/libs/zstd06/common/zstd_internal.h
+++ b/contrib/libs/zstd06/common/zstd_internal.h
@@ -1,256 +1,256 @@
 #include <contrib/libs/zstd06/renames.h>
-/*
-    zstd_internal - common functions to include
-    Header File for include
-    Copyright (C) 2014-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 : https://www.zstd.net
-*/
-#ifndef ZSTD_CCOMMON_H_MODULE
-#define ZSTD_CCOMMON_H_MODULE
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include "mem.h"
-#include "error_private.h"
-#include "zstd_static.h"
-
-
-/*-*************************************
-*  Common macros
-***************************************/
-#define MIN(a,b) ((a)<(b) ? (a) : (b))
-#define MAX(a,b) ((a)>(b) ? (a) : (b))
-
-
-/*-*************************************
-*  Common constants
-***************************************/
-#define ZSTD_OPT_DEBUG 0     // 3 = compression stats;  5 = check encoded sequences;  9 = full logs
-#include <stdio.h>
-#if defined(ZSTD_OPT_DEBUG) && ZSTD_OPT_DEBUG>=9
-    #define ZSTD_LOG_PARSER(...) printf(__VA_ARGS__)
-    #define ZSTD_LOG_ENCODE(...) printf(__VA_ARGS__)
-    #define ZSTD_LOG_BLOCK(...) printf(__VA_ARGS__)
-#else
-    #define ZSTD_LOG_PARSER(...)
-    #define ZSTD_LOG_ENCODE(...)
-    #define ZSTD_LOG_BLOCK(...)
-#endif
-
-#define ZSTD_OPT_NUM    (1<<12)
-#define ZSTD_DICT_MAGIC  0xEC30A436
-
-#define ZSTD_REP_NUM    3
-#define ZSTD_REP_INIT   ZSTD_REP_NUM
-#define ZSTD_REP_MOVE   (ZSTD_REP_NUM-1)
-
-#define KB *(1 <<10)
-#define MB *(1 <<20)
-#define GB *(1U<<30)
-
-#define BIT7 128
-#define BIT6  64
-#define BIT5  32
-#define BIT4  16
-#define BIT1   2
-#define BIT0   1
-
-#define ZSTD_WINDOWLOG_ABSOLUTEMIN 12
-static const size_t ZSTD_fcs_fieldSize[4] = { 0, 1, 2, 8 };
-
-#define ZSTD_BLOCKHEADERSIZE 3   /* because C standard does not allow a static const value to be defined using another static const value .... :( */
-static const size_t ZSTD_blockHeaderSize = ZSTD_BLOCKHEADERSIZE;
-typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;
-
-#define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */
-#define MIN_CBLOCK_SIZE (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */)   /* for a non-null block */
-
-#define HufLog 12
-
-#define IS_HUF 0
-#define IS_PCH 1
-#define IS_RAW 2
-#define IS_RLE 3
-
-#define LONGNBSEQ 0x7F00
-
-#define MINMATCH 3
-#define EQUAL_READ32 4
-#define REPCODE_STARTVALUE 1
-
-#define Litbits  8
-#define MaxLit ((1<<Litbits) - 1)
-#define MaxML  52
-#define MaxLL  35
-#define MaxOff 28
-#define MaxSeq MAX(MaxLL, MaxML)   /* Assumption : MaxOff < MaxLL,MaxML */
-#define MLFSELog    9
-#define LLFSELog    9
-#define OffFSELog   8
-
-#define FSE_ENCODING_RAW     0
-#define FSE_ENCODING_RLE     1
-#define FSE_ENCODING_STATIC  2
-#define FSE_ENCODING_DYNAMIC 3
-
-static const U32 LL_bits[MaxLL+1] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                      1, 1, 1, 1, 2, 2, 3, 3, 4, 6, 7, 8, 9,10,11,12,
-                                     13,14,15,16 };
-static const S16 LL_defaultNorm[MaxLL+1] = { 4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1,
-                                             2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 1, 1, 1, 1,
-                                            -1,-1,-1,-1 };
-static const U32 LL_defaultNormLog = 6;
-
-static const U32 ML_bits[MaxML+1] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                      1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 7, 8, 9,10,11,
-                                     12,13,14,15,16 };
-static const S16 ML_defaultNorm[MaxML+1] = { 1, 4, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
-                                             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-                                             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,-1,-1,
-                                            -1,-1,-1,-1,-1 };
-static const U32 ML_defaultNormLog = 6;
-
-static const S16 OF_defaultNorm[MaxOff+1] = { 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
-                                              1, 1, 1, 1, 1, 1, 1, 1,-1,-1,-1,-1,-1 };
-static const U32 OF_defaultNormLog = 5;
-
-
-/*-*******************************************
-*  Shared functions to include for inlining
-*********************************************/
-static void ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
-#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; }
-
-/*! ZSTD_wildcopy() :
-*   custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0) */
-#define WILDCOPY_OVERLENGTH 8
-MEM_STATIC void ZSTD_wildcopy(void* dst, const void* src, size_t length)
-{
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + length;
-    do
-        COPY8(op, ip)
-    while (op < oend);
-}
-
-MEM_STATIC unsigned ZSTD_highbit(U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
-    unsigned long r=0;
-    _BitScanReverse(&r, val);
-    return (unsigned)r;
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* GCC Intrinsic */
-    return 31 - __builtin_clz(val);
-#   else   /* Software version */
-    static const int DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
-    U32 v = val;
-    int r;
-    v |= v >> 1;
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-    r = DeBruijnClz[(U32)(v * 0x07C4ACDDU) >> 27];
-    return r;
-#   endif
-}
-
-
-/*-*******************************************
-*  Private interfaces
-*********************************************/
-typedef struct {
-    U32 off;
-    U32 len;
-} ZSTD_match_t;
-
-typedef struct {
-    U32 price;
-    U32 off;
-    U32 mlen;
-    U32 litlen;
-    U32 rep[ZSTD_REP_INIT];
-} ZSTD_optimal_t;
-
+/* 
+    zstd_internal - common functions to include 
+    Header File for include 
+    Copyright (C) 2014-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 : https://www.zstd.net 
+*/ 
+#ifndef ZSTD_CCOMMON_H_MODULE 
+#define ZSTD_CCOMMON_H_MODULE 
+ 
+/*-************************************* 
+*  Dependencies 
+***************************************/ 
+#include "mem.h" 
+#include "error_private.h" 
+#include "zstd_static.h" 
+ 
+ 
+/*-************************************* 
+*  Common macros 
+***************************************/ 
+#define MIN(a,b) ((a)<(b) ? (a) : (b)) 
+#define MAX(a,b) ((a)>(b) ? (a) : (b)) 
+ 
+ 
+/*-************************************* 
+*  Common constants 
+***************************************/ 
+#define ZSTD_OPT_DEBUG 0     // 3 = compression stats;  5 = check encoded sequences;  9 = full logs 
+#include <stdio.h> 
+#if defined(ZSTD_OPT_DEBUG) && ZSTD_OPT_DEBUG>=9 
+    #define ZSTD_LOG_PARSER(...) printf(__VA_ARGS__) 
+    #define ZSTD_LOG_ENCODE(...) printf(__VA_ARGS__) 
+    #define ZSTD_LOG_BLOCK(...) printf(__VA_ARGS__) 
+#else 
+    #define ZSTD_LOG_PARSER(...) 
+    #define ZSTD_LOG_ENCODE(...) 
+    #define ZSTD_LOG_BLOCK(...) 
+#endif 
+ 
+#define ZSTD_OPT_NUM    (1<<12) 
+#define ZSTD_DICT_MAGIC  0xEC30A436 
+ 
+#define ZSTD_REP_NUM    3 
+#define ZSTD_REP_INIT   ZSTD_REP_NUM 
+#define ZSTD_REP_MOVE   (ZSTD_REP_NUM-1) 
+ 
+#define KB *(1 <<10) 
+#define MB *(1 <<20) 
+#define GB *(1U<<30) 
+ 
+#define BIT7 128 
+#define BIT6  64 
+#define BIT5  32 
+#define BIT4  16 
+#define BIT1   2 
+#define BIT0   1 
+ 
+#define ZSTD_WINDOWLOG_ABSOLUTEMIN 12 
+static const size_t ZSTD_fcs_fieldSize[4] = { 0, 1, 2, 8 }; 
+ 
+#define ZSTD_BLOCKHEADERSIZE 3   /* because C standard does not allow a static const value to be defined using another static const value .... :( */ 
+static const size_t ZSTD_blockHeaderSize = ZSTD_BLOCKHEADERSIZE; 
+typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t; 
+ 
+#define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */ 
+#define MIN_CBLOCK_SIZE (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */)   /* for a non-null block */ 
+ 
+#define HufLog 12 
+ 
+#define IS_HUF 0 
+#define IS_PCH 1 
+#define IS_RAW 2 
+#define IS_RLE 3 
+ 
+#define LONGNBSEQ 0x7F00 
+ 
+#define MINMATCH 3 
+#define EQUAL_READ32 4 
+#define REPCODE_STARTVALUE 1 
+ 
+#define Litbits  8 
+#define MaxLit ((1<<Litbits) - 1) 
+#define MaxML  52 
+#define MaxLL  35 
+#define MaxOff 28 
+#define MaxSeq MAX(MaxLL, MaxML)   /* Assumption : MaxOff < MaxLL,MaxML */ 
+#define MLFSELog    9 
+#define LLFSELog    9 
+#define OffFSELog   8 
+ 
+#define FSE_ENCODING_RAW     0 
+#define FSE_ENCODING_RLE     1 
+#define FSE_ENCODING_STATIC  2 
+#define FSE_ENCODING_DYNAMIC 3 
+ 
+static const U32 LL_bits[MaxLL+1] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+                                      1, 1, 1, 1, 2, 2, 3, 3, 4, 6, 7, 8, 9,10,11,12, 
+                                     13,14,15,16 }; 
+static const S16 LL_defaultNorm[MaxLL+1] = { 4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 
+                                             2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 1, 1, 1, 1, 
+                                            -1,-1,-1,-1 }; 
+static const U32 LL_defaultNormLog = 6; 
+ 
+static const U32 ML_bits[MaxML+1] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+                                      1, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5, 7, 8, 9,10,11, 
+                                     12,13,14,15,16 }; 
+static const S16 ML_defaultNorm[MaxML+1] = { 1, 4, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 
+                                             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+                                             1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,-1,-1, 
+                                            -1,-1,-1,-1,-1 }; 
+static const U32 ML_defaultNormLog = 6; 
+ 
+static const S16 OF_defaultNorm[MaxOff+1] = { 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 
+                                              1, 1, 1, 1, 1, 1, 1, 1,-1,-1,-1,-1,-1 }; 
+static const U32 OF_defaultNormLog = 5; 
+ 
+ 
+/*-******************************************* 
+*  Shared functions to include for inlining 
+*********************************************/ 
+static void ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); } 
+#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; } 
+ 
+/*! ZSTD_wildcopy() : 
+*   custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0) */ 
+#define WILDCOPY_OVERLENGTH 8 
+MEM_STATIC void ZSTD_wildcopy(void* dst, const void* src, size_t length) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + length; 
+    do 
+        COPY8(op, ip) 
+    while (op < oend); 
+} 
+ 
+MEM_STATIC unsigned ZSTD_highbit(U32 val) 
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
+    unsigned long r=0; 
+    _BitScanReverse(&r, val); 
+    return (unsigned)r; 
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* GCC Intrinsic */ 
+    return 31 - __builtin_clz(val); 
+#   else   /* Software version */ 
+    static const int DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 }; 
+    U32 v = val; 
+    int r; 
+    v |= v >> 1; 
+    v |= v >> 2; 
+    v |= v >> 4; 
+    v |= v >> 8; 
+    v |= v >> 16; 
+    r = DeBruijnClz[(U32)(v * 0x07C4ACDDU) >> 27]; 
+    return r; 
+#   endif 
+} 
+ 
+ 
+/*-******************************************* 
+*  Private interfaces 
+*********************************************/ 
+typedef struct { 
+    U32 off; 
+    U32 len; 
+} ZSTD_match_t; 
+ 
+typedef struct { 
+    U32 price; 
+    U32 off; 
+    U32 mlen; 
+    U32 litlen; 
+    U32 rep[ZSTD_REP_INIT]; 
+} ZSTD_optimal_t; 
+ 
 //#if ZSTD_OPT_DEBUG == 3
 //    #include ".debug/zstd_stats.h"
 //#else
-    typedef struct { U32  unused; } ZSTD_stats_t;
+    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
-
-typedef struct {
-    void* buffer;
-    U32*  offsetStart;
-    U32*  offset;
-    BYTE* offCodeStart;
-    BYTE* litStart;
-    BYTE* lit;
-    U16*  litLengthStart;
-    U16*  litLength;
-    BYTE* llCodeStart;
-    U16*  matchLengthStart;
-    U16*  matchLength;
-    BYTE* mlCodeStart;
-    U32   longLengthID;   /* 0 == no longLength; 1 == Lit.longLength; 2 == Match.longLength; */
-    U32   longLengthPos;
-    /* opt */
-    ZSTD_optimal_t* priceTable;
-    ZSTD_match_t* matchTable;
-    U32* matchLengthFreq;
-    U32* litLengthFreq;
-    U32* litFreq;
-    U32* offCodeFreq;
-    U32  matchLengthSum;
-    U32  matchSum;
-    U32  litLengthSum;
-    U32  litSum;
-    U32  offCodeSum;
-    U32  log2matchLengthSum;
-    U32  log2matchSum;
-    U32  log2litLengthSum;
-    U32  log2litSum;
-    U32  log2offCodeSum;
-    U32  factor;
+ 
+typedef struct { 
+    void* buffer; 
+    U32*  offsetStart; 
+    U32*  offset; 
+    BYTE* offCodeStart; 
+    BYTE* litStart; 
+    BYTE* lit; 
+    U16*  litLengthStart; 
+    U16*  litLength; 
+    BYTE* llCodeStart; 
+    U16*  matchLengthStart; 
+    U16*  matchLength; 
+    BYTE* mlCodeStart; 
+    U32   longLengthID;   /* 0 == no longLength; 1 == Lit.longLength; 2 == Match.longLength; */ 
+    U32   longLengthPos; 
+    /* opt */ 
+    ZSTD_optimal_t* priceTable; 
+    ZSTD_match_t* matchTable; 
+    U32* matchLengthFreq; 
+    U32* litLengthFreq; 
+    U32* litFreq; 
+    U32* offCodeFreq; 
+    U32  matchLengthSum; 
+    U32  matchSum; 
+    U32  litLengthSum; 
+    U32  litSum; 
+    U32  offCodeSum; 
+    U32  log2matchLengthSum; 
+    U32  log2matchSum; 
+    U32  log2litLengthSum; 
+    U32  log2litSum; 
+    U32  log2offCodeSum; 
+    U32  factor; 
     U32  cachedPrice;
     U32  cachedLitLength;
     const BYTE* cachedLiterals;
-    ZSTD_stats_t stats;
-} seqStore_t;
-
-const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx);
-void ZSTD_seqToCodes(const seqStore_t* seqStorePtr, size_t const nbSeq);
-
-
-#endif   /* ZSTD_CCOMMON_H_MODULE */
+    ZSTD_stats_t stats; 
+} seqStore_t; 
+ 
+const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx); 
+void ZSTD_seqToCodes(const seqStore_t* seqStorePtr, size_t const nbSeq); 
+ 
+ 
+#endif   /* ZSTD_CCOMMON_H_MODULE */ 
diff --git a/contrib/libs/zstd06/common/zstd_static.h b/contrib/libs/zstd06/common/zstd_static.h
index a1dae42094..65d3bc8748 100644
--- a/contrib/libs/zstd06/common/zstd_static.h
+++ b/contrib/libs/zstd06/common/zstd_static.h
@@ -1,273 +1,273 @@
 #include <contrib/libs/zstd06/renames.h>
-/*
-    zstd - standard compression library
-    Header File for static linking only
-    Copyright (C) 2014-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
-*/
-#ifndef ZSTD_STATIC_H
-#define ZSTD_STATIC_H
-
-/* The prototypes defined within this file are considered experimental.
- * They should not be used in the context DLL as they may change in the future.
- * Prefer static linking if you need them, to control breaking version changes issues.
- */
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include "zstd.h"
-#include "mem.h"
-
-
-/*-*************************************
-*  Constants
-***************************************/
-#define ZSTD_MAGICNUMBER 0xFD2FB526   /* v0.6 */
-
-
-/*-*************************************
-*  Types
-***************************************/
-#define ZSTD_WINDOWLOG_MAX    ((U32)(MEM_32bits() ? 25 : 27))
-#define ZSTD_WINDOWLOG_MIN     18
-#define ZSTD_CHAINLOG_MAX     (ZSTD_WINDOWLOG_MAX+1)
-#define ZSTD_CHAINLOG_MIN       4
-#define ZSTD_HASHLOG_MAX       ZSTD_WINDOWLOG_MAX
-#define ZSTD_HASHLOG_MIN       12
-#define ZSTD_HASHLOG3_MAX      17
-#define ZSTD_HASHLOG3_MIN      15
-#define ZSTD_SEARCHLOG_MAX    (ZSTD_WINDOWLOG_MAX-1)
-#define ZSTD_SEARCHLOG_MIN      1
-#define ZSTD_SEARCHLENGTH_MAX   7
-#define ZSTD_SEARCHLENGTH_MIN   3
-#define ZSTD_TARGETLENGTH_MIN   4
-#define ZSTD_TARGETLENGTH_MAX 999
-
-/* from faster to stronger */
-typedef enum { ZSTD_fast, ZSTD_greedy, ZSTD_lazy, ZSTD_lazy2, ZSTD_btlazy2, ZSTD_btopt } ZSTD_strategy;
-
-typedef struct {
-    U32 windowLog;     /* largest match distance : larger == more compression, more memory needed during decompression */
-    U32 chainLog;      /* fully searched segment : larger == more compression, slower, more memory (useless for fast) */
-    U32 hashLog;       /* dispatch table : larger == faster, more memory */
-    U32 searchLog;     /* nb of searches : larger == more compression, slower */
-    U32 searchLength;  /* match length searched : larger == faster decompression, sometimes less compression */
-    U32 targetLength;  /* acceptable match size for optimal parser (only) : larger == more compression, slower */
-    ZSTD_strategy strategy;
-} ZSTD_compressionParameters;
-
-typedef struct {
-    U32 contentSizeFlag;   /* 1: content size will be in frame header (if known). */
-} ZSTD_frameParameters;
-
-typedef struct {
-    ZSTD_compressionParameters cParams;
-    ZSTD_frameParameters fParams;
-} ZSTD_parameters;
-
-
-/*-*************************************
-*  Advanced functions
-***************************************/
-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 */
+/* 
+    zstd - standard compression library 
+    Header File for static linking only 
+    Copyright (C) 2014-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 
+*/ 
+#ifndef ZSTD_STATIC_H 
+#define ZSTD_STATIC_H 
+ 
+/* The prototypes defined within this file are considered experimental. 
+ * They should not be used in the context DLL as they may change in the future. 
+ * Prefer static linking if you need them, to control breaking version changes issues. 
+ */ 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/*-************************************* 
+*  Dependencies 
+***************************************/ 
+#include "zstd.h" 
+#include "mem.h" 
+ 
+ 
+/*-************************************* 
+*  Constants 
+***************************************/ 
+#define ZSTD_MAGICNUMBER 0xFD2FB526   /* v0.6 */ 
+ 
+ 
+/*-************************************* 
+*  Types 
+***************************************/ 
+#define ZSTD_WINDOWLOG_MAX    ((U32)(MEM_32bits() ? 25 : 27)) 
+#define ZSTD_WINDOWLOG_MIN     18 
+#define ZSTD_CHAINLOG_MAX     (ZSTD_WINDOWLOG_MAX+1) 
+#define ZSTD_CHAINLOG_MIN       4 
+#define ZSTD_HASHLOG_MAX       ZSTD_WINDOWLOG_MAX 
+#define ZSTD_HASHLOG_MIN       12 
+#define ZSTD_HASHLOG3_MAX      17 
+#define ZSTD_HASHLOG3_MIN      15 
+#define ZSTD_SEARCHLOG_MAX    (ZSTD_WINDOWLOG_MAX-1) 
+#define ZSTD_SEARCHLOG_MIN      1 
+#define ZSTD_SEARCHLENGTH_MAX   7 
+#define ZSTD_SEARCHLENGTH_MIN   3 
+#define ZSTD_TARGETLENGTH_MIN   4 
+#define ZSTD_TARGETLENGTH_MAX 999 
+ 
+/* from faster to stronger */ 
+typedef enum { ZSTD_fast, ZSTD_greedy, ZSTD_lazy, ZSTD_lazy2, ZSTD_btlazy2, ZSTD_btopt } ZSTD_strategy; 
+ 
+typedef struct { 
+    U32 windowLog;     /* largest match distance : larger == more compression, more memory needed during decompression */ 
+    U32 chainLog;      /* fully searched segment : larger == more compression, slower, more memory (useless for fast) */ 
+    U32 hashLog;       /* dispatch table : larger == faster, more memory */ 
+    U32 searchLog;     /* nb of searches : larger == more compression, slower */ 
+    U32 searchLength;  /* match length searched : larger == faster decompression, sometimes less compression */ 
+    U32 targetLength;  /* acceptable match size for optimal parser (only) : larger == more compression, slower */ 
+    ZSTD_strategy strategy; 
+} ZSTD_compressionParameters; 
+ 
+typedef struct { 
+    U32 contentSizeFlag;   /* 1: content size will be in frame header (if known). */ 
+} ZSTD_frameParameters; 
+ 
+typedef struct { 
+    ZSTD_compressionParameters cParams; 
+    ZSTD_frameParameters fParams; 
+} ZSTD_parameters; 
+ 
+ 
+/*-************************************* 
+*  Advanced functions 
+***************************************/ 
+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);
-
-/*! ZSTD_checkParams() :
-*   Ensure param values remain within authorized range */
-ZSTDLIB_API size_t ZSTD_checkCParams(ZSTD_compressionParameters params);
-
-/*! ZSTD_adjustParams() :
-*   optimize params for a given `srcSize` and `dictSize`.
-*   both values are optional, select `0` if unknown. */
-ZSTDLIB_API void ZSTD_adjustCParams(ZSTD_compressionParameters* params, U64 srcSize, size_t dictSize);
-
-/*! ZSTD_compress_advanced() :
-*   Same as ZSTD_compress_usingDict(), with fine-tune control of each compression parameter */
-ZSTDLIB_API size_t ZSTD_compress_advanced (ZSTD_CCtx* ctx,
-                                           void* dst, size_t dstCapacity,
-                                     const void* src, size_t srcSize,
-                                     const void* dict,size_t dictSize,
-                                           ZSTD_parameters params);
-
-/*! ZSTD_compress_usingPreparedDCtx() :
-*   Same as ZSTD_compress_usingDict, but using a reference context `preparedCCtx`, where dictionary has been loaded.
-*   It avoids reloading the dictionary each time.
-*   `preparedCCtx` must have been properly initialized using ZSTD_compressBegin_usingDict() or ZSTD_compressBegin_advanced().
-*   Requires 2 contexts : 1 for reference (preparedCCtx) which will not be modified, and 1 to run the compression operation (cctx) */
-ZSTDLIB_API size_t ZSTD_compress_usingPreparedCCtx(
-                                           ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx,
-                                           void* dst, size_t dstCapacity,
-                                     const void* src, size_t srcSize);
-
-/*- Advanced Decompression functions -*/
-
-/*! ZSTD_decompress_usingPreparedDCtx() :
-*   Same as ZSTD_decompress_usingDict, but using a reference context `preparedDCtx`, where dictionary has been loaded.
-*   It avoids reloading the dictionary each time.
-*   `preparedDCtx` must have been properly initialized using ZSTD_decompressBegin_usingDict().
-*   Requires 2 contexts : 1 for reference (preparedDCtx), which will not be modified, and 1 to run the decompression operation (dctx) */
-ZSTDLIB_API size_t ZSTD_decompress_usingPreparedDCtx(
-                                           ZSTD_DCtx* dctx, const ZSTD_DCtx* preparedDCtx,
-                                           void* dst, size_t dstCapacity,
-                                     const void* src, size_t srcSize);
-
-
-/* **************************************
-*  Streaming functions (direct mode)
-****************************************/
-ZSTDLIB_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel);
-ZSTDLIB_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);
-ZSTDLIB_API size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, U64 pledgedSrcSize);
-ZSTDLIB_API size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx);
-
-ZSTDLIB_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-ZSTDLIB_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity);
-
-/*
-  Streaming compression, synchronous mode (bufferless)
-
-  A ZSTD_CCtx object is required to track streaming operations.
-  Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage it.
-  ZSTD_CCtx object can be re-used multiple times within successive compression operations.
-
-  Start by initializing a context.
-  Use ZSTD_compressBegin(), or ZSTD_compressBegin_usingDict() for dictionary compression,
-  or ZSTD_compressBegin_advanced(), for finer parameter control.
-  It's also possible to duplicate a reference context which has already been initialized, using ZSTD_copyCCtx()
-
-  Then, consume your input using ZSTD_compressContinue().
-  The interface is synchronous, so all input will be consumed and produce a compressed output.
-  You must ensure there is enough space in destination buffer to store compressed data under worst case scenario.
-  Worst case evaluation is provided by ZSTD_compressBound().
-
-  Finish a frame with ZSTD_compressEnd(), which will write the epilogue.
-  Without the epilogue, frames will be considered incomplete by decoder.
-
-  You can then reuse ZSTD_CCtx to compress some new frame.
-*/
-
-typedef struct { U64 frameContentSize; U32 windowLog; } ZSTD_frameParams;
-
-#define ZSTD_FRAMEHEADERSIZE_MAX 13    /* for static allocation */
-static const size_t ZSTD_frameHeaderSize_min = 5;
-static const size_t ZSTD_frameHeaderSize_max = ZSTD_FRAMEHEADERSIZE_MAX;
-ZSTDLIB_API size_t ZSTD_getFrameParams(ZSTD_frameParams* fparamsPtr, const void* src, size_t srcSize);   /**< doesn't consume input */
-
-ZSTDLIB_API size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx);
-ZSTDLIB_API size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
-ZSTDLIB_API void   ZSTD_copyDCtx(ZSTD_DCtx* dctx, const ZSTD_DCtx* preparedDCtx);
-
-ZSTDLIB_API size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx);
-ZSTDLIB_API size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-/*
-  Streaming decompression, direct mode (bufferless)
-
-  A ZSTD_DCtx object is required to track streaming operations.
-  Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it.
-  A ZSTD_DCtx object can be re-used multiple times.
-
-  First optional operation is to retrieve frame parameters, using ZSTD_getFrameParams(), which doesn't consume the input.
-  It can provide the minimum size of rolling buffer required to properly decompress data,
-  and optionally the final size of uncompressed content.
-  (Note : content size is an optional info that may not be present. 0 means : content size unknown)
-  Frame parameters are extracted from the beginning of compressed frame.
-  The amount of data to read is variable, from ZSTD_frameHeaderSize_min to ZSTD_frameHeaderSize_max (so if `srcSize` >= ZSTD_frameHeaderSize_max, it will always work)
-  If `srcSize` is too small for operation to succeed, function will return the minimum size it requires to produce a result.
-  Result : 0 when successful, it means the ZSTD_frameParams structure has been filled.
-          >0 : means there is not enough data into `src`. Provides the expected size to successfully decode header.
-           errorCode, which can be tested using ZSTD_isError()
-
-  Start decompression, with ZSTD_decompressBegin() or ZSTD_decompressBegin_usingDict().
-  Alternatively, you can copy a prepared context, using ZSTD_copyDCtx().
-
-  Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively.
-  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
-  ZSTD_decompressContinue() requires this exact amount of bytes, or it will fail.
-  ZSTD_decompressContinue() needs previous data blocks during decompression, up to (1 << windowlog).
-  They should preferably be located contiguously, prior to current block. Alternatively, a round buffer is also possible.
-
-  @result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity)
-  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
-
-  A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero.
-  Context can then be reset to start a new decompression.
-*/
-
-
-/* **************************************
-*  Block functions
-****************************************/
-/*! Block functions produce and decode raw zstd blocks, without frame metadata.
-    User will have to take in charge required information to regenerate data, such as compressed and content sizes.
-
-    A few rules to respect :
-    - Uncompressed block size must be <= ZSTD_BLOCKSIZE_MAX (128 KB)
-    - Compressing or decompressing requires a context structure
-      + Use ZSTD_createCCtx() and ZSTD_createDCtx()
-    - It is necessary to init context before starting
-      + compression : ZSTD_compressBegin()
-      + decompression : ZSTD_decompressBegin()
-      + variants _usingDict() are also allowed
-      + copyCCtx() and copyDCtx() work too
-    - When a block is considered not compressible enough, ZSTD_compressBlock() result will be zero.
-      In which case, nothing is produced into `dst`.
-      + User must test for such outcome and deal directly with uncompressed data
-      + ZSTD_decompressBlock() doesn't accept uncompressed data as input !!
-*/
-
-#define ZSTD_BLOCKSIZE_MAX (128 * 1024)   /* define, for static allocation */
+ 
+/*! ZSTD_checkParams() : 
+*   Ensure param values remain within authorized range */ 
+ZSTDLIB_API size_t ZSTD_checkCParams(ZSTD_compressionParameters params); 
+ 
+/*! ZSTD_adjustParams() : 
+*   optimize params for a given `srcSize` and `dictSize`. 
+*   both values are optional, select `0` if unknown. */ 
+ZSTDLIB_API void ZSTD_adjustCParams(ZSTD_compressionParameters* params, U64 srcSize, size_t dictSize); 
+ 
+/*! ZSTD_compress_advanced() : 
+*   Same as ZSTD_compress_usingDict(), with fine-tune control of each compression parameter */ 
+ZSTDLIB_API size_t ZSTD_compress_advanced (ZSTD_CCtx* ctx, 
+                                           void* dst, size_t dstCapacity, 
+                                     const void* src, size_t srcSize, 
+                                     const void* dict,size_t dictSize, 
+                                           ZSTD_parameters params); 
+ 
+/*! ZSTD_compress_usingPreparedDCtx() : 
+*   Same as ZSTD_compress_usingDict, but using a reference context `preparedCCtx`, where dictionary has been loaded. 
+*   It avoids reloading the dictionary each time. 
+*   `preparedCCtx` must have been properly initialized using ZSTD_compressBegin_usingDict() or ZSTD_compressBegin_advanced(). 
+*   Requires 2 contexts : 1 for reference (preparedCCtx) which will not be modified, and 1 to run the compression operation (cctx) */ 
+ZSTDLIB_API size_t ZSTD_compress_usingPreparedCCtx( 
+                                           ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, 
+                                           void* dst, size_t dstCapacity, 
+                                     const void* src, size_t srcSize); 
+ 
+/*- Advanced Decompression functions -*/ 
+ 
+/*! ZSTD_decompress_usingPreparedDCtx() : 
+*   Same as ZSTD_decompress_usingDict, but using a reference context `preparedDCtx`, where dictionary has been loaded. 
+*   It avoids reloading the dictionary each time. 
+*   `preparedDCtx` must have been properly initialized using ZSTD_decompressBegin_usingDict(). 
+*   Requires 2 contexts : 1 for reference (preparedDCtx), which will not be modified, and 1 to run the decompression operation (dctx) */ 
+ZSTDLIB_API size_t ZSTD_decompress_usingPreparedDCtx( 
+                                           ZSTD_DCtx* dctx, const ZSTD_DCtx* preparedDCtx, 
+                                           void* dst, size_t dstCapacity, 
+                                     const void* src, size_t srcSize); 
+ 
+ 
+/* ************************************** 
+*  Streaming functions (direct mode) 
+****************************************/ 
+ZSTDLIB_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel); 
+ZSTDLIB_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel); 
+ZSTDLIB_API size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, U64 pledgedSrcSize); 
+ZSTDLIB_API size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx); 
+ 
+ZSTDLIB_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); 
+ZSTDLIB_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity); 
+ 
+/* 
+  Streaming compression, synchronous mode (bufferless) 
+ 
+  A ZSTD_CCtx object is required to track streaming operations. 
+  Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage it. 
+  ZSTD_CCtx object can be re-used multiple times within successive compression operations. 
+ 
+  Start by initializing a context. 
+  Use ZSTD_compressBegin(), or ZSTD_compressBegin_usingDict() for dictionary compression, 
+  or ZSTD_compressBegin_advanced(), for finer parameter control. 
+  It's also possible to duplicate a reference context which has already been initialized, using ZSTD_copyCCtx() 
+ 
+  Then, consume your input using ZSTD_compressContinue(). 
+  The interface is synchronous, so all input will be consumed and produce a compressed output. 
+  You must ensure there is enough space in destination buffer to store compressed data under worst case scenario. 
+  Worst case evaluation is provided by ZSTD_compressBound(). 
+ 
+  Finish a frame with ZSTD_compressEnd(), which will write the epilogue. 
+  Without the epilogue, frames will be considered incomplete by decoder. 
+ 
+  You can then reuse ZSTD_CCtx to compress some new frame. 
+*/ 
+ 
+typedef struct { U64 frameContentSize; U32 windowLog; } ZSTD_frameParams; 
+ 
+#define ZSTD_FRAMEHEADERSIZE_MAX 13    /* for static allocation */ 
+static const size_t ZSTD_frameHeaderSize_min = 5; 
+static const size_t ZSTD_frameHeaderSize_max = ZSTD_FRAMEHEADERSIZE_MAX; 
+ZSTDLIB_API size_t ZSTD_getFrameParams(ZSTD_frameParams* fparamsPtr, const void* src, size_t srcSize);   /**< doesn't consume input */ 
+ 
+ZSTDLIB_API size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx); 
+ZSTDLIB_API size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize); 
+ZSTDLIB_API void   ZSTD_copyDCtx(ZSTD_DCtx* dctx, const ZSTD_DCtx* preparedDCtx); 
+ 
+ZSTDLIB_API size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx); 
+ZSTDLIB_API size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); 
+ 
+/* 
+  Streaming decompression, direct mode (bufferless) 
+ 
+  A ZSTD_DCtx object is required to track streaming operations. 
+  Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it. 
+  A ZSTD_DCtx object can be re-used multiple times. 
+ 
+  First optional operation is to retrieve frame parameters, using ZSTD_getFrameParams(), which doesn't consume the input. 
+  It can provide the minimum size of rolling buffer required to properly decompress data, 
+  and optionally the final size of uncompressed content. 
+  (Note : content size is an optional info that may not be present. 0 means : content size unknown) 
+  Frame parameters are extracted from the beginning of compressed frame. 
+  The amount of data to read is variable, from ZSTD_frameHeaderSize_min to ZSTD_frameHeaderSize_max (so if `srcSize` >= ZSTD_frameHeaderSize_max, it will always work) 
+  If `srcSize` is too small for operation to succeed, function will return the minimum size it requires to produce a result. 
+  Result : 0 when successful, it means the ZSTD_frameParams structure has been filled. 
+          >0 : means there is not enough data into `src`. Provides the expected size to successfully decode header. 
+           errorCode, which can be tested using ZSTD_isError() 
+ 
+  Start decompression, with ZSTD_decompressBegin() or ZSTD_decompressBegin_usingDict(). 
+  Alternatively, you can copy a prepared context, using ZSTD_copyDCtx(). 
+ 
+  Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively. 
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue(). 
+  ZSTD_decompressContinue() requires this exact amount of bytes, or it will fail. 
+  ZSTD_decompressContinue() needs previous data blocks during decompression, up to (1 << windowlog). 
+  They should preferably be located contiguously, prior to current block. Alternatively, a round buffer is also possible. 
+ 
+  @result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity) 
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header. 
+ 
+  A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero. 
+  Context can then be reset to start a new decompression. 
+*/ 
+ 
+ 
+/* ************************************** 
+*  Block functions 
+****************************************/ 
+/*! Block functions produce and decode raw zstd blocks, without frame metadata. 
+    User will have to take in charge required information to regenerate data, such as compressed and content sizes. 
+ 
+    A few rules to respect : 
+    - Uncompressed block size must be <= ZSTD_BLOCKSIZE_MAX (128 KB) 
+    - Compressing or decompressing requires a context structure 
+      + Use ZSTD_createCCtx() and ZSTD_createDCtx() 
+    - It is necessary to init context before starting 
+      + compression : ZSTD_compressBegin() 
+      + decompression : ZSTD_decompressBegin() 
+      + variants _usingDict() are also allowed 
+      + copyCCtx() and copyDCtx() work too 
+    - When a block is considered not compressible enough, ZSTD_compressBlock() result will be zero. 
+      In which case, nothing is produced into `dst`. 
+      + User must test for such outcome and deal directly with uncompressed data 
+      + ZSTD_decompressBlock() doesn't accept uncompressed data as input !! 
+*/ 
+ 
+#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);
-
-
-/*-*************************************
-*  Error management
-***************************************/
-#include "error_public.h"
-/*! 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" */
+ 
+ 
+/*-************************************* 
+*  Error management 
+***************************************/ 
+#include "error_public.h" 
+/*! 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);
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* ZSTD_STATIC_H */
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* ZSTD_STATIC_H */ 
diff --git a/contrib/libs/zstd06/compress/zstd_compress.c b/contrib/libs/zstd06/compress/zstd_compress.c
index 1bb75c68cc..e1a9e5a48b 100644
--- a/contrib/libs/zstd06/compress/zstd_compress.c
+++ b/contrib/libs/zstd06/compress/zstd_compress.c
@@ -1,1971 +1,1971 @@
-/*
-    ZSTD HC - High Compression Mode of Zstandard
-    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 source repository : https://www.zstd.net
-*/
-
-
-/* *******************************************************
-*  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 */
-#else
-#  ifdef __GNUC__
-#    define FORCE_INLINE static inline __attribute__((always_inline))
-#  else
-#    define FORCE_INLINE static inline
-#  endif
-#endif
-
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include <stdlib.h>   /* malloc */
-#include <string.h>   /* memset */
-#include "mem.h"
-#include "fse_static.h"
+/* 
+    ZSTD HC - High Compression Mode of Zstandard 
+    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 source repository : https://www.zstd.net 
+*/ 
+ 
+ 
+/* ******************************************************* 
+*  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 */ 
+#else 
+#  ifdef __GNUC__ 
+#    define FORCE_INLINE static inline __attribute__((always_inline)) 
+#  else 
+#    define FORCE_INLINE static inline 
+#  endif 
+#endif 
+ 
+ 
+/*-************************************* 
+*  Dependencies 
+***************************************/ 
+#include <stdlib.h>   /* malloc */ 
+#include <string.h>   /* memset */ 
+#include "mem.h" 
+#include "fse_static.h" 
 #include "huf_static.h"
-#include "zstd_internal.h"
-
-
-/*-*************************************
-*  Constants
-***************************************/
-static const U32 g_searchStrength = 8;   /* control skip over incompressible data */
-
-
-/*-*************************************
-*  Helper functions
-***************************************/
-size_t ZSTD_compressBound(size_t srcSize) { return FSE_compressBound(srcSize) + 12; }
-
-
-/*-*************************************
-*  Sequence storage
-***************************************/
-static void ZSTD_resetSeqStore(seqStore_t* ssPtr)
-{
-    ssPtr->offset = ssPtr->offsetStart;
-    ssPtr->lit = ssPtr->litStart;
-    ssPtr->litLength = ssPtr->litLengthStart;
-    ssPtr->matchLength = ssPtr->matchLengthStart;
-    ssPtr->longLengthID = 0;
-}
-
-
-/*-*************************************
-*  Context memory management
-***************************************/
-struct ZSTD_CCtx_s
-{
-    const BYTE* nextSrc;    /* next block here to continue on current prefix */
-    const BYTE* base;       /* All regular indexes relative to this position */
-    const BYTE* dictBase;   /* extDict indexes relative to this position */
-    U32   dictLimit;        /* below that point, need extDict */
-    U32   lowLimit;         /* below that point, no more data */
-    U32   nextToUpdate;     /* index from which to continue dictionary update */
-    U32   nextToUpdate3;    /* index from which to continue dictionary update */
-    U32   hashLog3;         /* dispatch table : larger == faster, more memory */
-    U32   loadedDictEnd;
-    U32   stage;            /* 0: created; 1: init,dictLoad; 2:started */
-    ZSTD_parameters params;
-    void* workSpace;
-    size_t workSpaceSize;
-    size_t blockSize;
-
-    seqStore_t seqStore;    /* sequences storage ptrs */
-    U32* hashTable;
-    U32* hashTable3;
-    U32* chainTable;
-    HUF_CElt* hufTable;
-    U32 flagStaticTables;
-    FSE_CTable offcodeCTable   [FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)];
-    FSE_CTable matchlengthCTable [FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)];
-    FSE_CTable litlengthCTable   [FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)];
-};
-
-ZSTD_CCtx* ZSTD_createCCtx(void)
-{
-    return (ZSTD_CCtx*) calloc(1, sizeof(ZSTD_CCtx));
-}
-
-size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx)
-{
-    free(cctx->workSpace);
-    free(cctx);
-    return 0;   /* reserved as a potential error code in the future */
-}
-
-const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx)   /* hidden interface */
-{
-    return &(ctx->seqStore);
-}
-
-
-#define CLAMP(val,min,max) { if (val<min) val=min; else if (val>max) val=max; }
-#define CLAMPCHECK(val,min,max) { if ((val<min) || (val>max)) return ERROR(compressionParameter_unsupported); }
-
-/** ZSTD_checkParams() :
-    ensure param values remain within authorized range.
-    @return : 0, or an error code if one value is beyond authorized range */
-size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
-{
-    CLAMPCHECK(cParams.windowLog, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX);
-    CLAMPCHECK(cParams.chainLog, ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX);
-    CLAMPCHECK(cParams.hashLog, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX);
-    CLAMPCHECK(cParams.searchLog, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX);
-    { U32 const searchLengthMin = (cParams.strategy == ZSTD_fast || cParams.strategy == ZSTD_greedy) ? ZSTD_SEARCHLENGTH_MIN+1 : ZSTD_SEARCHLENGTH_MIN;
-      U32 const searchLengthMax = (cParams.strategy == ZSTD_fast) ? ZSTD_SEARCHLENGTH_MAX : ZSTD_SEARCHLENGTH_MAX-1;
-      CLAMPCHECK(cParams.searchLength, searchLengthMin, searchLengthMax); }
-    CLAMPCHECK(cParams.targetLength, ZSTD_TARGETLENGTH_MIN, ZSTD_TARGETLENGTH_MAX);
-    if ((U32)(cParams.strategy) > (U32)ZSTD_btopt) return ERROR(compressionParameter_unsupported);
-    return 0;
-}
-
-
-static unsigned ZSTD_highbit(U32 val);
-
-/** ZSTD_checkCParams_advanced() :
-    temporary work-around, while the compressor compatibility remains limited regarding windowLog < 18 */
-size_t ZSTD_checkCParams_advanced(ZSTD_compressionParameters cParams, U64 srcSize)
-{
-    if (srcSize > (1ULL << ZSTD_WINDOWLOG_MIN)) return ZSTD_checkCParams(cParams);
-    if (cParams.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN) return ERROR(compressionParameter_unsupported);
-    if (srcSize <= (1ULL << cParams.windowLog)) cParams.windowLog = ZSTD_WINDOWLOG_MIN; /* fake value - temporary work around */
-    if (srcSize <= (1ULL << cParams.chainLog)) cParams.chainLog = ZSTD_CHAINLOG_MIN;    /* fake value - temporary work around */
-    if ((srcSize <= (1ULL << cParams.hashLog)) && ((U32)cParams.strategy < (U32)ZSTD_btlazy2)) cParams.hashLog = ZSTD_HASHLOG_MIN;       /* fake value - temporary work around */
-    return ZSTD_checkCParams(cParams);
-}
-
-
-/** ZSTD_adjustParams() :
-    optimize params for q given input (`srcSize` and `dictSize`).
-    mostly downsizing to reduce memory consumption and initialization.
-    Both `srcSize` and `dictSize` are optional (use 0 if unknown),
-    but if both are 0, no optimization can be done.
-    Note : params is considered validated at this stage. Use ZSTD_checkParams() to ensure that. */
-void ZSTD_adjustCParams(ZSTD_compressionParameters* params, U64 srcSize, size_t dictSize)
-{
-    if (srcSize+dictSize == 0) return;   /* no size information available : no adjustment */
-
-    /* resize params, to use less memory when necessary */
-    {   U32 const minSrcSize = (srcSize==0) ? 500 : 0;
-        U64 const rSize = srcSize + dictSize + minSrcSize;
-        if (rSize < ((U64)1<<ZSTD_WINDOWLOG_MAX)) {
-            U32 const srcLog = ZSTD_highbit((U32)(rSize)-1) + 1;
-            if (params->windowLog > srcLog) params->windowLog = srcLog;
-    }   }
-    if (params->hashLog > params->windowLog) params->hashLog = params->windowLog;
-    {   U32 const btPlus = (params->strategy == ZSTD_btlazy2) || (params->strategy == ZSTD_btopt);
-        U32 const maxChainLog = params->windowLog+btPlus;
-        if (params->chainLog > maxChainLog) params->chainLog = maxChainLog; }   /* <= ZSTD_CHAINLOG_MAX */
-
-    if (params->windowLog  < ZSTD_WINDOWLOG_ABSOLUTEMIN) params->windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* required for frame header */
-    if ((params->hashLog  < ZSTD_HASHLOG_MIN) && ((U32)params->strategy >= (U32)ZSTD_btlazy2)) params->hashLog = ZSTD_HASHLOG_MIN;  /* required to ensure collision resistance in bt */
-}
-
-
-size_t ZSTD_sizeofCCtx(ZSTD_compressionParameters cParams)   /* hidden interface, for paramagrill */
-{
-    ZSTD_CCtx* zc = ZSTD_createCCtx();
-    ZSTD_parameters params;
-    params.cParams = cParams;
-    params.fParams.contentSizeFlag = 1;
-    ZSTD_compressBegin_advanced(zc, NULL, 0, params, 0);
-    { size_t const ccsize = sizeof(*zc) + zc->workSpaceSize;
-      ZSTD_freeCCtx(zc);
-      return ccsize; }
-}
-
-/*! ZSTD_resetCCtx_advanced() :
-    note : 'params' is expected to be validated */
-static size_t ZSTD_resetCCtx_advanced (ZSTD_CCtx* zc,
-                                       ZSTD_parameters params, U32 reset)
-{   /* note : params considered validated here */
-    const size_t blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << params.cParams.windowLog);
-    const U32    divider = (params.cParams.searchLength==3) ? 3 : 4;
-    const size_t maxNbSeq = blockSize / divider;
-    const size_t tokenSpace = blockSize + 11*maxNbSeq;
-    const size_t chainSize = (params.cParams.strategy == ZSTD_fast) ? 0 : (1 << params.cParams.chainLog);
+#include "zstd_internal.h" 
+ 
+ 
+/*-************************************* 
+*  Constants 
+***************************************/ 
+static const U32 g_searchStrength = 8;   /* control skip over incompressible data */ 
+ 
+ 
+/*-************************************* 
+*  Helper functions 
+***************************************/ 
+size_t ZSTD_compressBound(size_t srcSize) { return FSE_compressBound(srcSize) + 12; } 
+ 
+ 
+/*-************************************* 
+*  Sequence storage 
+***************************************/ 
+static void ZSTD_resetSeqStore(seqStore_t* ssPtr) 
+{ 
+    ssPtr->offset = ssPtr->offsetStart; 
+    ssPtr->lit = ssPtr->litStart; 
+    ssPtr->litLength = ssPtr->litLengthStart; 
+    ssPtr->matchLength = ssPtr->matchLengthStart; 
+    ssPtr->longLengthID = 0; 
+} 
+ 
+ 
+/*-************************************* 
+*  Context memory management 
+***************************************/ 
+struct ZSTD_CCtx_s 
+{ 
+    const BYTE* nextSrc;    /* next block here to continue on current prefix */ 
+    const BYTE* base;       /* All regular indexes relative to this position */ 
+    const BYTE* dictBase;   /* extDict indexes relative to this position */ 
+    U32   dictLimit;        /* below that point, need extDict */ 
+    U32   lowLimit;         /* below that point, no more data */ 
+    U32   nextToUpdate;     /* index from which to continue dictionary update */ 
+    U32   nextToUpdate3;    /* index from which to continue dictionary update */ 
+    U32   hashLog3;         /* dispatch table : larger == faster, more memory */ 
+    U32   loadedDictEnd; 
+    U32   stage;            /* 0: created; 1: init,dictLoad; 2:started */ 
+    ZSTD_parameters params; 
+    void* workSpace; 
+    size_t workSpaceSize; 
+    size_t blockSize; 
+ 
+    seqStore_t seqStore;    /* sequences storage ptrs */ 
+    U32* hashTable; 
+    U32* hashTable3; 
+    U32* chainTable; 
+    HUF_CElt* hufTable; 
+    U32 flagStaticTables; 
+    FSE_CTable offcodeCTable   [FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)]; 
+    FSE_CTable matchlengthCTable [FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)]; 
+    FSE_CTable litlengthCTable   [FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)]; 
+}; 
+ 
+ZSTD_CCtx* ZSTD_createCCtx(void) 
+{ 
+    return (ZSTD_CCtx*) calloc(1, sizeof(ZSTD_CCtx)); 
+} 
+ 
+size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx) 
+{ 
+    free(cctx->workSpace); 
+    free(cctx); 
+    return 0;   /* reserved as a potential error code in the future */ 
+} 
+ 
+const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx)   /* hidden interface */ 
+{ 
+    return &(ctx->seqStore); 
+} 
+ 
+ 
+#define CLAMP(val,min,max) { if (val<min) val=min; else if (val>max) val=max; } 
+#define CLAMPCHECK(val,min,max) { if ((val<min) || (val>max)) return ERROR(compressionParameter_unsupported); } 
+ 
+/** ZSTD_checkParams() : 
+    ensure param values remain within authorized range. 
+    @return : 0, or an error code if one value is beyond authorized range */ 
+size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams) 
+{ 
+    CLAMPCHECK(cParams.windowLog, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX); 
+    CLAMPCHECK(cParams.chainLog, ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX); 
+    CLAMPCHECK(cParams.hashLog, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX); 
+    CLAMPCHECK(cParams.searchLog, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX); 
+    { U32 const searchLengthMin = (cParams.strategy == ZSTD_fast || cParams.strategy == ZSTD_greedy) ? ZSTD_SEARCHLENGTH_MIN+1 : ZSTD_SEARCHLENGTH_MIN; 
+      U32 const searchLengthMax = (cParams.strategy == ZSTD_fast) ? ZSTD_SEARCHLENGTH_MAX : ZSTD_SEARCHLENGTH_MAX-1; 
+      CLAMPCHECK(cParams.searchLength, searchLengthMin, searchLengthMax); } 
+    CLAMPCHECK(cParams.targetLength, ZSTD_TARGETLENGTH_MIN, ZSTD_TARGETLENGTH_MAX); 
+    if ((U32)(cParams.strategy) > (U32)ZSTD_btopt) return ERROR(compressionParameter_unsupported); 
+    return 0; 
+} 
+ 
+ 
+static unsigned ZSTD_highbit(U32 val); 
+ 
+/** ZSTD_checkCParams_advanced() : 
+    temporary work-around, while the compressor compatibility remains limited regarding windowLog < 18 */ 
+size_t ZSTD_checkCParams_advanced(ZSTD_compressionParameters cParams, U64 srcSize) 
+{ 
+    if (srcSize > (1ULL << ZSTD_WINDOWLOG_MIN)) return ZSTD_checkCParams(cParams); 
+    if (cParams.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN) return ERROR(compressionParameter_unsupported); 
+    if (srcSize <= (1ULL << cParams.windowLog)) cParams.windowLog = ZSTD_WINDOWLOG_MIN; /* fake value - temporary work around */ 
+    if (srcSize <= (1ULL << cParams.chainLog)) cParams.chainLog = ZSTD_CHAINLOG_MIN;    /* fake value - temporary work around */ 
+    if ((srcSize <= (1ULL << cParams.hashLog)) && ((U32)cParams.strategy < (U32)ZSTD_btlazy2)) cParams.hashLog = ZSTD_HASHLOG_MIN;       /* fake value - temporary work around */ 
+    return ZSTD_checkCParams(cParams); 
+} 
+ 
+ 
+/** ZSTD_adjustParams() : 
+    optimize params for q given input (`srcSize` and `dictSize`). 
+    mostly downsizing to reduce memory consumption and initialization. 
+    Both `srcSize` and `dictSize` are optional (use 0 if unknown), 
+    but if both are 0, no optimization can be done. 
+    Note : params is considered validated at this stage. Use ZSTD_checkParams() to ensure that. */ 
+void ZSTD_adjustCParams(ZSTD_compressionParameters* params, U64 srcSize, size_t dictSize) 
+{ 
+    if (srcSize+dictSize == 0) return;   /* no size information available : no adjustment */ 
+ 
+    /* resize params, to use less memory when necessary */ 
+    {   U32 const minSrcSize = (srcSize==0) ? 500 : 0; 
+        U64 const rSize = srcSize + dictSize + minSrcSize; 
+        if (rSize < ((U64)1<<ZSTD_WINDOWLOG_MAX)) { 
+            U32 const srcLog = ZSTD_highbit((U32)(rSize)-1) + 1; 
+            if (params->windowLog > srcLog) params->windowLog = srcLog; 
+    }   } 
+    if (params->hashLog > params->windowLog) params->hashLog = params->windowLog; 
+    {   U32 const btPlus = (params->strategy == ZSTD_btlazy2) || (params->strategy == ZSTD_btopt); 
+        U32 const maxChainLog = params->windowLog+btPlus; 
+        if (params->chainLog > maxChainLog) params->chainLog = maxChainLog; }   /* <= ZSTD_CHAINLOG_MAX */ 
+ 
+    if (params->windowLog  < ZSTD_WINDOWLOG_ABSOLUTEMIN) params->windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* required for frame header */ 
+    if ((params->hashLog  < ZSTD_HASHLOG_MIN) && ((U32)params->strategy >= (U32)ZSTD_btlazy2)) params->hashLog = ZSTD_HASHLOG_MIN;  /* required to ensure collision resistance in bt */ 
+} 
+ 
+ 
+size_t ZSTD_sizeofCCtx(ZSTD_compressionParameters cParams)   /* hidden interface, for paramagrill */ 
+{ 
+    ZSTD_CCtx* zc = ZSTD_createCCtx(); 
+    ZSTD_parameters params; 
+    params.cParams = cParams; 
+    params.fParams.contentSizeFlag = 1; 
+    ZSTD_compressBegin_advanced(zc, NULL, 0, params, 0); 
+    { size_t const ccsize = sizeof(*zc) + zc->workSpaceSize; 
+      ZSTD_freeCCtx(zc); 
+      return ccsize; } 
+} 
+ 
+/*! ZSTD_resetCCtx_advanced() : 
+    note : 'params' is expected to be validated */ 
+static size_t ZSTD_resetCCtx_advanced (ZSTD_CCtx* zc, 
+                                       ZSTD_parameters params, U32 reset) 
+{   /* note : params considered validated here */ 
+    const size_t blockSize = MIN(ZSTD_BLOCKSIZE_MAX, (size_t)1 << params.cParams.windowLog); 
+    const U32    divider = (params.cParams.searchLength==3) ? 3 : 4; 
+    const size_t maxNbSeq = blockSize / divider; 
+    const size_t tokenSpace = blockSize + 11*maxNbSeq; 
+    const size_t chainSize = (params.cParams.strategy == ZSTD_fast) ? 0 : (1 << params.cParams.chainLog); 
     const size_t hSize = ((size_t)1) << params.cParams.hashLog;
-    const size_t h3Size = (zc->hashLog3) ? 1 << zc->hashLog3 : 0;
-    const size_t tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);
-
-    /* Check if workSpace is large enough, alloc a new one if needed */
-    {   size_t const optSpace = ((MaxML+1) + (MaxLL+1) + (MaxOff+1) + (1<<Litbits))*sizeof(U32)
-                              + (ZSTD_OPT_NUM+1)*(sizeof(ZSTD_match_t) + sizeof(ZSTD_optimal_t));
-        size_t const neededSpace = tableSpace + (256*sizeof(U32)) /* huffTable */ + tokenSpace
-                              + ((params.cParams.strategy == ZSTD_btopt) ? optSpace : 0);
-        if (zc->workSpaceSize < neededSpace) {
-            free(zc->workSpace);
-            zc->workSpace = malloc(neededSpace);
-            if (zc->workSpace == NULL) return ERROR(memory_allocation);
-            zc->workSpaceSize = neededSpace;
-    }   }
-
-    if (reset) memset(zc->workSpace, 0, tableSpace );   /* reset only tables */
-    zc->hashTable3 = (U32*)(zc->workSpace);
-    zc->hashTable = zc->hashTable3 + h3Size;
-    zc->chainTable = zc->hashTable + hSize;
-    zc->seqStore.buffer = zc->chainTable + chainSize;
-    zc->hufTable = (HUF_CElt*)zc->seqStore.buffer;
-    zc->flagStaticTables = 0;
-    zc->seqStore.buffer = ((U32*)(zc->seqStore.buffer)) + 256;
-
-    zc->nextToUpdate = 1;
-    zc->nextSrc = NULL;
-    zc->base = NULL;
-    zc->dictBase = NULL;
-    zc->dictLimit = 0;
-    zc->lowLimit = 0;
-    zc->params = params;
-    zc->blockSize = blockSize;
-
-    if (params.cParams.strategy == ZSTD_btopt) {
-        zc->seqStore.litFreq = (U32*)(zc->seqStore.buffer);
-        zc->seqStore.litLengthFreq = zc->seqStore.litFreq + (1<<Litbits);
-        zc->seqStore.matchLengthFreq = zc->seqStore.litLengthFreq + (MaxLL+1);
-        zc->seqStore.offCodeFreq = zc->seqStore.matchLengthFreq + (MaxML+1);
-        zc->seqStore.matchTable = (ZSTD_match_t*)((void*)(zc->seqStore.offCodeFreq + (MaxOff+1)));
-        zc->seqStore.priceTable = (ZSTD_optimal_t*)((void*)(zc->seqStore.matchTable + ZSTD_OPT_NUM+1));
-        zc->seqStore.buffer = zc->seqStore.priceTable + ZSTD_OPT_NUM+1;
-        zc->seqStore.litLengthSum = 0;
-    }
-    zc->seqStore.offsetStart = (U32*) (zc->seqStore.buffer);
-    zc->seqStore.litLengthStart = (U16*) (void*)(zc->seqStore.offsetStart + maxNbSeq);
-    zc->seqStore.matchLengthStart = (U16*) (void*)(zc->seqStore.litLengthStart + maxNbSeq);
-    zc->seqStore.llCodeStart = (BYTE*) (zc->seqStore.matchLengthStart + maxNbSeq);
-    zc->seqStore.mlCodeStart = zc->seqStore.llCodeStart + maxNbSeq;
-    zc->seqStore.offCodeStart = zc->seqStore.mlCodeStart + maxNbSeq;
-    zc->seqStore.litStart = zc->seqStore.offCodeStart + maxNbSeq;
-
-    zc->stage = 1;
-    zc->loadedDictEnd = 0;
-
-    return 0;
-}
-
-
-/*! ZSTD_copyCCtx() :
-*   Duplicate an existing context `srcCCtx` into another one `dstCCtx`.
-*   Only works during stage 1 (i.e. after creation, but before first call to ZSTD_compressContinue()).
-*   @return : 0, or an error code */
-size_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx)
-{
-    if (srcCCtx->stage!=1) return ERROR(stage_wrong);
-
-    dstCCtx->hashLog3 = srcCCtx->hashLog3; /* must be before ZSTD_resetCCtx_advanced */
-    ZSTD_resetCCtx_advanced(dstCCtx, srcCCtx->params, 0);
-    dstCCtx->params.fParams.contentSizeFlag = 0;   /* content size different from the one set during srcCCtx init */
-
-    /* copy tables */
-    {   const size_t chainSize = (srcCCtx->params.cParams.strategy == ZSTD_fast) ? 0 : (1 << srcCCtx->params.cParams.chainLog);
+    const size_t h3Size = (zc->hashLog3) ? 1 << zc->hashLog3 : 0; 
+    const size_t tableSpace = (chainSize + hSize + h3Size) * sizeof(U32); 
+ 
+    /* Check if workSpace is large enough, alloc a new one if needed */ 
+    {   size_t const optSpace = ((MaxML+1) + (MaxLL+1) + (MaxOff+1) + (1<<Litbits))*sizeof(U32) 
+                              + (ZSTD_OPT_NUM+1)*(sizeof(ZSTD_match_t) + sizeof(ZSTD_optimal_t)); 
+        size_t const neededSpace = tableSpace + (256*sizeof(U32)) /* huffTable */ + tokenSpace 
+                              + ((params.cParams.strategy == ZSTD_btopt) ? optSpace : 0); 
+        if (zc->workSpaceSize < neededSpace) { 
+            free(zc->workSpace); 
+            zc->workSpace = malloc(neededSpace); 
+            if (zc->workSpace == NULL) return ERROR(memory_allocation); 
+            zc->workSpaceSize = neededSpace; 
+    }   } 
+ 
+    if (reset) memset(zc->workSpace, 0, tableSpace );   /* reset only tables */ 
+    zc->hashTable3 = (U32*)(zc->workSpace); 
+    zc->hashTable = zc->hashTable3 + h3Size; 
+    zc->chainTable = zc->hashTable + hSize; 
+    zc->seqStore.buffer = zc->chainTable + chainSize; 
+    zc->hufTable = (HUF_CElt*)zc->seqStore.buffer; 
+    zc->flagStaticTables = 0; 
+    zc->seqStore.buffer = ((U32*)(zc->seqStore.buffer)) + 256; 
+ 
+    zc->nextToUpdate = 1; 
+    zc->nextSrc = NULL; 
+    zc->base = NULL; 
+    zc->dictBase = NULL; 
+    zc->dictLimit = 0; 
+    zc->lowLimit = 0; 
+    zc->params = params; 
+    zc->blockSize = blockSize; 
+ 
+    if (params.cParams.strategy == ZSTD_btopt) { 
+        zc->seqStore.litFreq = (U32*)(zc->seqStore.buffer); 
+        zc->seqStore.litLengthFreq = zc->seqStore.litFreq + (1<<Litbits); 
+        zc->seqStore.matchLengthFreq = zc->seqStore.litLengthFreq + (MaxLL+1); 
+        zc->seqStore.offCodeFreq = zc->seqStore.matchLengthFreq + (MaxML+1); 
+        zc->seqStore.matchTable = (ZSTD_match_t*)((void*)(zc->seqStore.offCodeFreq + (MaxOff+1))); 
+        zc->seqStore.priceTable = (ZSTD_optimal_t*)((void*)(zc->seqStore.matchTable + ZSTD_OPT_NUM+1)); 
+        zc->seqStore.buffer = zc->seqStore.priceTable + ZSTD_OPT_NUM+1; 
+        zc->seqStore.litLengthSum = 0; 
+    } 
+    zc->seqStore.offsetStart = (U32*) (zc->seqStore.buffer); 
+    zc->seqStore.litLengthStart = (U16*) (void*)(zc->seqStore.offsetStart + maxNbSeq); 
+    zc->seqStore.matchLengthStart = (U16*) (void*)(zc->seqStore.litLengthStart + maxNbSeq); 
+    zc->seqStore.llCodeStart = (BYTE*) (zc->seqStore.matchLengthStart + maxNbSeq); 
+    zc->seqStore.mlCodeStart = zc->seqStore.llCodeStart + maxNbSeq; 
+    zc->seqStore.offCodeStart = zc->seqStore.mlCodeStart + maxNbSeq; 
+    zc->seqStore.litStart = zc->seqStore.offCodeStart + maxNbSeq; 
+ 
+    zc->stage = 1; 
+    zc->loadedDictEnd = 0; 
+ 
+    return 0; 
+} 
+ 
+ 
+/*! ZSTD_copyCCtx() : 
+*   Duplicate an existing context `srcCCtx` into another one `dstCCtx`. 
+*   Only works during stage 1 (i.e. after creation, but before first call to ZSTD_compressContinue()). 
+*   @return : 0, or an error code */ 
+size_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx) 
+{ 
+    if (srcCCtx->stage!=1) return ERROR(stage_wrong); 
+ 
+    dstCCtx->hashLog3 = srcCCtx->hashLog3; /* must be before ZSTD_resetCCtx_advanced */ 
+    ZSTD_resetCCtx_advanced(dstCCtx, srcCCtx->params, 0); 
+    dstCCtx->params.fParams.contentSizeFlag = 0;   /* content size different from the one set during srcCCtx init */ 
+ 
+    /* copy tables */ 
+    {   const size_t chainSize = (srcCCtx->params.cParams.strategy == ZSTD_fast) ? 0 : (1 << srcCCtx->params.cParams.chainLog); 
         const size_t hSize = ((size_t)1) << srcCCtx->params.cParams.hashLog;
-        const size_t h3Size = (srcCCtx->hashLog3) ? 1 << srcCCtx->hashLog3 : 0;
-        const size_t tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);
-        memcpy(dstCCtx->workSpace, srcCCtx->workSpace, tableSpace);
-    }
-
-    /* copy dictionary pointers */
-    dstCCtx->nextToUpdate = srcCCtx->nextToUpdate;
-    dstCCtx->nextToUpdate3= srcCCtx->nextToUpdate3;
-    dstCCtx->nextSrc      = srcCCtx->nextSrc;
-    dstCCtx->base         = srcCCtx->base;
-    dstCCtx->dictBase     = srcCCtx->dictBase;
-    dstCCtx->dictLimit    = srcCCtx->dictLimit;
-    dstCCtx->lowLimit     = srcCCtx->lowLimit;
-    dstCCtx->loadedDictEnd= srcCCtx->loadedDictEnd;
-
-    /* copy entropy tables */
-    dstCCtx->flagStaticTables = srcCCtx->flagStaticTables;
-    if (srcCCtx->flagStaticTables) {
-        memcpy(dstCCtx->hufTable, srcCCtx->hufTable, 256*4);
-        memcpy(dstCCtx->litlengthCTable, srcCCtx->litlengthCTable, sizeof(dstCCtx->litlengthCTable));
-        memcpy(dstCCtx->matchlengthCTable, srcCCtx->matchlengthCTable, sizeof(dstCCtx->matchlengthCTable));
-        memcpy(dstCCtx->offcodeCTable, srcCCtx->offcodeCTable, sizeof(dstCCtx->offcodeCTable));
-    }
-
-    return 0;
-}
-
-
-/*! ZSTD_reduceTable() :
-*   reduce table indexes by `reducerValue` */
-static void ZSTD_reduceTable (U32* const table, U32 const size, U32 const reducerValue)
-{
-    U32 u;
-    for (u=0 ; u < size ; u++) {
-        if (table[u] < reducerValue) table[u] = 0;
-        else table[u] -= reducerValue;
-    }
-}
-
-/*! ZSTD_reduceIndex() :
-*   rescale all indexes to avoid future overflow (indexes are U32) */
-static void ZSTD_reduceIndex (ZSTD_CCtx* zc, const U32 reducerValue)
-{
-    { const U32 hSize = 1 << zc->params.cParams.hashLog;
-      ZSTD_reduceTable(zc->hashTable, hSize, reducerValue); }
-
-    { const U32 chainSize = (zc->params.cParams.strategy == ZSTD_fast) ? 0 : (1 << zc->params.cParams.chainLog);
-      ZSTD_reduceTable(zc->chainTable, chainSize, reducerValue); }
-
-    { const U32 h3Size = (zc->hashLog3) ? 1 << zc->hashLog3 : 0;
-      ZSTD_reduceTable(zc->hashTable3, h3Size, reducerValue); }
-}
-
-
-/*-*******************************************************
-*  Block entropic compression
-*********************************************************/
-
-/* Frame format description
-   Frame Header -  [ Block Header - Block ] - Frame End
-   1) Frame Header
-      - 4 bytes - Magic Number : ZSTD_MAGICNUMBER (defined within zstd_static.h)
-      - 1 byte  - Frame Descriptor
-   2) Block Header
-      - 3 bytes, starting with a 2-bits descriptor
-                 Uncompressed, Compressed, Frame End, unused
-   3) Block
-      See Block Format Description
-   4) Frame End
-      - 3 bytes, compatible with Block Header
-*/
-
-
-/* Frame descriptor
-
-   1 byte, using :
-   bit 0-3 : windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN   (see zstd_internal.h)
-   bit 4   : minmatch 4(0) or 3(1)
-   bit 5   : reserved (must be zero)
-   bit 6-7 : Frame content size : unknown, 1 byte, 2 bytes, 8 bytes
-
-   Optional : content size (0, 1, 2 or 8 bytes)
-   0 : unknown
-   1 : 0-255 bytes
-   2 : 256 - 65535+256
-   8 : up to 16 exa
-*/
-
-
-/* Block format description
-
-   Block = Literal Section - Sequences Section
-   Prerequisite : size of (compressed) block, maximum size of regenerated data
-
-   1) Literal Section
-
-   1.1) Header : 1-5 bytes
-        flags: 2 bits
-            00 compressed by Huff0
-            01 unused
-            10 is Raw (uncompressed)
-            11 is Rle
-            Note : using 01 => Huff0 with precomputed table ?
-            Note : delta map ? => compressed ?
-
-   1.1.1) Huff0-compressed literal block : 3-5 bytes
-            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream
-            srcSize < 1 KB => 3 bytes (2-2-10-10)
-            srcSize < 16KB => 4 bytes (2-2-14-14)
-            else           => 5 bytes (2-2-18-18)
-            big endian convention
-
-   1.1.2) Raw (uncompressed) literal block header : 1-3 bytes
-        size :  5 bits: (IS_RAW<<6) + (0<<4) + size
-               12 bits: (IS_RAW<<6) + (2<<4) + (size>>8)
-                        size&255
-               20 bits: (IS_RAW<<6) + (3<<4) + (size>>16)
-                        size>>8&255
-                        size&255
-
-   1.1.3) Rle (repeated single byte) literal block header : 1-3 bytes
-        size :  5 bits: (IS_RLE<<6) + (0<<4) + size
-               12 bits: (IS_RLE<<6) + (2<<4) + (size>>8)
-                        size&255
-               20 bits: (IS_RLE<<6) + (3<<4) + (size>>16)
-                        size>>8&255
-                        size&255
-
-   1.1.4) Huff0-compressed literal block, using precomputed CTables : 3-5 bytes
-            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream
-            srcSize < 1 KB => 3 bytes (2-2-10-10)
-            srcSize < 16KB => 4 bytes (2-2-14-14)
-            else           => 5 bytes (2-2-18-18)
-            big endian convention
-
-        1- CTable available (stored into workspace ?)
-        2- Small input (fast heuristic ? Full comparison ? depend on clevel ?)
-
-
-   1.2) Literal block content
-
-   1.2.1) Huff0 block, using sizes from header
-        See Huff0 format
-
-   1.2.2) Huff0 block, using prepared table
-
-   1.2.3) Raw content
-
-   1.2.4) single byte
-
-
-   2) Sequences section
-
-      - Nb Sequences : 2 bytes, little endian
-      - Control Token : 1 byte (see below)
-      - Dumps Length : 1 or 2 bytes (depending on control token)
-      - Dumps : as stated by dumps length
-      - Literal Lengths FSE table (as needed depending on encoding method)
-      - Offset Codes FSE table (as needed depending on encoding method)
-      - Match Lengths FSE table (as needed depending on encoding method)
-
-    2.1) Control Token
-      8 bits, divided as :
-      0-1 : dumpsLength
-      2-3 : MatchLength, FSE encoding method
-      4-5 : Offset Codes, FSE encoding method
-      6-7 : Literal Lengths, FSE encoding method
-
-      FSE encoding method :
-      FSE_ENCODING_RAW : uncompressed; no header
-      FSE_ENCODING_RLE : single repeated value; header 1 byte
-      FSE_ENCODING_STATIC : use prepared table; no header
-      FSE_ENCODING_DYNAMIC : read NCount
-*/
-
-size_t ZSTD_noCompressBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    BYTE* const ostart = (BYTE* const)dst;
-
-    if (srcSize + ZSTD_blockHeaderSize > dstCapacity) return ERROR(dstSize_tooSmall);
-    memcpy(ostart + ZSTD_blockHeaderSize, src, srcSize);
-
-    /* Build header */
-    ostart[0]  = (BYTE)(srcSize>>16);
-    ostart[1]  = (BYTE)(srcSize>>8);
-    ostart[2]  = (BYTE) srcSize;
-    ostart[0] += (BYTE)(bt_raw<<6);   /* is a raw (uncompressed) block */
-
-    return ZSTD_blockHeaderSize+srcSize;
-}
-
-
-static size_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    BYTE* const ostart = (BYTE* const)dst;
-    U32 const flSize = 1 + (srcSize>31) + (srcSize>4095);
-
-    if (srcSize + flSize > dstCapacity) return ERROR(dstSize_tooSmall);
-
-    switch(flSize)
-    {
-        case 1: /* 2 - 1 - 5 */
-            ostart[0] = (BYTE)((IS_RAW<<6) + (0<<5) + srcSize);
-            break;
-        case 2: /* 2 - 2 - 12 */
-            ostart[0] = (BYTE)((IS_RAW<<6) + (2<<4) + (srcSize >> 8));
-            ostart[1] = (BYTE)srcSize;
-            break;
-        default:   /*note : should not be necessary : flSize is within {1,2,3} */
-        case 3: /* 2 - 2 - 20 */
-            ostart[0] = (BYTE)((IS_RAW<<6) + (3<<4) + (srcSize >> 16));
-            ostart[1] = (BYTE)(srcSize>>8);
-            ostart[2] = (BYTE)srcSize;
-            break;
-    }
-
-    memcpy(ostart + flSize, src, srcSize);
-    return srcSize + flSize;
-}
-
-static size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    BYTE* const ostart = (BYTE* const)dst;
-    U32 const flSize = 1 + (srcSize>31) + (srcSize>4095);
-
-    (void)dstCapacity;  /* dstCapacity guaranteed to be >=4, hence large enough */
-
-    switch(flSize)
-    {
-        case 1: /* 2 - 1 - 5 */
-            ostart[0] = (BYTE)((IS_RLE<<6) + (0<<5) + srcSize);
-            break;
-        case 2: /* 2 - 2 - 12 */
-            ostart[0] = (BYTE)((IS_RLE<<6) + (2<<4) + (srcSize >> 8));
-            ostart[1] = (BYTE)srcSize;
-            break;
-        default:   /*note : should not be necessary : flSize is necessarily within {1,2,3} */
-        case 3: /* 2 - 2 - 20 */
-            ostart[0] = (BYTE)((IS_RLE<<6) + (3<<4) + (srcSize >> 16));
-            ostart[1] = (BYTE)(srcSize>>8);
-            ostart[2] = (BYTE)srcSize;
-            break;
-    }
-
-    ostart[flSize] = *(const BYTE*)src;
-    return flSize+1;
-}
-
-
-static size_t ZSTD_minGain(size_t srcSize) { return (srcSize >> 6) + 2; }
-
-static size_t ZSTD_compressLiterals (ZSTD_CCtx* zc,
-                                     void* dst, size_t dstCapacity,
-                               const void* src, size_t srcSize)
-{
-    size_t const minGain = ZSTD_minGain(srcSize);
-    size_t const lhSize = 3 + (srcSize >= 1 KB) + (srcSize >= 16 KB);
-    BYTE* const ostart = (BYTE*)dst;
-    U32 singleStream = srcSize < 256;
-    U32 hType = IS_HUF;
-    size_t cLitSize;
-
-
-    /* small ? don't even attempt compression (speed opt) */
-#   define LITERAL_NOENTROPY 63
-    {   size_t const minLitSize = zc->flagStaticTables ? 6 : LITERAL_NOENTROPY;
-        if (srcSize <= minLitSize) return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
-    }
-
-    if (dstCapacity < lhSize+1) return ERROR(dstSize_tooSmall);   /* not enough space for compression */
-    if (zc->flagStaticTables && (lhSize==3)) {
-        hType = IS_PCH;
-        singleStream = 1;
-        cLitSize = HUF_compress1X_usingCTable(ostart+lhSize, dstCapacity-lhSize, src, srcSize, zc->hufTable);
-    } else {
-        cLitSize = singleStream ? HUF_compress1X(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 12)
-                                : HUF_compress2 (ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 12);
-    }
-
-    if ((cLitSize==0) || (cLitSize >= srcSize - minGain))
-        return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
-    if (cLitSize==1)
-        return ZSTD_compressRleLiteralsBlock(dst, dstCapacity, src, srcSize);
-
-    /* Build header */
-    switch(lhSize)
-    {
-    case 3: /* 2 - 2 - 10 - 10 */
-        ostart[0] = (BYTE)((srcSize>>6) + (singleStream << 4) + (hType<<6));
-        ostart[1] = (BYTE)((srcSize<<2) + (cLitSize>>8));
-        ostart[2] = (BYTE)(cLitSize);
-        break;
-    case 4: /* 2 - 2 - 14 - 14 */
-        ostart[0] = (BYTE)((srcSize>>10) + (2<<4) +  (hType<<6));
-        ostart[1] = (BYTE)(srcSize>> 2);
-        ostart[2] = (BYTE)((srcSize<<6) + (cLitSize>>8));
-        ostart[3] = (BYTE)(cLitSize);
-        break;
-    default:   /* should not be necessary, lhSize is only {3,4,5} */
-    case 5: /* 2 - 2 - 18 - 18 */
-        ostart[0] = (BYTE)((srcSize>>14) + (3<<4) +  (hType<<6));
-        ostart[1] = (BYTE)(srcSize>>6);
-        ostart[2] = (BYTE)((srcSize<<2) + (cLitSize>>16));
-        ostart[3] = (BYTE)(cLitSize>>8);
-        ostart[4] = (BYTE)(cLitSize);
-        break;
-    }
-    return lhSize+cLitSize;
-}
-
-
-void ZSTD_seqToCodes(const seqStore_t* seqStorePtr, size_t const nbSeq)
-{
-    /* LL codes */
-    {   static const BYTE LL_Code[64] = {  0,  1,  2,  3,  4,  5,  6,  7,
-                                           8,  9, 10, 11, 12, 13, 14, 15,
-                                          16, 16, 17, 17, 18, 18, 19, 19,
-                                          20, 20, 20, 20, 21, 21, 21, 21,
-                                          22, 22, 22, 22, 22, 22, 22, 22,
-                                          23, 23, 23, 23, 23, 23, 23, 23,
-                                          24, 24, 24, 24, 24, 24, 24, 24,
-                                          24, 24, 24, 24, 24, 24, 24, 24 };
-        const BYTE LL_deltaCode = 19;
-        const U16* const llTable = seqStorePtr->litLengthStart;
-        BYTE* const llCodeTable = seqStorePtr->llCodeStart;
-        size_t u;
-        for (u=0; u<nbSeq; u++) {
-            U32 const  ll = llTable[u];
-            llCodeTable[u] = (ll>63) ? (BYTE)ZSTD_highbit(ll) + LL_deltaCode : LL_Code[ll];
-        }
-        if (seqStorePtr->longLengthID==1)
-            llCodeTable[seqStorePtr->longLengthPos] = MaxLL;
-    }
-
-    /* Offset codes */
-    {   const U32* const offsetTable = seqStorePtr->offsetStart;
-        BYTE* const ofCodeTable = seqStorePtr->offCodeStart;
-        size_t u;
-        for (u=0; u<nbSeq; u++) ofCodeTable[u] = (BYTE)ZSTD_highbit(offsetTable[u]);
-    }
-
-    /* ML codes */
-    {   static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
-                                          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
-                                          32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37,
-                                          38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39,
-                                          40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
-                                          41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
-                                          42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
-                                          42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 };
-        const BYTE ML_deltaCode = 36;
-        const U16* const mlTable = seqStorePtr->matchLengthStart;
-        BYTE* const mlCodeTable = seqStorePtr->mlCodeStart;
-        size_t u;
-        for (u=0; u<nbSeq; u++) {
-            U32 const ml = mlTable[u];
-            mlCodeTable[u] = (ml>127) ? (BYTE)ZSTD_highbit(ml) + ML_deltaCode : ML_Code[ml];
-        }
-        if (seqStorePtr->longLengthID==2)
-            mlCodeTable[seqStorePtr->longLengthPos] = MaxML;
-    }
-}
-
-
-size_t ZSTD_compressSequences(ZSTD_CCtx* zc,
-                              void* dst, size_t dstCapacity,
-                              size_t srcSize)
-{
-    const seqStore_t* seqStorePtr = &(zc->seqStore);
-    U32 count[MaxSeq+1];
-    S16 norm[MaxSeq+1];
-    FSE_CTable* CTable_LitLength = zc->litlengthCTable;
-    FSE_CTable* CTable_OffsetBits = zc->offcodeCTable;
-    FSE_CTable* CTable_MatchLength = zc->matchlengthCTable;
-    U32 LLtype, Offtype, MLtype;   /* compressed, raw or rle */
-    U16*  const llTable = seqStorePtr->litLengthStart;
-    U16*  const mlTable = seqStorePtr->matchLengthStart;
-    const U32*  const offsetTable = seqStorePtr->offsetStart;
-    const U32*  const offsetTableEnd = seqStorePtr->offset;
-    BYTE* const ofCodeTable = seqStorePtr->offCodeStart;
-    BYTE* const llCodeTable = seqStorePtr->llCodeStart;
-    BYTE* const mlCodeTable = seqStorePtr->mlCodeStart;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + dstCapacity;
-    BYTE* op = ostart;
-    size_t const nbSeq = offsetTableEnd - offsetTable;
-    BYTE* seqHead;
-
-    /* Compress literals */
-    {   const BYTE* const literals = seqStorePtr->litStart;
-        size_t const litSize = seqStorePtr->lit - literals;
-        size_t const cSize = ZSTD_compressLiterals(zc, op, dstCapacity, literals, litSize);
-        if (ZSTD_isError(cSize)) return cSize;
-        op += cSize;
-    }
-
-    /* Sequences Header */
-    if ((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead */) return ERROR(dstSize_tooSmall);
-    if (nbSeq < 0x7F) *op++ = (BYTE)nbSeq;
-    else if (nbSeq < LONGNBSEQ) op[0] = (BYTE)((nbSeq>>8) + 0x80), op[1] = (BYTE)nbSeq, op+=2;
-    else op[0]=0xFF, MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ)), op+=3;
-    if (nbSeq==0) goto _check_compressibility;
-
-    /* seqHead : flags for FSE encoding type */
-    seqHead = op++;
-
-#define MIN_SEQ_FOR_DYNAMIC_FSE   64
-#define MAX_SEQ_FOR_STATIC_FSE  1000
-
-    /* convert length/distances into codes */
-    ZSTD_seqToCodes(seqStorePtr, nbSeq);
-
-    /* CTable for Literal Lengths */
-    {   U32 max = MaxLL;
-        size_t const mostFrequent = FSE_countFast(count, &max, llCodeTable, nbSeq);
-        if ((mostFrequent == nbSeq) && (nbSeq > 2)) {
-            *op++ = llCodeTable[0];
-            FSE_buildCTable_rle(CTable_LitLength, (BYTE)max);
-            LLtype = FSE_ENCODING_RLE;
-        } else if ((zc->flagStaticTables) && (nbSeq < MAX_SEQ_FOR_STATIC_FSE)) {
-            LLtype = FSE_ENCODING_STATIC;
-        } else if ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (LL_defaultNormLog-1)))) {
-            FSE_buildCTable(CTable_LitLength, LL_defaultNorm, MaxLL, LL_defaultNormLog);
-            LLtype = FSE_ENCODING_RAW;
-        } else {
-            size_t nbSeq_1 = nbSeq;
-            const U32 tableLog = FSE_optimalTableLog(LLFSELog, nbSeq, max);
-            if (count[llCodeTable[nbSeq-1]]>1) { count[llCodeTable[nbSeq-1]]--; nbSeq_1--; }
-            FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max);
-            { size_t const NCountSize = FSE_writeNCount(op, oend-op, norm, max, tableLog);   /* overflow protected */
-              if (FSE_isError(NCountSize)) return ERROR(GENERIC);
-              op += NCountSize; }
-            FSE_buildCTable(CTable_LitLength, norm, max, tableLog);
-            LLtype = FSE_ENCODING_DYNAMIC;
-    }   }
-
-    /* CTable for Offsets */
-    {   U32 max = MaxOff;
-        size_t const mostFrequent = FSE_countFast(count, &max, ofCodeTable, nbSeq);
-        if ((mostFrequent == nbSeq) && (nbSeq > 2)) {
-            *op++ = ofCodeTable[0];
-            FSE_buildCTable_rle(CTable_OffsetBits, (BYTE)max);
-            Offtype = FSE_ENCODING_RLE;
-        } else if ((zc->flagStaticTables) && (nbSeq < MAX_SEQ_FOR_STATIC_FSE)) {
-            Offtype = FSE_ENCODING_STATIC;
-        } else if ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (OF_defaultNormLog-1)))) {
-            FSE_buildCTable(CTable_OffsetBits, OF_defaultNorm, MaxOff, OF_defaultNormLog);
-            Offtype = FSE_ENCODING_RAW;
-        } else {
-            size_t nbSeq_1 = nbSeq;
-            const U32 tableLog = FSE_optimalTableLog(OffFSELog, nbSeq, max);
-            if (count[ofCodeTable[nbSeq-1]]>1) { count[ofCodeTable[nbSeq-1]]--; nbSeq_1--; }
-            FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max);
-            { size_t const NCountSize = FSE_writeNCount(op, oend-op, norm, max, tableLog);   /* overflow protected */
-              if (FSE_isError(NCountSize)) return ERROR(GENERIC);
-              op += NCountSize; }
-            FSE_buildCTable(CTable_OffsetBits, norm, max, tableLog);
-            Offtype = FSE_ENCODING_DYNAMIC;
-    }   }
-
-    /* CTable for MatchLengths */
-    {   U32 max = MaxML;
-        size_t const mostFrequent = FSE_countFast(count, &max, mlCodeTable, nbSeq);
-        if ((mostFrequent == nbSeq) && (nbSeq > 2)) {
-            *op++ = *mlCodeTable;
-            FSE_buildCTable_rle(CTable_MatchLength, (BYTE)max);
-            MLtype = FSE_ENCODING_RLE;
-        } else if ((zc->flagStaticTables) && (nbSeq < MAX_SEQ_FOR_STATIC_FSE)) {
-            MLtype = FSE_ENCODING_STATIC;
-        } else if ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (ML_defaultNormLog-1)))) {
-            FSE_buildCTable(CTable_MatchLength, ML_defaultNorm, MaxML, ML_defaultNormLog);
-            MLtype = FSE_ENCODING_RAW;
-        } else {
-            size_t nbSeq_1 = nbSeq;
-            const U32 tableLog = FSE_optimalTableLog(MLFSELog, nbSeq, max);
-            if (count[mlCodeTable[nbSeq-1]]>1) { count[mlCodeTable[nbSeq-1]]--; nbSeq_1--; }
-            FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max);
-            { size_t const NCountSize = FSE_writeNCount(op, oend-op, norm, max, tableLog);   /* overflow protected */
-              if (FSE_isError(NCountSize)) return ERROR(GENERIC);
-              op += NCountSize; }
-            FSE_buildCTable(CTable_MatchLength, norm, max, tableLog);
-            MLtype = FSE_ENCODING_DYNAMIC;
-    }   }
-
-    *seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2));
-    zc->flagStaticTables = 0;
-
-    /* Encoding Sequences */
-    {   BIT_CStream_t blockStream;
-        FSE_CState_t  stateMatchLength;
-        FSE_CState_t  stateOffsetBits;
-        FSE_CState_t  stateLitLength;
-
-        { size_t const errorCode = BIT_initCStream(&blockStream, op, oend-op);
-          if (ERR_isError(errorCode)) return ERROR(dstSize_tooSmall); }   /* not enough space remaining */
-
-        /* first symbols */
-        FSE_initCState2(&stateMatchLength, CTable_MatchLength, mlCodeTable[nbSeq-1]);
-        FSE_initCState2(&stateOffsetBits,  CTable_OffsetBits,  ofCodeTable[nbSeq-1]);
-        FSE_initCState2(&stateLitLength,   CTable_LitLength,   llCodeTable[nbSeq-1]);
-        BIT_addBits(&blockStream, llTable[nbSeq-1], LL_bits[llCodeTable[nbSeq-1]]);
-        if (MEM_32bits()) BIT_flushBits(&blockStream);
-        BIT_addBits(&blockStream, mlTable[nbSeq-1], ML_bits[mlCodeTable[nbSeq-1]]);
-        if (MEM_32bits()) BIT_flushBits(&blockStream);
-        BIT_addBits(&blockStream, offsetTable[nbSeq-1], ofCodeTable[nbSeq-1]);
-        BIT_flushBits(&blockStream);
-
-        {   size_t n;
-            for (n=nbSeq-2 ; n<nbSeq ; n--) {      /* intentional underflow */
-                const BYTE ofCode = ofCodeTable[n];
-                const BYTE mlCode = mlCodeTable[n];
-                const BYTE llCode = llCodeTable[n];
-                const U32  llBits = LL_bits[llCode];
-                const U32  mlBits = ML_bits[mlCode];
-                const U32  ofBits = ofCode;                                     /* 32b*/  /* 64b*/
-                                                                                /* (7)*/  /* (7)*/
-                FSE_encodeSymbol(&blockStream, &stateOffsetBits, ofCode);       /* 15 */  /* 15 */
-                FSE_encodeSymbol(&blockStream, &stateMatchLength, mlCode);      /* 24 */  /* 24 */
-                if (MEM_32bits()) BIT_flushBits(&blockStream);                  /* (7)*/
-                FSE_encodeSymbol(&blockStream, &stateLitLength, llCode);        /* 16 */  /* 33 */
-                if (MEM_32bits() || (ofBits+mlBits+llBits >= 64-7-(LLFSELog+MLFSELog+OffFSELog)))
-                    BIT_flushBits(&blockStream);                                /* (7)*/
-                BIT_addBits(&blockStream, llTable[n], llBits);
-                if (MEM_32bits() && ((llBits+mlBits)>24)) BIT_flushBits(&blockStream);
-                BIT_addBits(&blockStream, mlTable[n], mlBits);
-                if (MEM_32bits()) BIT_flushBits(&blockStream);                  /* (7)*/
-                BIT_addBits(&blockStream, offsetTable[n], ofBits);              /* 31 */
-                BIT_flushBits(&blockStream);                                    /* (7)*/
-        }   }
-
-        FSE_flushCState(&blockStream, &stateMatchLength);
-        FSE_flushCState(&blockStream, &stateOffsetBits);
-        FSE_flushCState(&blockStream, &stateLitLength);
-
-        {   size_t const streamSize = BIT_closeCStream(&blockStream);
-            if (streamSize==0) return ERROR(dstSize_tooSmall);   /* not enough space */
-            op += streamSize;
-    }   }
-
-    /* check compressibility */
-_check_compressibility:
-    { size_t const minGain = ZSTD_minGain(srcSize);
-      size_t const maxCSize = srcSize - minGain;
-      if ((size_t)(op-ostart) >= maxCSize) return 0; }
-
-    return op - ostart;
-}
-
-
-/*! ZSTD_storeSeq() :
-    Store a sequence (literal length, literals, offset code and match length code) into seqStore_t.
-    `offsetCode` : distance to match, or 0 == repCode.
-    `matchCode` : matchLength - MINMATCH
-*/
-MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const BYTE* literals, size_t offsetCode, size_t matchCode)
-{
-#if 0  /* for debug */
-    static const BYTE* g_start = NULL;
-    const U32 pos = (U32)(literals - g_start);
-    if (g_start==NULL) g_start = literals;
+        const size_t h3Size = (srcCCtx->hashLog3) ? 1 << srcCCtx->hashLog3 : 0; 
+        const size_t tableSpace = (chainSize + hSize + h3Size) * sizeof(U32); 
+        memcpy(dstCCtx->workSpace, srcCCtx->workSpace, tableSpace); 
+    } 
+ 
+    /* copy dictionary pointers */ 
+    dstCCtx->nextToUpdate = srcCCtx->nextToUpdate; 
+    dstCCtx->nextToUpdate3= srcCCtx->nextToUpdate3; 
+    dstCCtx->nextSrc      = srcCCtx->nextSrc; 
+    dstCCtx->base         = srcCCtx->base; 
+    dstCCtx->dictBase     = srcCCtx->dictBase; 
+    dstCCtx->dictLimit    = srcCCtx->dictLimit; 
+    dstCCtx->lowLimit     = srcCCtx->lowLimit; 
+    dstCCtx->loadedDictEnd= srcCCtx->loadedDictEnd; 
+ 
+    /* copy entropy tables */ 
+    dstCCtx->flagStaticTables = srcCCtx->flagStaticTables; 
+    if (srcCCtx->flagStaticTables) { 
+        memcpy(dstCCtx->hufTable, srcCCtx->hufTable, 256*4); 
+        memcpy(dstCCtx->litlengthCTable, srcCCtx->litlengthCTable, sizeof(dstCCtx->litlengthCTable)); 
+        memcpy(dstCCtx->matchlengthCTable, srcCCtx->matchlengthCTable, sizeof(dstCCtx->matchlengthCTable)); 
+        memcpy(dstCCtx->offcodeCTable, srcCCtx->offcodeCTable, sizeof(dstCCtx->offcodeCTable)); 
+    } 
+ 
+    return 0; 
+} 
+ 
+ 
+/*! ZSTD_reduceTable() : 
+*   reduce table indexes by `reducerValue` */ 
+static void ZSTD_reduceTable (U32* const table, U32 const size, U32 const reducerValue) 
+{ 
+    U32 u; 
+    for (u=0 ; u < size ; u++) { 
+        if (table[u] < reducerValue) table[u] = 0; 
+        else table[u] -= reducerValue; 
+    } 
+} 
+ 
+/*! ZSTD_reduceIndex() : 
+*   rescale all indexes to avoid future overflow (indexes are U32) */ 
+static void ZSTD_reduceIndex (ZSTD_CCtx* zc, const U32 reducerValue) 
+{ 
+    { const U32 hSize = 1 << zc->params.cParams.hashLog; 
+      ZSTD_reduceTable(zc->hashTable, hSize, reducerValue); } 
+ 
+    { const U32 chainSize = (zc->params.cParams.strategy == ZSTD_fast) ? 0 : (1 << zc->params.cParams.chainLog); 
+      ZSTD_reduceTable(zc->chainTable, chainSize, reducerValue); } 
+ 
+    { const U32 h3Size = (zc->hashLog3) ? 1 << zc->hashLog3 : 0; 
+      ZSTD_reduceTable(zc->hashTable3, h3Size, reducerValue); } 
+} 
+ 
+ 
+/*-******************************************************* 
+*  Block entropic compression 
+*********************************************************/ 
+ 
+/* Frame format description 
+   Frame Header -  [ Block Header - Block ] - Frame End 
+   1) Frame Header 
+      - 4 bytes - Magic Number : ZSTD_MAGICNUMBER (defined within zstd_static.h) 
+      - 1 byte  - Frame Descriptor 
+   2) Block Header 
+      - 3 bytes, starting with a 2-bits descriptor 
+                 Uncompressed, Compressed, Frame End, unused 
+   3) Block 
+      See Block Format Description 
+   4) Frame End 
+      - 3 bytes, compatible with Block Header 
+*/ 
+ 
+ 
+/* Frame descriptor 
+ 
+   1 byte, using : 
+   bit 0-3 : windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN   (see zstd_internal.h) 
+   bit 4   : minmatch 4(0) or 3(1) 
+   bit 5   : reserved (must be zero) 
+   bit 6-7 : Frame content size : unknown, 1 byte, 2 bytes, 8 bytes 
+ 
+   Optional : content size (0, 1, 2 or 8 bytes) 
+   0 : unknown 
+   1 : 0-255 bytes 
+   2 : 256 - 65535+256 
+   8 : up to 16 exa 
+*/ 
+ 
+ 
+/* Block format description 
+ 
+   Block = Literal Section - Sequences Section 
+   Prerequisite : size of (compressed) block, maximum size of regenerated data 
+ 
+   1) Literal Section 
+ 
+   1.1) Header : 1-5 bytes 
+        flags: 2 bits 
+            00 compressed by Huff0 
+            01 unused 
+            10 is Raw (uncompressed) 
+            11 is Rle 
+            Note : using 01 => Huff0 with precomputed table ? 
+            Note : delta map ? => compressed ? 
+ 
+   1.1.1) Huff0-compressed literal block : 3-5 bytes 
+            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream 
+            srcSize < 1 KB => 3 bytes (2-2-10-10) 
+            srcSize < 16KB => 4 bytes (2-2-14-14) 
+            else           => 5 bytes (2-2-18-18) 
+            big endian convention 
+ 
+   1.1.2) Raw (uncompressed) literal block header : 1-3 bytes 
+        size :  5 bits: (IS_RAW<<6) + (0<<4) + size 
+               12 bits: (IS_RAW<<6) + (2<<4) + (size>>8) 
+                        size&255 
+               20 bits: (IS_RAW<<6) + (3<<4) + (size>>16) 
+                        size>>8&255 
+                        size&255 
+ 
+   1.1.3) Rle (repeated single byte) literal block header : 1-3 bytes 
+        size :  5 bits: (IS_RLE<<6) + (0<<4) + size 
+               12 bits: (IS_RLE<<6) + (2<<4) + (size>>8) 
+                        size&255 
+               20 bits: (IS_RLE<<6) + (3<<4) + (size>>16) 
+                        size>>8&255 
+                        size&255 
+ 
+   1.1.4) Huff0-compressed literal block, using precomputed CTables : 3-5 bytes 
+            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream 
+            srcSize < 1 KB => 3 bytes (2-2-10-10) 
+            srcSize < 16KB => 4 bytes (2-2-14-14) 
+            else           => 5 bytes (2-2-18-18) 
+            big endian convention 
+ 
+        1- CTable available (stored into workspace ?) 
+        2- Small input (fast heuristic ? Full comparison ? depend on clevel ?) 
+ 
+ 
+   1.2) Literal block content 
+ 
+   1.2.1) Huff0 block, using sizes from header 
+        See Huff0 format 
+ 
+   1.2.2) Huff0 block, using prepared table 
+ 
+   1.2.3) Raw content 
+ 
+   1.2.4) single byte 
+ 
+ 
+   2) Sequences section 
+ 
+      - Nb Sequences : 2 bytes, little endian 
+      - Control Token : 1 byte (see below) 
+      - Dumps Length : 1 or 2 bytes (depending on control token) 
+      - Dumps : as stated by dumps length 
+      - Literal Lengths FSE table (as needed depending on encoding method) 
+      - Offset Codes FSE table (as needed depending on encoding method) 
+      - Match Lengths FSE table (as needed depending on encoding method) 
+ 
+    2.1) Control Token 
+      8 bits, divided as : 
+      0-1 : dumpsLength 
+      2-3 : MatchLength, FSE encoding method 
+      4-5 : Offset Codes, FSE encoding method 
+      6-7 : Literal Lengths, FSE encoding method 
+ 
+      FSE encoding method : 
+      FSE_ENCODING_RAW : uncompressed; no header 
+      FSE_ENCODING_RLE : single repeated value; header 1 byte 
+      FSE_ENCODING_STATIC : use prepared table; no header 
+      FSE_ENCODING_DYNAMIC : read NCount 
+*/ 
+ 
+size_t ZSTD_noCompressBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    BYTE* const ostart = (BYTE* const)dst; 
+ 
+    if (srcSize + ZSTD_blockHeaderSize > dstCapacity) return ERROR(dstSize_tooSmall); 
+    memcpy(ostart + ZSTD_blockHeaderSize, src, srcSize); 
+ 
+    /* Build header */ 
+    ostart[0]  = (BYTE)(srcSize>>16); 
+    ostart[1]  = (BYTE)(srcSize>>8); 
+    ostart[2]  = (BYTE) srcSize; 
+    ostart[0] += (BYTE)(bt_raw<<6);   /* is a raw (uncompressed) block */ 
+ 
+    return ZSTD_blockHeaderSize+srcSize; 
+} 
+ 
+ 
+static size_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    BYTE* const ostart = (BYTE* const)dst; 
+    U32 const flSize = 1 + (srcSize>31) + (srcSize>4095); 
+ 
+    if (srcSize + flSize > dstCapacity) return ERROR(dstSize_tooSmall); 
+ 
+    switch(flSize) 
+    { 
+        case 1: /* 2 - 1 - 5 */ 
+            ostart[0] = (BYTE)((IS_RAW<<6) + (0<<5) + srcSize); 
+            break; 
+        case 2: /* 2 - 2 - 12 */ 
+            ostart[0] = (BYTE)((IS_RAW<<6) + (2<<4) + (srcSize >> 8)); 
+            ostart[1] = (BYTE)srcSize; 
+            break; 
+        default:   /*note : should not be necessary : flSize is within {1,2,3} */ 
+        case 3: /* 2 - 2 - 20 */ 
+            ostart[0] = (BYTE)((IS_RAW<<6) + (3<<4) + (srcSize >> 16)); 
+            ostart[1] = (BYTE)(srcSize>>8); 
+            ostart[2] = (BYTE)srcSize; 
+            break; 
+    } 
+ 
+    memcpy(ostart + flSize, src, srcSize); 
+    return srcSize + flSize; 
+} 
+ 
+static size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    BYTE* const ostart = (BYTE* const)dst; 
+    U32 const flSize = 1 + (srcSize>31) + (srcSize>4095); 
+ 
+    (void)dstCapacity;  /* dstCapacity guaranteed to be >=4, hence large enough */ 
+ 
+    switch(flSize) 
+    { 
+        case 1: /* 2 - 1 - 5 */ 
+            ostart[0] = (BYTE)((IS_RLE<<6) + (0<<5) + srcSize); 
+            break; 
+        case 2: /* 2 - 2 - 12 */ 
+            ostart[0] = (BYTE)((IS_RLE<<6) + (2<<4) + (srcSize >> 8)); 
+            ostart[1] = (BYTE)srcSize; 
+            break; 
+        default:   /*note : should not be necessary : flSize is necessarily within {1,2,3} */ 
+        case 3: /* 2 - 2 - 20 */ 
+            ostart[0] = (BYTE)((IS_RLE<<6) + (3<<4) + (srcSize >> 16)); 
+            ostart[1] = (BYTE)(srcSize>>8); 
+            ostart[2] = (BYTE)srcSize; 
+            break; 
+    } 
+ 
+    ostart[flSize] = *(const BYTE*)src; 
+    return flSize+1; 
+} 
+ 
+ 
+static size_t ZSTD_minGain(size_t srcSize) { return (srcSize >> 6) + 2; } 
+ 
+static size_t ZSTD_compressLiterals (ZSTD_CCtx* zc, 
+                                     void* dst, size_t dstCapacity, 
+                               const void* src, size_t srcSize) 
+{ 
+    size_t const minGain = ZSTD_minGain(srcSize); 
+    size_t const lhSize = 3 + (srcSize >= 1 KB) + (srcSize >= 16 KB); 
+    BYTE* const ostart = (BYTE*)dst; 
+    U32 singleStream = srcSize < 256; 
+    U32 hType = IS_HUF; 
+    size_t cLitSize; 
+ 
+ 
+    /* small ? don't even attempt compression (speed opt) */ 
+#   define LITERAL_NOENTROPY 63 
+    {   size_t const minLitSize = zc->flagStaticTables ? 6 : LITERAL_NOENTROPY; 
+        if (srcSize <= minLitSize) return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize); 
+    } 
+ 
+    if (dstCapacity < lhSize+1) return ERROR(dstSize_tooSmall);   /* not enough space for compression */ 
+    if (zc->flagStaticTables && (lhSize==3)) { 
+        hType = IS_PCH; 
+        singleStream = 1; 
+        cLitSize = HUF_compress1X_usingCTable(ostart+lhSize, dstCapacity-lhSize, src, srcSize, zc->hufTable); 
+    } else { 
+        cLitSize = singleStream ? HUF_compress1X(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 12) 
+                                : HUF_compress2 (ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 12); 
+    } 
+ 
+    if ((cLitSize==0) || (cLitSize >= srcSize - minGain)) 
+        return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize); 
+    if (cLitSize==1) 
+        return ZSTD_compressRleLiteralsBlock(dst, dstCapacity, src, srcSize); 
+ 
+    /* Build header */ 
+    switch(lhSize) 
+    { 
+    case 3: /* 2 - 2 - 10 - 10 */ 
+        ostart[0] = (BYTE)((srcSize>>6) + (singleStream << 4) + (hType<<6)); 
+        ostart[1] = (BYTE)((srcSize<<2) + (cLitSize>>8)); 
+        ostart[2] = (BYTE)(cLitSize); 
+        break; 
+    case 4: /* 2 - 2 - 14 - 14 */ 
+        ostart[0] = (BYTE)((srcSize>>10) + (2<<4) +  (hType<<6)); 
+        ostart[1] = (BYTE)(srcSize>> 2); 
+        ostart[2] = (BYTE)((srcSize<<6) + (cLitSize>>8)); 
+        ostart[3] = (BYTE)(cLitSize); 
+        break; 
+    default:   /* should not be necessary, lhSize is only {3,4,5} */ 
+    case 5: /* 2 - 2 - 18 - 18 */ 
+        ostart[0] = (BYTE)((srcSize>>14) + (3<<4) +  (hType<<6)); 
+        ostart[1] = (BYTE)(srcSize>>6); 
+        ostart[2] = (BYTE)((srcSize<<2) + (cLitSize>>16)); 
+        ostart[3] = (BYTE)(cLitSize>>8); 
+        ostart[4] = (BYTE)(cLitSize); 
+        break; 
+    } 
+    return lhSize+cLitSize; 
+} 
+ 
+ 
+void ZSTD_seqToCodes(const seqStore_t* seqStorePtr, size_t const nbSeq) 
+{ 
+    /* LL codes */ 
+    {   static const BYTE LL_Code[64] = {  0,  1,  2,  3,  4,  5,  6,  7, 
+                                           8,  9, 10, 11, 12, 13, 14, 15, 
+                                          16, 16, 17, 17, 18, 18, 19, 19, 
+                                          20, 20, 20, 20, 21, 21, 21, 21, 
+                                          22, 22, 22, 22, 22, 22, 22, 22, 
+                                          23, 23, 23, 23, 23, 23, 23, 23, 
+                                          24, 24, 24, 24, 24, 24, 24, 24, 
+                                          24, 24, 24, 24, 24, 24, 24, 24 }; 
+        const BYTE LL_deltaCode = 19; 
+        const U16* const llTable = seqStorePtr->litLengthStart; 
+        BYTE* const llCodeTable = seqStorePtr->llCodeStart; 
+        size_t u; 
+        for (u=0; u<nbSeq; u++) { 
+            U32 const  ll = llTable[u]; 
+            llCodeTable[u] = (ll>63) ? (BYTE)ZSTD_highbit(ll) + LL_deltaCode : LL_Code[ll]; 
+        } 
+        if (seqStorePtr->longLengthID==1) 
+            llCodeTable[seqStorePtr->longLengthPos] = MaxLL; 
+    } 
+ 
+    /* Offset codes */ 
+    {   const U32* const offsetTable = seqStorePtr->offsetStart; 
+        BYTE* const ofCodeTable = seqStorePtr->offCodeStart; 
+        size_t u; 
+        for (u=0; u<nbSeq; u++) ofCodeTable[u] = (BYTE)ZSTD_highbit(offsetTable[u]); 
+    } 
+ 
+    /* ML codes */ 
+    {   static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 
+                                          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 
+                                          32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37, 
+                                          38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 
+                                          40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 
+                                          41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 
+                                          42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+                                          42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 }; 
+        const BYTE ML_deltaCode = 36; 
+        const U16* const mlTable = seqStorePtr->matchLengthStart; 
+        BYTE* const mlCodeTable = seqStorePtr->mlCodeStart; 
+        size_t u; 
+        for (u=0; u<nbSeq; u++) { 
+            U32 const ml = mlTable[u]; 
+            mlCodeTable[u] = (ml>127) ? (BYTE)ZSTD_highbit(ml) + ML_deltaCode : ML_Code[ml]; 
+        } 
+        if (seqStorePtr->longLengthID==2) 
+            mlCodeTable[seqStorePtr->longLengthPos] = MaxML; 
+    } 
+} 
+ 
+ 
+size_t ZSTD_compressSequences(ZSTD_CCtx* zc, 
+                              void* dst, size_t dstCapacity, 
+                              size_t srcSize) 
+{ 
+    const seqStore_t* seqStorePtr = &(zc->seqStore); 
+    U32 count[MaxSeq+1]; 
+    S16 norm[MaxSeq+1]; 
+    FSE_CTable* CTable_LitLength = zc->litlengthCTable; 
+    FSE_CTable* CTable_OffsetBits = zc->offcodeCTable; 
+    FSE_CTable* CTable_MatchLength = zc->matchlengthCTable; 
+    U32 LLtype, Offtype, MLtype;   /* compressed, raw or rle */ 
+    U16*  const llTable = seqStorePtr->litLengthStart; 
+    U16*  const mlTable = seqStorePtr->matchLengthStart; 
+    const U32*  const offsetTable = seqStorePtr->offsetStart; 
+    const U32*  const offsetTableEnd = seqStorePtr->offset; 
+    BYTE* const ofCodeTable = seqStorePtr->offCodeStart; 
+    BYTE* const llCodeTable = seqStorePtr->llCodeStart; 
+    BYTE* const mlCodeTable = seqStorePtr->mlCodeStart; 
+    BYTE* const ostart = (BYTE*)dst; 
+    BYTE* const oend = ostart + dstCapacity; 
+    BYTE* op = ostart; 
+    size_t const nbSeq = offsetTableEnd - offsetTable; 
+    BYTE* seqHead; 
+ 
+    /* Compress literals */ 
+    {   const BYTE* const literals = seqStorePtr->litStart; 
+        size_t const litSize = seqStorePtr->lit - literals; 
+        size_t const cSize = ZSTD_compressLiterals(zc, op, dstCapacity, literals, litSize); 
+        if (ZSTD_isError(cSize)) return cSize; 
+        op += cSize; 
+    } 
+ 
+    /* Sequences Header */ 
+    if ((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead */) return ERROR(dstSize_tooSmall); 
+    if (nbSeq < 0x7F) *op++ = (BYTE)nbSeq; 
+    else if (nbSeq < LONGNBSEQ) op[0] = (BYTE)((nbSeq>>8) + 0x80), op[1] = (BYTE)nbSeq, op+=2; 
+    else op[0]=0xFF, MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ)), op+=3; 
+    if (nbSeq==0) goto _check_compressibility; 
+ 
+    /* seqHead : flags for FSE encoding type */ 
+    seqHead = op++; 
+ 
+#define MIN_SEQ_FOR_DYNAMIC_FSE   64 
+#define MAX_SEQ_FOR_STATIC_FSE  1000 
+ 
+    /* convert length/distances into codes */ 
+    ZSTD_seqToCodes(seqStorePtr, nbSeq); 
+ 
+    /* CTable for Literal Lengths */ 
+    {   U32 max = MaxLL; 
+        size_t const mostFrequent = FSE_countFast(count, &max, llCodeTable, nbSeq); 
+        if ((mostFrequent == nbSeq) && (nbSeq > 2)) { 
+            *op++ = llCodeTable[0]; 
+            FSE_buildCTable_rle(CTable_LitLength, (BYTE)max); 
+            LLtype = FSE_ENCODING_RLE; 
+        } else if ((zc->flagStaticTables) && (nbSeq < MAX_SEQ_FOR_STATIC_FSE)) { 
+            LLtype = FSE_ENCODING_STATIC; 
+        } else if ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (LL_defaultNormLog-1)))) { 
+            FSE_buildCTable(CTable_LitLength, LL_defaultNorm, MaxLL, LL_defaultNormLog); 
+            LLtype = FSE_ENCODING_RAW; 
+        } else { 
+            size_t nbSeq_1 = nbSeq; 
+            const U32 tableLog = FSE_optimalTableLog(LLFSELog, nbSeq, max); 
+            if (count[llCodeTable[nbSeq-1]]>1) { count[llCodeTable[nbSeq-1]]--; nbSeq_1--; } 
+            FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max); 
+            { size_t const NCountSize = FSE_writeNCount(op, oend-op, norm, max, tableLog);   /* overflow protected */ 
+              if (FSE_isError(NCountSize)) return ERROR(GENERIC); 
+              op += NCountSize; } 
+            FSE_buildCTable(CTable_LitLength, norm, max, tableLog); 
+            LLtype = FSE_ENCODING_DYNAMIC; 
+    }   } 
+ 
+    /* CTable for Offsets */ 
+    {   U32 max = MaxOff; 
+        size_t const mostFrequent = FSE_countFast(count, &max, ofCodeTable, nbSeq); 
+        if ((mostFrequent == nbSeq) && (nbSeq > 2)) { 
+            *op++ = ofCodeTable[0]; 
+            FSE_buildCTable_rle(CTable_OffsetBits, (BYTE)max); 
+            Offtype = FSE_ENCODING_RLE; 
+        } else if ((zc->flagStaticTables) && (nbSeq < MAX_SEQ_FOR_STATIC_FSE)) { 
+            Offtype = FSE_ENCODING_STATIC; 
+        } else if ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (OF_defaultNormLog-1)))) { 
+            FSE_buildCTable(CTable_OffsetBits, OF_defaultNorm, MaxOff, OF_defaultNormLog); 
+            Offtype = FSE_ENCODING_RAW; 
+        } else { 
+            size_t nbSeq_1 = nbSeq; 
+            const U32 tableLog = FSE_optimalTableLog(OffFSELog, nbSeq, max); 
+            if (count[ofCodeTable[nbSeq-1]]>1) { count[ofCodeTable[nbSeq-1]]--; nbSeq_1--; } 
+            FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max); 
+            { size_t const NCountSize = FSE_writeNCount(op, oend-op, norm, max, tableLog);   /* overflow protected */ 
+              if (FSE_isError(NCountSize)) return ERROR(GENERIC); 
+              op += NCountSize; } 
+            FSE_buildCTable(CTable_OffsetBits, norm, max, tableLog); 
+            Offtype = FSE_ENCODING_DYNAMIC; 
+    }   } 
+ 
+    /* CTable for MatchLengths */ 
+    {   U32 max = MaxML; 
+        size_t const mostFrequent = FSE_countFast(count, &max, mlCodeTable, nbSeq); 
+        if ((mostFrequent == nbSeq) && (nbSeq > 2)) { 
+            *op++ = *mlCodeTable; 
+            FSE_buildCTable_rle(CTable_MatchLength, (BYTE)max); 
+            MLtype = FSE_ENCODING_RLE; 
+        } else if ((zc->flagStaticTables) && (nbSeq < MAX_SEQ_FOR_STATIC_FSE)) { 
+            MLtype = FSE_ENCODING_STATIC; 
+        } else if ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (ML_defaultNormLog-1)))) { 
+            FSE_buildCTable(CTable_MatchLength, ML_defaultNorm, MaxML, ML_defaultNormLog); 
+            MLtype = FSE_ENCODING_RAW; 
+        } else { 
+            size_t nbSeq_1 = nbSeq; 
+            const U32 tableLog = FSE_optimalTableLog(MLFSELog, nbSeq, max); 
+            if (count[mlCodeTable[nbSeq-1]]>1) { count[mlCodeTable[nbSeq-1]]--; nbSeq_1--; } 
+            FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max); 
+            { size_t const NCountSize = FSE_writeNCount(op, oend-op, norm, max, tableLog);   /* overflow protected */ 
+              if (FSE_isError(NCountSize)) return ERROR(GENERIC); 
+              op += NCountSize; } 
+            FSE_buildCTable(CTable_MatchLength, norm, max, tableLog); 
+            MLtype = FSE_ENCODING_DYNAMIC; 
+    }   } 
+ 
+    *seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2)); 
+    zc->flagStaticTables = 0; 
+ 
+    /* Encoding Sequences */ 
+    {   BIT_CStream_t blockStream; 
+        FSE_CState_t  stateMatchLength; 
+        FSE_CState_t  stateOffsetBits; 
+        FSE_CState_t  stateLitLength; 
+ 
+        { size_t const errorCode = BIT_initCStream(&blockStream, op, oend-op); 
+          if (ERR_isError(errorCode)) return ERROR(dstSize_tooSmall); }   /* not enough space remaining */ 
+ 
+        /* first symbols */ 
+        FSE_initCState2(&stateMatchLength, CTable_MatchLength, mlCodeTable[nbSeq-1]); 
+        FSE_initCState2(&stateOffsetBits,  CTable_OffsetBits,  ofCodeTable[nbSeq-1]); 
+        FSE_initCState2(&stateLitLength,   CTable_LitLength,   llCodeTable[nbSeq-1]); 
+        BIT_addBits(&blockStream, llTable[nbSeq-1], LL_bits[llCodeTable[nbSeq-1]]); 
+        if (MEM_32bits()) BIT_flushBits(&blockStream); 
+        BIT_addBits(&blockStream, mlTable[nbSeq-1], ML_bits[mlCodeTable[nbSeq-1]]); 
+        if (MEM_32bits()) BIT_flushBits(&blockStream); 
+        BIT_addBits(&blockStream, offsetTable[nbSeq-1], ofCodeTable[nbSeq-1]); 
+        BIT_flushBits(&blockStream); 
+ 
+        {   size_t n; 
+            for (n=nbSeq-2 ; n<nbSeq ; n--) {      /* intentional underflow */ 
+                const BYTE ofCode = ofCodeTable[n]; 
+                const BYTE mlCode = mlCodeTable[n]; 
+                const BYTE llCode = llCodeTable[n]; 
+                const U32  llBits = LL_bits[llCode]; 
+                const U32  mlBits = ML_bits[mlCode]; 
+                const U32  ofBits = ofCode;                                     /* 32b*/  /* 64b*/ 
+                                                                                /* (7)*/  /* (7)*/ 
+                FSE_encodeSymbol(&blockStream, &stateOffsetBits, ofCode);       /* 15 */  /* 15 */ 
+                FSE_encodeSymbol(&blockStream, &stateMatchLength, mlCode);      /* 24 */  /* 24 */ 
+                if (MEM_32bits()) BIT_flushBits(&blockStream);                  /* (7)*/ 
+                FSE_encodeSymbol(&blockStream, &stateLitLength, llCode);        /* 16 */  /* 33 */ 
+                if (MEM_32bits() || (ofBits+mlBits+llBits >= 64-7-(LLFSELog+MLFSELog+OffFSELog))) 
+                    BIT_flushBits(&blockStream);                                /* (7)*/ 
+                BIT_addBits(&blockStream, llTable[n], llBits); 
+                if (MEM_32bits() && ((llBits+mlBits)>24)) BIT_flushBits(&blockStream); 
+                BIT_addBits(&blockStream, mlTable[n], mlBits); 
+                if (MEM_32bits()) BIT_flushBits(&blockStream);                  /* (7)*/ 
+                BIT_addBits(&blockStream, offsetTable[n], ofBits);              /* 31 */ 
+                BIT_flushBits(&blockStream);                                    /* (7)*/ 
+        }   } 
+ 
+        FSE_flushCState(&blockStream, &stateMatchLength); 
+        FSE_flushCState(&blockStream, &stateOffsetBits); 
+        FSE_flushCState(&blockStream, &stateLitLength); 
+ 
+        {   size_t const streamSize = BIT_closeCStream(&blockStream); 
+            if (streamSize==0) return ERROR(dstSize_tooSmall);   /* not enough space */ 
+            op += streamSize; 
+    }   } 
+ 
+    /* check compressibility */ 
+_check_compressibility: 
+    { size_t const minGain = ZSTD_minGain(srcSize); 
+      size_t const maxCSize = srcSize - minGain; 
+      if ((size_t)(op-ostart) >= maxCSize) return 0; } 
+ 
+    return op - ostart; 
+} 
+ 
+ 
+/*! ZSTD_storeSeq() : 
+    Store a sequence (literal length, literals, offset code and match length code) into seqStore_t. 
+    `offsetCode` : distance to match, or 0 == repCode. 
+    `matchCode` : matchLength - MINMATCH 
+*/ 
+MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const BYTE* literals, size_t offsetCode, size_t matchCode) 
+{ 
+#if 0  /* for debug */ 
+    static const BYTE* g_start = NULL; 
+    const U32 pos = (U32)(literals - g_start); 
+    if (g_start==NULL) g_start = literals; 
     if ((pos > 2587900) && (pos < 2588050))
-        printf("Cpos %6u :%5u literals & match %3u bytes at distance %6u \n",
-               pos, (U32)litLength, (U32)matchCode+MINMATCH, (U32)offsetCode);
-#endif
-    ZSTD_statsUpdatePrices(&seqStorePtr->stats, litLength, literals, offsetCode, matchCode);
-
-    /* copy Literals */
-    ZSTD_wildcopy(seqStorePtr->lit, literals, litLength);
-    seqStorePtr->lit += litLength;
-
-    /* literal Length */
-    if (litLength>0xFFFF) { seqStorePtr->longLengthID = 1; seqStorePtr->longLengthPos = (U32)(seqStorePtr->litLength - seqStorePtr->litLengthStart); }
-    *seqStorePtr->litLength++ = (U16)litLength;
-
-    /* match offset */
-    *(seqStorePtr->offset++) = (U32)offsetCode + 1;
-
-    /* match Length */
-    if (matchCode>0xFFFF) { seqStorePtr->longLengthID = 2; seqStorePtr->longLengthPos = (U32)(seqStorePtr->matchLength - seqStorePtr->matchLengthStart); }
-    *seqStorePtr->matchLength++ = (U16)matchCode;
-}
-
-
-/*-*************************************
-*  Match length counter
-***************************************/
-static unsigned ZSTD_NbCommonBytes (register size_t val)
-{
-    if (MEM_isLittleEndian()) {
-        if (MEM_64bits()) {
-#       if defined(_MSC_VER) && defined(_WIN64)
-            unsigned long r = 0;
-            _BitScanForward64( &r, (U64)val );
-            return (unsigned)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3)
-            return (__builtin_ctzll((U64)val) >> 3);
-#       else
-            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 };
-            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];
-#       endif
-        } else { /* 32 bits */
-#       if defined(_MSC_VER)
-            unsigned long r=0;
-            _BitScanForward( &r, (U32)val );
-            return (unsigned)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3)
-            return (__builtin_ctz((U32)val) >> 3);
-#       else
-            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 };
-            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
-#       endif
-        }
-    } else {  /* Big Endian CPU */
-        if (MEM_64bits()) {
-#       if defined(_MSC_VER) && defined(_WIN64)
-            unsigned long r = 0;
-            _BitScanReverse64( &r, val );
-            return (unsigned)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3)
-            return (__builtin_clzll(val) >> 3);
-#       else
-            unsigned r;
-            const unsigned n32 = sizeof(size_t)*4;   /* calculate this way due to compiler complaining in 32-bits mode */
-            if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; }
-            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
-            r += (!val);
-            return r;
-#       endif
-        } else { /* 32 bits */
-#       if defined(_MSC_VER)
-            unsigned long r = 0;
-            _BitScanReverse( &r, (unsigned long)val );
-            return (unsigned)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3)
-            return (__builtin_clz((U32)val) >> 3);
-#       else
-            unsigned r;
-            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
-            r += (!val);
-            return r;
-#       endif
-    }   }
-}
-
-
-static size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
-{
-    const BYTE* const pStart = pIn;
-
-    while ((pIn<pInLimit-(sizeof(size_t)-1))) {
-        size_t diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
-        if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; }
-        pIn += ZSTD_NbCommonBytes(diff);
-        return (size_t)(pIn - pStart);
-    }
-    if (MEM_64bits()) if ((pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; }
-    if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; }
-    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
-    return (size_t)(pIn - pStart);
-}
-
-/** ZSTD_count_2segments() :
-*   can count match length with `ip` & `match` in 2 different segments.
-*   convention : on reaching mEnd, match count continue starting from iStart
-*/
-static size_t ZSTD_count_2segments(const BYTE* ip, const BYTE* match, const BYTE* iEnd, const BYTE* mEnd, const BYTE* iStart)
-{
-    size_t matchLength;
-    const BYTE* vEnd = ip + (mEnd - match);
-    if (vEnd > iEnd) vEnd = iEnd;
-    matchLength = ZSTD_count(ip, match, vEnd);
-    if (match + matchLength == mEnd)
-        matchLength += ZSTD_count(ip+matchLength, iStart, iEnd);
-    return matchLength;
-}
-
-
-/*-*************************************
-*  Hashes
-***************************************/
-static const U32 prime3bytes = 506832829U;
-static U32    ZSTD_hash3(U32 u, U32 h) { return ((u << (32-24)) * prime3bytes)  >> (32-h) ; }
-static size_t ZSTD_hash3Ptr(const void* ptr, U32 h) { return ZSTD_hash3(MEM_readLE32(ptr), h); }
-
-static const U32 prime4bytes = 2654435761U;
-static U32    ZSTD_hash4(U32 u, U32 h) { return (u * prime4bytes) >> (32-h) ; }
-static size_t ZSTD_hash4Ptr(const void* ptr, U32 h) { return ZSTD_hash4(MEM_read32(ptr), h); }
-
-static const U64 prime5bytes = 889523592379ULL;
-static size_t ZSTD_hash5(U64 u, U32 h) { return (size_t)(((u  << (64-40)) * prime5bytes) >> (64-h)) ; }
-static size_t ZSTD_hash5Ptr(const void* p, U32 h) { return ZSTD_hash5(MEM_readLE64(p), h); }
-
-static const U64 prime6bytes = 227718039650203ULL;
-static size_t ZSTD_hash6(U64 u, U32 h) { return (size_t)(((u  << (64-48)) * prime6bytes) >> (64-h)) ; }
-static size_t ZSTD_hash6Ptr(const void* p, U32 h) { return ZSTD_hash6(MEM_readLE64(p), h); }
-
-static const U64 prime7bytes = 58295818150454627ULL;
-static size_t ZSTD_hash7(U64 u, U32 h) { return (size_t)(((u  << (64-56)) * prime7bytes) >> (64-h)) ; }
-static size_t ZSTD_hash7Ptr(const void* p, U32 h) { return ZSTD_hash7(MEM_readLE64(p), h); }
-
-static size_t ZSTD_hashPtr(const void* p, U32 hBits, U32 mls)
-{
-    switch(mls)
-    {
-    default:
-    case 4: return ZSTD_hash4Ptr(p, hBits);
-    case 5: return ZSTD_hash5Ptr(p, hBits);
-    case 6: return ZSTD_hash6Ptr(p, hBits);
-    case 7: return ZSTD_hash7Ptr(p, hBits);
-    }
-}
-
-
-/*-*************************************
-*  Fast Scan
-***************************************/
-static void ZSTD_fillHashTable (ZSTD_CCtx* zc, const void* end, const U32 mls)
-{
-    U32* const hashTable = zc->hashTable;
-    const U32 hBits = zc->params.cParams.hashLog;
-    const BYTE* const base = zc->base;
-    const BYTE* ip = base + zc->nextToUpdate;
-    const BYTE* const iend = ((const BYTE*)end) - 8;
-    const size_t fastHashFillStep = 3;
-
-    while(ip <= iend) {
-        hashTable[ZSTD_hashPtr(ip, hBits, mls)] = (U32)(ip - base);
-        ip += fastHashFillStep;
-    }
-}
-
-
-FORCE_INLINE
-void ZSTD_compressBlock_fast_generic(ZSTD_CCtx* zc,
-                                 const void* src, size_t srcSize,
-                                 const U32 mls)
-{
-    U32* const hashTable = zc->hashTable;
-    const U32 hBits = zc->params.cParams.hashLog;
-    seqStore_t* seqStorePtr = &(zc->seqStore);
-    const BYTE* const base = zc->base;
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const U32 lowIndex = zc->dictLimit;
-    const BYTE* const lowest = base + lowIndex;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - 8;
-    size_t offset_2=REPCODE_STARTVALUE, offset_1=REPCODE_STARTVALUE;
-
-    /* init */
-    ZSTD_resetSeqStore(seqStorePtr);
-    if (ip < lowest+REPCODE_STARTVALUE) ip = lowest+REPCODE_STARTVALUE;
-
-    /* Main Search Loop */
-    while (ip < ilimit) {  /* < instead of <=, because repcode check at (ip+1) */
-        size_t mlCode;
-        size_t offset;
-        const size_t h = ZSTD_hashPtr(ip, hBits, mls);
-        const U32 matchIndex = hashTable[h];
-        const BYTE* match = base + matchIndex;
-        const U32 current = (U32)(ip-base);
-        hashTable[h] = current;   /* update hash table */
-
-        if (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1)) {   /* note : by construction, offset_1 <= current */
-            mlCode = ZSTD_count(ip+1+EQUAL_READ32, ip+1+EQUAL_READ32-offset_1, iend) + EQUAL_READ32;
-            ip++;
-            ZSTD_storeSeq(seqStorePtr, ip-anchor, anchor, 0, mlCode-MINMATCH);
-       } else {
-            if ( (matchIndex <= lowIndex) ||
-                 (MEM_read32(match) != MEM_read32(ip)) ) {
-                ip += ((ip-anchor) >> g_searchStrength) + 1;
-                continue;
-            }
-            mlCode = ZSTD_count(ip+EQUAL_READ32, match+EQUAL_READ32, iend) + EQUAL_READ32;
-            offset = ip-match;
-            while ((ip>anchor) && (match>lowest) && (ip[-1] == match[-1])) { ip--; match--; mlCode++; }  /* catch up */
-            offset_2 = offset_1;
-            offset_1 = offset;
-
-            ZSTD_storeSeq(seqStorePtr, ip-anchor, anchor, offset + ZSTD_REP_MOVE, mlCode-MINMATCH);
-        }
-
-        /* match found */
-        ip += mlCode;
-        anchor = ip;
-
-        if (ip <= ilimit) {
-            /* Fill Table */
-            hashTable[ZSTD_hashPtr(base+current+2, hBits, mls)] = current+2;  /* here because current+2 could be > iend-8 */
-            hashTable[ZSTD_hashPtr(ip-2, hBits, mls)] = (U32)(ip-2-base);
-            /* check immediate repcode */
-            while ( (ip <= ilimit)
-                 && (MEM_read32(ip) == MEM_read32(ip - offset_2)) ) {
-                /* store sequence */
-                size_t const rlCode = ZSTD_count(ip+EQUAL_READ32, ip+EQUAL_READ32-offset_2, iend) + EQUAL_READ32;
-                { size_t const tmpOff = offset_2; offset_2 = offset_1; offset_1 = tmpOff; } /* swap offset_2 <=> offset_1 */
-                hashTable[ZSTD_hashPtr(ip, hBits, mls)] = (U32)(ip-base);
-                ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, rlCode-MINMATCH);
-                ip += rlCode;
-                anchor = ip;
-                continue;   /* faster when present ... (?) */
-    }   }   }
-
-    /* Last Literals */
-    {   size_t const lastLLSize = iend - anchor;
-        memcpy(seqStorePtr->lit, anchor, lastLLSize);
-        seqStorePtr->lit += lastLLSize;
-    }
-}
-
-
-static void ZSTD_compressBlock_fast(ZSTD_CCtx* ctx,
-                       const void* src, size_t srcSize)
-{
-    const U32 mls = ctx->params.cParams.searchLength;
-    switch(mls)
-    {
-    default:
-    case 4 :
-        ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 4); return;
-    case 5 :
-        ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 5); return;
-    case 6 :
-        ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 6); return;
-    case 7 :
-        ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 7); return;
-    }
-}
-
-
-static void ZSTD_compressBlock_fast_extDict_generic(ZSTD_CCtx* ctx,
-                                 const void* src, size_t srcSize,
-                                 const U32 mls)
-{
-    U32* hashTable = ctx->hashTable;
-    const U32 hBits = ctx->params.cParams.hashLog;
-    seqStore_t* seqStorePtr = &(ctx->seqStore);
-    const BYTE* const base = ctx->base;
-    const BYTE* const dictBase = ctx->dictBase;
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const U32   lowLimit = ctx->lowLimit;
-    const BYTE* const dictStart = dictBase + lowLimit;
-    const U32   dictLimit = ctx->dictLimit;
-    const BYTE* const lowPrefixPtr = base + dictLimit;
-    const BYTE* const dictEnd = dictBase + dictLimit;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - 8;
-
-    U32 offset_2=REPCODE_STARTVALUE, offset_1=REPCODE_STARTVALUE;
-
-
-    /* init */
-    ZSTD_resetSeqStore(seqStorePtr);
-    /* skip first position to avoid read overflow during repcode match check */
-    hashTable[ZSTD_hashPtr(ip+0, hBits, mls)] = (U32)(ip-base+0);
-    ip += REPCODE_STARTVALUE;
-
-    /* Main Search Loop */
-    while (ip < ilimit) {  /* < instead of <=, because (ip+1) */
-        const size_t h = ZSTD_hashPtr(ip, hBits, mls);
-        const U32 matchIndex = hashTable[h];
-        const BYTE* matchBase = matchIndex < dictLimit ? dictBase : base;
-        const BYTE* match = matchBase + matchIndex;
-        const U32 current = (U32)(ip-base);
-        const U32 repIndex = current + 1 - offset_1;
-        const BYTE* repBase = repIndex < dictLimit ? dictBase : base;
-        const BYTE* repMatch = repBase + repIndex;
-        size_t mlCode;
-        U32 offset;
-        hashTable[h] = current;   /* update hash table */
-
-        if ( ((repIndex >= dictLimit) || (repIndex <= dictLimit-4))
-          && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {
-            const BYTE* repMatchEnd = repIndex < dictLimit ? dictEnd : iend;
-            mlCode = ZSTD_count_2segments(ip+1+EQUAL_READ32, repMatch+EQUAL_READ32, iend, repMatchEnd, lowPrefixPtr) + EQUAL_READ32;
-            ip++;
-            ZSTD_storeSeq(seqStorePtr, ip-anchor, anchor, 0, mlCode-MINMATCH);
-        } else {
-            if ( (matchIndex < lowLimit) ||
-                 (MEM_read32(match) != MEM_read32(ip)) ) {
-                ip += ((ip-anchor) >> g_searchStrength) + 1;
-                continue;
-            }
-            {   const BYTE* matchEnd = matchIndex < dictLimit ? dictEnd : iend;
-                const BYTE* lowMatchPtr = matchIndex < dictLimit ? dictStart : lowPrefixPtr;
-                mlCode = ZSTD_count_2segments(ip+EQUAL_READ32, match+EQUAL_READ32, iend, matchEnd, lowPrefixPtr) + EQUAL_READ32;
-                while ((ip>anchor) && (match>lowMatchPtr) && (ip[-1] == match[-1])) { ip--; match--; mlCode++; }   /* catch up */
-                offset = current - matchIndex;
-                offset_2 = offset_1;
-                offset_1 = offset;
-                ZSTD_storeSeq(seqStorePtr, ip-anchor, anchor, offset + ZSTD_REP_MOVE, mlCode-MINMATCH);
-        }   }
-
-        /* found a match : store it */
-        ip += mlCode;
-        anchor = ip;
-
-        if (ip <= ilimit) {
-            /* Fill Table */
-			hashTable[ZSTD_hashPtr(base+current+2, hBits, mls)] = current+2;
-            hashTable[ZSTD_hashPtr(ip-2, hBits, mls)] = (U32)(ip-2-base);
-            /* check immediate repcode */
-            while (ip <= ilimit) {
-                U32 const current2 = (U32)(ip-base);
-                U32 const repIndex2 = current2 - offset_2;
-                const BYTE* repMatch2 = repIndex2 < dictLimit ? dictBase + repIndex2 : base + repIndex2;
-                if ( ((repIndex2 <= dictLimit-4) || (repIndex2 >= dictLimit))
-                  && (MEM_read32(repMatch2) == MEM_read32(ip)) ) {
-                    const BYTE* const repEnd2 = repIndex2 < dictLimit ? dictEnd : iend;
-                    size_t repLength2 = ZSTD_count_2segments(ip+EQUAL_READ32, repMatch2+EQUAL_READ32, iend, repEnd2, lowPrefixPtr) + EQUAL_READ32;
-                    U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */
-                    ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, repLength2-MINMATCH);
-                    hashTable[ZSTD_hashPtr(ip, hBits, mls)] = current2;
-                    ip += repLength2;
-                    anchor = ip;
-                    continue;
-                }
-                break;
-    }   }   }
-
-    /* Last Literals */
-    {   size_t const lastLLSize = iend - anchor;
-        memcpy(seqStorePtr->lit, anchor, lastLLSize);
-        seqStorePtr->lit += lastLLSize;
-    }
-}
-
-
-static void ZSTD_compressBlock_fast_extDict(ZSTD_CCtx* ctx,
-                         const void* src, size_t srcSize)
-{
-    const U32 mls = ctx->params.cParams.searchLength;
-    switch(mls)
-    {
-    default:
-    case 4 :
-        ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 4); return;
-    case 5 :
-        ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 5); return;
-    case 6 :
-        ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 6); return;
-    case 7 :
-        ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 7); return;
-    }
-}
-
-
-
-
-/*-*************************************
-*  Binary Tree search
-***************************************/
-/** ZSTD_insertBt1() : add one or multiple positions to tree.
-*   ip : assumed <= iend-8 .
-*   @return : nb of positions added */
-static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, const BYTE* const iend, U32 nbCompares,
-                          U32 extDict)
-{
-    U32* const hashTable = zc->hashTable;
-    const U32 hashLog = zc->params.cParams.hashLog;
-    const size_t h  = ZSTD_hashPtr(ip, hashLog, mls);
-    U32* const bt   = zc->chainTable;
-    const U32 btLog = zc->params.cParams.chainLog - 1;
-    const U32 btMask= (1 << btLog) - 1;
-    U32 matchIndex  = hashTable[h];
-    size_t commonLengthSmaller=0, commonLengthLarger=0;
-    const BYTE* const base = zc->base;
-    const BYTE* const dictBase = zc->dictBase;
-    const U32 dictLimit = zc->dictLimit;
-    const BYTE* const dictEnd = dictBase + dictLimit;
-    const BYTE* const prefixStart = base + dictLimit;
-    const BYTE* match = base + matchIndex;
-    const U32 current = (U32)(ip-base);
-    const U32 btLow = btMask >= current ? 0 : current - btMask;
-    U32* smallerPtr = bt + 2*(current&btMask);
-    U32* largerPtr  = smallerPtr + 1;
-    U32 dummy32;   /* to be nullified at the end */
-    const U32 windowLow = zc->lowLimit;
-    U32 matchEndIdx = current+8;
-    size_t bestLength = 8;
-    U32 predictedSmall = *(bt + 2*((current-1)&btMask) + 0);
-    U32 predictedLarge = *(bt + 2*((current-1)&btMask) + 1);
-    predictedSmall += (predictedSmall>0);
-    predictedLarge += (predictedLarge>0);
-
-    hashTable[h] = current;   /* Update Hash Table */
-
-    while (nbCompares-- && (matchIndex > windowLow)) {
-        U32* nextPtr = bt + 2*(matchIndex & btMask);
-        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
-#if 0   /* note : can create issues when hlog small <= 11 */
-        const U32* predictPtr = bt + 2*((matchIndex-1) & btMask);   /* written this way, as bt is a roll buffer */
-        if (matchIndex == predictedSmall) {
-            /* no need to check length, result known */
-            *smallerPtr = matchIndex;
-            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-            smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */
-            matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
-            predictedSmall = predictPtr[1] + (predictPtr[1]>0);
-            continue;
-        }
-        if (matchIndex == predictedLarge) {
-            *largerPtr = matchIndex;
-            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-            largerPtr = nextPtr;
-            matchIndex = nextPtr[0];
-            predictedLarge = predictPtr[0] + (predictPtr[0]>0);
-            continue;
-        }
-#endif
-        if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
-            match = base + matchIndex;
-            if (match[matchLength] == ip[matchLength])
-                matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iend) +1;
-        } else {
-            match = dictBase + matchIndex;
-            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
-            if (matchIndex+matchLength >= dictLimit)
-				match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */
-        }
-
-        if (matchLength > bestLength) {
-            bestLength = matchLength;
-            if (matchLength > matchEndIdx - matchIndex)
-                matchEndIdx = matchIndex + (U32)matchLength;
-        }
-
-        if (ip+matchLength == iend)   /* equal : no way to know if inf or sup */
-            break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt the tree */
-
-        if (match[matchLength] < ip[matchLength]) {  /* necessarily within correct buffer */
-            /* match is smaller than current */
-            *smallerPtr = matchIndex;             /* update smaller idx */
-            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
-            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-            smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */
-            matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
-        } else {
-            /* match is larger than current */
-            *largerPtr = matchIndex;
-            commonLengthLarger = matchLength;
-            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-            largerPtr = nextPtr;
-            matchIndex = nextPtr[0];
-    }   }
-
-    *smallerPtr = *largerPtr = 0;
-    if (bestLength > 384) return MIN(192, (U32)(bestLength - 384));
-    if (matchEndIdx > current + 8) return matchEndIdx - current - 8;
-    return 1;
-}
-
-
-static size_t ZSTD_insertBtAndFindBestMatch (
-                        ZSTD_CCtx* zc,
-                        const BYTE* const ip, const BYTE* const iend,
-                        size_t* offsetPtr,
-                        U32 nbCompares, const U32 mls,
-                        U32 extDict)
-{
-    U32* const hashTable = zc->hashTable;
-    const U32 hashLog = zc->params.cParams.hashLog;
-    const size_t h  = ZSTD_hashPtr(ip, hashLog, mls);
-    U32* const bt   = zc->chainTable;
-    const U32 btLog = zc->params.cParams.chainLog - 1;
-    const U32 btMask= (1 << btLog) - 1;
-    U32 matchIndex  = hashTable[h];
-    size_t commonLengthSmaller=0, commonLengthLarger=0;
-    const BYTE* const base = zc->base;
-    const BYTE* const dictBase = zc->dictBase;
-    const U32 dictLimit = zc->dictLimit;
-    const BYTE* const dictEnd = dictBase + dictLimit;
-    const BYTE* const prefixStart = base + dictLimit;
-    const U32 current = (U32)(ip-base);
-    const U32 btLow = btMask >= current ? 0 : current - btMask;
-    const U32 windowLow = zc->lowLimit;
-    U32* smallerPtr = bt + 2*(current&btMask);
-    U32* largerPtr  = bt + 2*(current&btMask) + 1;
-    U32 matchEndIdx = current+8;
-    U32 dummy32;   /* to be nullified at the end */
-    size_t bestLength = 0;
-
-    hashTable[h] = current;   /* Update Hash Table */
-
-    while (nbCompares-- && (matchIndex > windowLow)) {
-        U32* nextPtr = bt + 2*(matchIndex & btMask);
-        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
-        const BYTE* match;
-
-        if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
-            match = base + matchIndex;
-            if (match[matchLength] == ip[matchLength])
-                matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iend) +1;
-        } else {
-            match = dictBase + matchIndex;
-            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);
-            if (matchIndex+matchLength >= dictLimit)
-				match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */
-        }
-
-        if (matchLength > bestLength) {
-            if (matchLength > matchEndIdx - matchIndex)
-                matchEndIdx = matchIndex + (U32)matchLength;
-            if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit(current-matchIndex+1) - ZSTD_highbit((U32)offsetPtr[0]+1)) )
-                bestLength = matchLength, *offsetPtr = ZSTD_REP_MOVE + current - matchIndex;
-            if (ip+matchLength == iend)   /* equal : no way to know if inf or sup */
-                break;   /* drop, to guarantee consistency (miss a little bit of compression) */
-        }
-
-        if (match[matchLength] < ip[matchLength]) {
-            /* match is smaller than current */
-            *smallerPtr = matchIndex;             /* update smaller idx */
-            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
-            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-            smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */
-            matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
-        } else {
-            /* match is larger than current */
-            *largerPtr = matchIndex;
-            commonLengthLarger = matchLength;
-            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-            largerPtr = nextPtr;
-            matchIndex = nextPtr[0];
-    }   }
-
-    *smallerPtr = *largerPtr = 0;
-
-    zc->nextToUpdate = (matchEndIdx > current + 8) ? matchEndIdx - 8 : current+1;
-    return bestLength;
-}
-
-
-static void ZSTD_updateTree(ZSTD_CCtx* zc, const BYTE* const ip, const BYTE* const iend, const U32 nbCompares, const U32 mls)
-{
-    const BYTE* const base = zc->base;
-    const U32 target = (U32)(ip - base);
-    U32 idx = zc->nextToUpdate;
-
-    while(idx < target)
-        idx += ZSTD_insertBt1(zc, base+idx, mls, iend, nbCompares, 0);
-}
-
-/** ZSTD_BtFindBestMatch() : Tree updater, providing best match */
-static size_t ZSTD_BtFindBestMatch (
-                        ZSTD_CCtx* zc,
-                        const BYTE* const ip, const BYTE* const iLimit,
-                        size_t* offsetPtr,
-                        const U32 maxNbAttempts, const U32 mls)
-{
-    if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
-    ZSTD_updateTree(zc, ip, iLimit, maxNbAttempts, mls);
-    return ZSTD_insertBtAndFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, mls, 0);
-}
-
-
-static size_t ZSTD_BtFindBestMatch_selectMLS (
-                        ZSTD_CCtx* zc,   /* Index table will be updated */
-                        const BYTE* ip, const BYTE* const iLimit,
-                        size_t* offsetPtr,
-                        const U32 maxNbAttempts, const U32 matchLengthSearch)
-{
-    switch(matchLengthSearch)
-    {
-    default :
-    case 4 : return ZSTD_BtFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, 4);
-    case 5 : return ZSTD_BtFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, 5);
-    case 6 : return ZSTD_BtFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, 6);
-    }
-}
-
-
-static void ZSTD_updateTree_extDict(ZSTD_CCtx* zc, const BYTE* const ip, const BYTE* const iend, const U32 nbCompares, const U32 mls)
-{
-    const BYTE* const base = zc->base;
-    const U32 target = (U32)(ip - base);
-    U32 idx = zc->nextToUpdate;
-
-    while (idx < target) idx += ZSTD_insertBt1(zc, base+idx, mls, iend, nbCompares, 1);
-}
-
-
-
-/** Tree updater, providing best match */
-static size_t ZSTD_BtFindBestMatch_extDict (
-                        ZSTD_CCtx* zc,
-                        const BYTE* const ip, const BYTE* const iLimit,
-                        size_t* offsetPtr,
-                        const U32 maxNbAttempts, const U32 mls)
-{
-    if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
-    ZSTD_updateTree_extDict(zc, ip, iLimit, maxNbAttempts, mls);
-    return ZSTD_insertBtAndFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, mls, 1);
-}
-
-
-static size_t ZSTD_BtFindBestMatch_selectMLS_extDict (
-                        ZSTD_CCtx* zc,   /* Index table will be updated */
-                        const BYTE* ip, const BYTE* const iLimit,
-                        size_t* offsetPtr,
-                        const U32 maxNbAttempts, const U32 matchLengthSearch)
-{
-    switch(matchLengthSearch)
-    {
-    default :
-    case 4 : return ZSTD_BtFindBestMatch_extDict(zc, ip, iLimit, offsetPtr, maxNbAttempts, 4);
-    case 5 : return ZSTD_BtFindBestMatch_extDict(zc, ip, iLimit, offsetPtr, maxNbAttempts, 5);
-    case 6 : return ZSTD_BtFindBestMatch_extDict(zc, ip, iLimit, offsetPtr, maxNbAttempts, 6);
-    }
-}
-
-
-
-/* ***********************
-*  Hash Chain
-*************************/
-
-#define NEXT_IN_CHAIN(d, mask)   chainTable[(d) & mask]
-
-
-/* Update chains up to ip (excluded)
-   Assumption : always within prefix (ie. not within extDict) */
-FORCE_INLINE
-U32 ZSTD_insertAndFindFirstIndex (ZSTD_CCtx* zc, const BYTE* ip, U32 mls)
-{
-    U32* const hashTable  = zc->hashTable;
-    const U32 hashLog = zc->params.cParams.hashLog;
-    U32* const chainTable = zc->chainTable;
-    const U32 chainMask = (1 << zc->params.cParams.chainLog) - 1;
-    const BYTE* const base = zc->base;
-    const U32 target = (U32)(ip - base);
-    U32 idx = zc->nextToUpdate;
-
-    while(idx < target) {
-        size_t const h = ZSTD_hashPtr(base+idx, hashLog, mls);
-        NEXT_IN_CHAIN(idx, chainMask) = hashTable[h];
-        hashTable[h] = idx;
-        idx++;
-    }
-
-    zc->nextToUpdate = target;
-    return hashTable[ZSTD_hashPtr(ip, hashLog, mls)];
-}
-
-
-
-FORCE_INLINE /* inlining is important to hardwire a hot branch (template emulation) */
-size_t ZSTD_HcFindBestMatch_generic (
-                        ZSTD_CCtx* zc,   /* Index table will be updated */
-                        const BYTE* const ip, const BYTE* const iLimit,
-                        size_t* offsetPtr,
-                        const U32 maxNbAttempts, const U32 mls, const U32 extDict)
-{
-    U32* const chainTable = zc->chainTable;
-    const U32 chainSize = (1 << zc->params.cParams.chainLog);
-    const U32 chainMask = chainSize-1;
-    const BYTE* const base = zc->base;
-    const BYTE* const dictBase = zc->dictBase;
-    const U32 dictLimit = zc->dictLimit;
-    const BYTE* const prefixStart = base + dictLimit;
-    const BYTE* const dictEnd = dictBase + dictLimit;
-    const U32 lowLimit = zc->lowLimit;
-    const U32 current = (U32)(ip-base);
-    const U32 minChain = current > chainSize ? current - chainSize : 0;
-    int nbAttempts=maxNbAttempts;
-    size_t ml=EQUAL_READ32-1;
-
-    /* HC4 match finder */
-    U32 matchIndex = ZSTD_insertAndFindFirstIndex (zc, ip, mls);
-
-    for ( ; (matchIndex>lowLimit) && (nbAttempts) ; nbAttempts--) {
-        const BYTE* match;
-        size_t currentMl=0;
-        if ((!extDict) || matchIndex >= dictLimit) {
-            match = base + matchIndex;
-            if (match[ml] == ip[ml])   /* potentially better */
-                currentMl = ZSTD_count(ip, match, iLimit);
-        } else {
-            match = dictBase + matchIndex;
-            if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */
-                currentMl = ZSTD_count_2segments(ip+EQUAL_READ32, match+EQUAL_READ32, iLimit, dictEnd, prefixStart) + EQUAL_READ32;
-        }
-
-        /* save best solution */
-        if (currentMl > ml) { ml = currentMl; *offsetPtr = ZSTD_REP_MOVE + current - matchIndex; if (ip+currentMl == iLimit) break; /* best possible, and avoid read overflow*/ }
-
-        if (matchIndex <= minChain) break;
-        matchIndex = NEXT_IN_CHAIN(matchIndex, chainMask);
-    }
-
-    return ml;
-}
-
-
-FORCE_INLINE size_t ZSTD_HcFindBestMatch_selectMLS (
-                        ZSTD_CCtx* zc,
-                        const BYTE* ip, const BYTE* const iLimit,
-                        size_t* offsetPtr,
-                        const U32 maxNbAttempts, const U32 matchLengthSearch)
-{
-    switch(matchLengthSearch)
-    {
-    default :
-    case 4 : return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 4, 0);
-    case 5 : return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 5, 0);
-    case 6 : return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 6, 0);
-    }
-}
-
-
-FORCE_INLINE size_t ZSTD_HcFindBestMatch_extDict_selectMLS (
-                        ZSTD_CCtx* zc,
-                        const BYTE* ip, const BYTE* const iLimit,
-                        size_t* offsetPtr,
-                        const U32 maxNbAttempts, const U32 matchLengthSearch)
-{
-    switch(matchLengthSearch)
-    {
-    default :
-    case 4 : return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 4, 1);
-    case 5 : return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 5, 1);
-    case 6 : return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 6, 1);
-    }
-}
-
-
-/* *******************************
-*  Common parser - lazy strategy
-*********************************/
-FORCE_INLINE
-void ZSTD_compressBlock_lazy_generic(ZSTD_CCtx* ctx,
-                                     const void* src, size_t srcSize,
-                                     const U32 searchMethod, const U32 depth)
-{
-    seqStore_t* seqStorePtr = &(ctx->seqStore);
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - 8;
-    const BYTE* const base = ctx->base + ctx->dictLimit;
-
-    U32 const maxSearches = 1 << ctx->params.cParams.searchLog;
-    U32 const mls = ctx->params.cParams.searchLength;
-
-    typedef size_t (*searchMax_f)(ZSTD_CCtx* zc, const BYTE* ip, const BYTE* iLimit,
-                        size_t* offsetPtr,
-                        U32 maxNbAttempts, U32 matchLengthSearch);
-    searchMax_f searchMax = searchMethod ? ZSTD_BtFindBestMatch_selectMLS : ZSTD_HcFindBestMatch_selectMLS;
-
-    /* init */
-    U32 rep[ZSTD_REP_INIT];
-    { U32 i ; for (i=0; i<ZSTD_REP_INIT; i++) rep[i]=REPCODE_STARTVALUE; }
-
-    ctx->nextToUpdate3 = ctx->nextToUpdate;
-    ZSTD_resetSeqStore(seqStorePtr);
-    if ((ip-base) < REPCODE_STARTVALUE) ip = base + REPCODE_STARTVALUE;
-
-    /* Match Loop */
-    while (ip < ilimit) {
-        size_t matchLength=0;
-        size_t offset=0;
-        const BYTE* start=ip+1;
-
-        /* check repCode */
-        if (MEM_read32(ip+1) == MEM_read32(ip+1 - rep[0])) {
-            /* repcode : we take it */
-            matchLength = ZSTD_count(ip+1+EQUAL_READ32, ip+1+EQUAL_READ32-rep[0], iend) + EQUAL_READ32;
-            if (depth==0) goto _storeSequence;
-        }
-
-        /* first search (depth 0) */
-        {   size_t offsetFound = 99999999;
-            size_t const ml2 = searchMax(ctx, ip, iend, &offsetFound, maxSearches, mls);
-            if (ml2 > matchLength)
-                matchLength = ml2, start = ip, offset=offsetFound;
-        }
-
-        if (matchLength < EQUAL_READ32) {
-            ip += ((ip-anchor) >> g_searchStrength) + 1;   /* jump faster over incompressible sections */
-            continue;
-        }
-
-        /* let's try to find a better solution */
-        if (depth>=1)
-        while (ip<ilimit) {
-            ip ++;
-            if ((offset) && (MEM_read32(ip) == MEM_read32(ip - rep[0]))) {
-                size_t const mlRep = ZSTD_count(ip+EQUAL_READ32, ip+EQUAL_READ32-rep[0], iend) + EQUAL_READ32;
-                int const gain2 = (int)(mlRep * 3);
-                int const gain1 = (int)(matchLength*3 - ZSTD_highbit((U32)offset+1) + 1);
-                if ((mlRep >= EQUAL_READ32) && (gain2 > gain1))
-                    matchLength = mlRep, offset = 0, start = ip;
-            }
-            {   size_t offset2=99999999;
-                size_t const ml2 = searchMax(ctx, ip, iend, &offset2, maxSearches, mls);
-                int const gain2 = (int)(ml2*4 - ZSTD_highbit((U32)offset2+1));   /* raw approx */
-                int const gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 4);
-                if ((ml2 >= EQUAL_READ32) && (gain2 > gain1)) {
-                    matchLength = ml2, offset = offset2, start = ip;
-                    continue;   /* search a better one */
-            }   }
-
-            /* let's find an even better one */
-            if ((depth==2) && (ip<ilimit)) {
-                ip ++;
-                if ((offset) && (MEM_read32(ip) == MEM_read32(ip - rep[0]))) {
-                    size_t const ml2 = ZSTD_count(ip+EQUAL_READ32, ip+EQUAL_READ32-rep[0], iend) + EQUAL_READ32;
-                    int const gain2 = (int)(ml2 * 4);
-                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 1);
-                    if ((ml2 >= EQUAL_READ32) && (gain2 > gain1))
-                        matchLength = ml2, offset = 0, start = ip;
-                }
-                {   size_t offset2=99999999;
-                    size_t const ml2 = searchMax(ctx, ip, iend, &offset2, maxSearches, mls);
-                    int const gain2 = (int)(ml2*4 - ZSTD_highbit((U32)offset2+1));   /* raw approx */
-                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 7);
-                    if ((ml2 >= EQUAL_READ32) && (gain2 > gain1)) {
-                        matchLength = ml2, offset = offset2, start = ip;
-                        continue;
-            }   }   }
-            break;  /* nothing found : store previous solution */
-        }
-
-        /* catch up */
-        if (offset) {
-            while ((start>anchor) && (start>base+offset-ZSTD_REP_MOVE) && (start[-1] == start[-1-offset+ZSTD_REP_MOVE]))   /* only search for offset within prefix */
-                { start--; matchLength++; }
-            rep[1] = rep[0]; rep[0] = (U32)(offset - ZSTD_REP_MOVE);
-        }
-
-        /* store sequence */
-_storeSequence:
-        {   size_t const litLength = start - anchor;
-            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, matchLength-MINMATCH);
-            anchor = ip = start + matchLength;
-        }
-
-        /* check immediate repcode */
-        while ( (ip <= ilimit)
-             && (MEM_read32(ip) == MEM_read32(ip - rep[1])) ) {
-            /* store sequence */
-            matchLength = ZSTD_count(ip+EQUAL_READ32, ip+EQUAL_READ32-rep[1], iend) + EQUAL_READ32;
-            offset = rep[1]; rep[1] = rep[0]; rep[0] = (U32)offset; /* swap repcodes */
-            ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, matchLength-MINMATCH);
-            ip += matchLength;
-            anchor = ip;
-            continue;   /* faster when present ... (?) */
-    }   }
-
-    /* Last Literals */
-    {   size_t const lastLLSize = iend - anchor;
-        memcpy(seqStorePtr->lit, anchor, lastLLSize);
-        seqStorePtr->lit += lastLLSize;
-        ZSTD_statsUpdatePrices(&seqStorePtr->stats, lastLLSize, anchor, 0, 0);
-    }
-}
-
-
-static void ZSTD_compressBlock_btlazy2(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
-{
-    ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 1, 2);
-}
-
-static void ZSTD_compressBlock_lazy2(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
-{
-    ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 0, 2);
-}
-
-static void ZSTD_compressBlock_lazy(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
-{
-    ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 0, 1);
-}
-
-static void ZSTD_compressBlock_greedy(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
-{
-    ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 0, 0);
-}
-
-
-FORCE_INLINE
-void ZSTD_compressBlock_lazy_extDict_generic(ZSTD_CCtx* ctx,
-                                     const void* src, size_t srcSize,
-                                     const U32 searchMethod, const U32 depth)
-{
-    seqStore_t* seqStorePtr = &(ctx->seqStore);
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - 8;
-    const BYTE* const base = ctx->base;
-    const U32 dictLimit = ctx->dictLimit;
-    const BYTE* const prefixStart = base + dictLimit;
-    const BYTE* const dictBase = ctx->dictBase;
-    const BYTE* const dictEnd  = dictBase + dictLimit;
-    const BYTE* const dictStart  = dictBase + ctx->lowLimit;
-
-    const U32 maxSearches = 1 << ctx->params.cParams.searchLog;
-    const U32 mls = ctx->params.cParams.searchLength;
-
-    typedef size_t (*searchMax_f)(ZSTD_CCtx* zc, const BYTE* ip, const BYTE* iLimit,
-                        size_t* offsetPtr,
-                        U32 maxNbAttempts, U32 matchLengthSearch);
-    searchMax_f searchMax = searchMethod ? ZSTD_BtFindBestMatch_selectMLS_extDict : ZSTD_HcFindBestMatch_extDict_selectMLS;
-
-    /* init */
-    U32 rep[ZSTD_REP_INIT];
-    { U32 i; for (i=0; i<ZSTD_REP_INIT; i++) rep[i]=REPCODE_STARTVALUE; }
-
-    ctx->nextToUpdate3 = ctx->nextToUpdate;
-    ZSTD_resetSeqStore(seqStorePtr);
-    if ((ip - prefixStart) < REPCODE_STARTVALUE) ip += REPCODE_STARTVALUE;
-
-    /* Match Loop */
-    while (ip < ilimit) {
-        size_t matchLength=0;
-        size_t offset=0;
-        const BYTE* start=ip+1;
-        U32 current = (U32)(ip-base);
-
-        /* check repCode */
-        {
-            const U32 repIndex = (U32)(current+1 - rep[0]);
-            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
-            const BYTE* const repMatch = repBase + repIndex;
-            if ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */
-            if (MEM_read32(ip+1) == MEM_read32(repMatch)) {
-                /* repcode detected we should take it */
-                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                matchLength = ZSTD_count_2segments(ip+1+EQUAL_READ32, repMatch+EQUAL_READ32, iend, repEnd, prefixStart) + EQUAL_READ32;
-                if (depth==0) goto _storeSequence;
-        }   }
-
-        /* first search (depth 0) */
-        {   size_t offsetFound = 99999999;
-            size_t const ml2 = searchMax(ctx, ip, iend, &offsetFound, maxSearches, mls);
-            if (ml2 > matchLength)
-                matchLength = ml2, start = ip, offset=offsetFound;
-        }
-
-         if (matchLength < EQUAL_READ32) {
-            ip += ((ip-anchor) >> g_searchStrength) + 1;   /* jump faster over incompressible sections */
-            continue;
-        }
-
-        /* let's try to find a better solution */
-        if (depth>=1)
-        while (ip<ilimit) {
-            ip ++;
-            current++;
-            /* check repCode */
-            if (offset) {
-                const U32 repIndex = (U32)(current - rep[0]);
-                const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
-                const BYTE* const repMatch = repBase + repIndex;
-                if ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */
-                if (MEM_read32(ip) == MEM_read32(repMatch)) {
-                    /* repcode detected */
-                    const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                    size_t const repLength = ZSTD_count_2segments(ip+EQUAL_READ32, repMatch+EQUAL_READ32, iend, repEnd, prefixStart) + EQUAL_READ32;
-                    int const gain2 = (int)(repLength * 3);
-                    int const gain1 = (int)(matchLength*3 - ZSTD_highbit((U32)offset+1) + 1);
-                    if ((repLength >= EQUAL_READ32) && (gain2 > gain1))
-                        matchLength = repLength, offset = 0, start = ip;
-            }   }
-
-            /* search match, depth 1 */
-            {   size_t offset2=99999999;
-                size_t const ml2 = searchMax(ctx, ip, iend, &offset2, maxSearches, mls);
-                int const gain2 = (int)(ml2*4 - ZSTD_highbit((U32)offset2+1));   /* raw approx */
-                int const gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 4);
-                if ((ml2 >= EQUAL_READ32) && (gain2 > gain1)) {
-                    matchLength = ml2, offset = offset2, start = ip;
-                    continue;   /* search a better one */
-            }   }
-
-            /* let's find an even better one */
-            if ((depth==2) && (ip<ilimit)) {
-                ip ++;
-                current++;
-                /* check repCode */
-                if (offset) {
-                    const U32 repIndex = (U32)(current - rep[0]);
-                    const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
-                    const BYTE* const repMatch = repBase + repIndex;
-                    if ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */
-                    if (MEM_read32(ip) == MEM_read32(repMatch)) {
-                        /* repcode detected */
-                        const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                        size_t repLength = ZSTD_count_2segments(ip+EQUAL_READ32, repMatch+EQUAL_READ32, iend, repEnd, prefixStart) + EQUAL_READ32;
-                        int gain2 = (int)(repLength * 4);
-                        int gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 1);
-                        if ((repLength >= EQUAL_READ32) && (gain2 > gain1))
-                            matchLength = repLength, offset = 0, start = ip;
-                }   }
-
-                /* search match, depth 2 */
-                {   size_t offset2=99999999;
-                    size_t const ml2 = searchMax(ctx, ip, iend, &offset2, maxSearches, mls);
-                    int const gain2 = (int)(ml2*4 - ZSTD_highbit((U32)offset2+1));   /* raw approx */
-                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 7);
-                    if ((ml2 >= EQUAL_READ32) && (gain2 > gain1)) {
-                        matchLength = ml2, offset = offset2, start = ip;
-                        continue;
-            }   }   }
-            break;  /* nothing found : store previous solution */
-        }
-
-        /* catch up */
-        if (offset) {
-            U32 matchIndex = (U32)((start-base) - (offset - ZSTD_REP_MOVE));
-            const BYTE* match = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex;
-            const BYTE* const mStart = (matchIndex < dictLimit) ? dictStart : prefixStart;
-            while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; }  /* catch up */
-            rep[1] = rep[0]; rep[0] = (U32)(offset - ZSTD_REP_MOVE);
-        }
-
-        /* store sequence */
-_storeSequence:
-        {   size_t const litLength = start - anchor;
-            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, matchLength-MINMATCH);
-            anchor = ip = start + matchLength;
-        }
-
-        /* check immediate repcode */
-        while (ip <= ilimit) {
-            const U32 repIndex = (U32)((ip-base) - rep[1]);
-            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
-            const BYTE* const repMatch = repBase + repIndex;
-            if ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */
-            if (MEM_read32(ip) == MEM_read32(repMatch)) {
-                /* repcode detected we should take it */
-                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                matchLength = ZSTD_count_2segments(ip+EQUAL_READ32, repMatch+EQUAL_READ32, iend, repEnd, prefixStart) + EQUAL_READ32;
-                offset = rep[1]; rep[1] = rep[0]; rep[0] = (U32)offset;   /* swap offset history */
-                ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, matchLength-MINMATCH);
-                ip += matchLength;
-                anchor = ip;
-                continue;   /* faster when present ... (?) */
-            }
-            break;
-    }   }
-
-    /* Last Literals */
-    {   size_t const lastLLSize = iend - anchor;
-        memcpy(seqStorePtr->lit, anchor, lastLLSize);
-        seqStorePtr->lit += lastLLSize;
-    }
-}
-
-
-void ZSTD_compressBlock_greedy_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
-{
-    ZSTD_compressBlock_lazy_extDict_generic(ctx, src, srcSize, 0, 0);
-}
-
-static void ZSTD_compressBlock_lazy_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
-{
-    ZSTD_compressBlock_lazy_extDict_generic(ctx, src, srcSize, 0, 1);
-}
-
-static void ZSTD_compressBlock_lazy2_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
-{
-    ZSTD_compressBlock_lazy_extDict_generic(ctx, src, srcSize, 0, 2);
-}
-
-static void ZSTD_compressBlock_btlazy2_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
-{
-    ZSTD_compressBlock_lazy_extDict_generic(ctx, src, srcSize, 1, 2);
-}
-
+        printf("Cpos %6u :%5u literals & match %3u bytes at distance %6u \n", 
+               pos, (U32)litLength, (U32)matchCode+MINMATCH, (U32)offsetCode); 
+#endif 
+    ZSTD_statsUpdatePrices(&seqStorePtr->stats, litLength, literals, offsetCode, matchCode); 
+ 
+    /* copy Literals */ 
+    ZSTD_wildcopy(seqStorePtr->lit, literals, litLength); 
+    seqStorePtr->lit += litLength; 
+ 
+    /* literal Length */ 
+    if (litLength>0xFFFF) { seqStorePtr->longLengthID = 1; seqStorePtr->longLengthPos = (U32)(seqStorePtr->litLength - seqStorePtr->litLengthStart); } 
+    *seqStorePtr->litLength++ = (U16)litLength; 
+ 
+    /* match offset */ 
+    *(seqStorePtr->offset++) = (U32)offsetCode + 1; 
+ 
+    /* match Length */ 
+    if (matchCode>0xFFFF) { seqStorePtr->longLengthID = 2; seqStorePtr->longLengthPos = (U32)(seqStorePtr->matchLength - seqStorePtr->matchLengthStart); } 
+    *seqStorePtr->matchLength++ = (U16)matchCode; 
+} 
+ 
+ 
+/*-************************************* 
+*  Match length counter 
+***************************************/ 
+static unsigned ZSTD_NbCommonBytes (register size_t val) 
+{ 
+    if (MEM_isLittleEndian()) { 
+        if (MEM_64bits()) { 
+#       if defined(_MSC_VER) && defined(_WIN64) 
+            unsigned long r = 0; 
+            _BitScanForward64( &r, (U64)val ); 
+            return (unsigned)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) 
+            return (__builtin_ctzll((U64)val) >> 3); 
+#       else 
+            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 }; 
+            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58]; 
+#       endif 
+        } else { /* 32 bits */ 
+#       if defined(_MSC_VER) 
+            unsigned long r=0; 
+            _BitScanForward( &r, (U32)val ); 
+            return (unsigned)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) 
+            return (__builtin_ctz((U32)val) >> 3); 
+#       else 
+            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 }; 
+            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27]; 
+#       endif 
+        } 
+    } else {  /* Big Endian CPU */ 
+        if (MEM_64bits()) { 
+#       if defined(_MSC_VER) && defined(_WIN64) 
+            unsigned long r = 0; 
+            _BitScanReverse64( &r, val ); 
+            return (unsigned)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) 
+            return (__builtin_clzll(val) >> 3); 
+#       else 
+            unsigned r; 
+            const unsigned n32 = sizeof(size_t)*4;   /* calculate this way due to compiler complaining in 32-bits mode */ 
+            if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; } 
+            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; } 
+            r += (!val); 
+            return r; 
+#       endif 
+        } else { /* 32 bits */ 
+#       if defined(_MSC_VER) 
+            unsigned long r = 0; 
+            _BitScanReverse( &r, (unsigned long)val ); 
+            return (unsigned)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) 
+            return (__builtin_clz((U32)val) >> 3); 
+#       else 
+            unsigned r; 
+            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; } 
+            r += (!val); 
+            return r; 
+#       endif 
+    }   } 
+} 
+ 
+ 
+static size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit) 
+{ 
+    const BYTE* const pStart = pIn; 
+ 
+    while ((pIn<pInLimit-(sizeof(size_t)-1))) { 
+        size_t diff = MEM_readST(pMatch) ^ MEM_readST(pIn); 
+        if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; } 
+        pIn += ZSTD_NbCommonBytes(diff); 
+        return (size_t)(pIn - pStart); 
+    } 
+    if (MEM_64bits()) if ((pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; } 
+    if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; } 
+    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++; 
+    return (size_t)(pIn - pStart); 
+} 
+ 
+/** ZSTD_count_2segments() : 
+*   can count match length with `ip` & `match` in 2 different segments. 
+*   convention : on reaching mEnd, match count continue starting from iStart 
+*/ 
+static size_t ZSTD_count_2segments(const BYTE* ip, const BYTE* match, const BYTE* iEnd, const BYTE* mEnd, const BYTE* iStart) 
+{ 
+    size_t matchLength; 
+    const BYTE* vEnd = ip + (mEnd - match); 
+    if (vEnd > iEnd) vEnd = iEnd; 
+    matchLength = ZSTD_count(ip, match, vEnd); 
+    if (match + matchLength == mEnd) 
+        matchLength += ZSTD_count(ip+matchLength, iStart, iEnd); 
+    return matchLength; 
+} 
+ 
+ 
+/*-************************************* 
+*  Hashes 
+***************************************/ 
+static const U32 prime3bytes = 506832829U; 
+static U32    ZSTD_hash3(U32 u, U32 h) { return ((u << (32-24)) * prime3bytes)  >> (32-h) ; } 
+static size_t ZSTD_hash3Ptr(const void* ptr, U32 h) { return ZSTD_hash3(MEM_readLE32(ptr), h); } 
+ 
+static const U32 prime4bytes = 2654435761U; 
+static U32    ZSTD_hash4(U32 u, U32 h) { return (u * prime4bytes) >> (32-h) ; } 
+static size_t ZSTD_hash4Ptr(const void* ptr, U32 h) { return ZSTD_hash4(MEM_read32(ptr), h); } 
+ 
+static const U64 prime5bytes = 889523592379ULL; 
+static size_t ZSTD_hash5(U64 u, U32 h) { return (size_t)(((u  << (64-40)) * prime5bytes) >> (64-h)) ; } 
+static size_t ZSTD_hash5Ptr(const void* p, U32 h) { return ZSTD_hash5(MEM_readLE64(p), h); } 
+ 
+static const U64 prime6bytes = 227718039650203ULL; 
+static size_t ZSTD_hash6(U64 u, U32 h) { return (size_t)(((u  << (64-48)) * prime6bytes) >> (64-h)) ; } 
+static size_t ZSTD_hash6Ptr(const void* p, U32 h) { return ZSTD_hash6(MEM_readLE64(p), h); } 
+ 
+static const U64 prime7bytes = 58295818150454627ULL; 
+static size_t ZSTD_hash7(U64 u, U32 h) { return (size_t)(((u  << (64-56)) * prime7bytes) >> (64-h)) ; } 
+static size_t ZSTD_hash7Ptr(const void* p, U32 h) { return ZSTD_hash7(MEM_readLE64(p), h); } 
+ 
+static size_t ZSTD_hashPtr(const void* p, U32 hBits, U32 mls) 
+{ 
+    switch(mls) 
+    { 
+    default: 
+    case 4: return ZSTD_hash4Ptr(p, hBits); 
+    case 5: return ZSTD_hash5Ptr(p, hBits); 
+    case 6: return ZSTD_hash6Ptr(p, hBits); 
+    case 7: return ZSTD_hash7Ptr(p, hBits); 
+    } 
+} 
+ 
+ 
+/*-************************************* 
+*  Fast Scan 
+***************************************/ 
+static void ZSTD_fillHashTable (ZSTD_CCtx* zc, const void* end, const U32 mls) 
+{ 
+    U32* const hashTable = zc->hashTable; 
+    const U32 hBits = zc->params.cParams.hashLog; 
+    const BYTE* const base = zc->base; 
+    const BYTE* ip = base + zc->nextToUpdate; 
+    const BYTE* const iend = ((const BYTE*)end) - 8; 
+    const size_t fastHashFillStep = 3; 
+ 
+    while(ip <= iend) { 
+        hashTable[ZSTD_hashPtr(ip, hBits, mls)] = (U32)(ip - base); 
+        ip += fastHashFillStep; 
+    } 
+} 
+ 
+ 
+FORCE_INLINE 
+void ZSTD_compressBlock_fast_generic(ZSTD_CCtx* zc, 
+                                 const void* src, size_t srcSize, 
+                                 const U32 mls) 
+{ 
+    U32* const hashTable = zc->hashTable; 
+    const U32 hBits = zc->params.cParams.hashLog; 
+    seqStore_t* seqStorePtr = &(zc->seqStore); 
+    const BYTE* const base = zc->base; 
+    const BYTE* const istart = (const BYTE*)src; 
+    const BYTE* ip = istart; 
+    const BYTE* anchor = istart; 
+    const U32 lowIndex = zc->dictLimit; 
+    const BYTE* const lowest = base + lowIndex; 
+    const BYTE* const iend = istart + srcSize; 
+    const BYTE* const ilimit = iend - 8; 
+    size_t offset_2=REPCODE_STARTVALUE, offset_1=REPCODE_STARTVALUE; 
+ 
+    /* init */ 
+    ZSTD_resetSeqStore(seqStorePtr); 
+    if (ip < lowest+REPCODE_STARTVALUE) ip = lowest+REPCODE_STARTVALUE; 
+ 
+    /* Main Search Loop */ 
+    while (ip < ilimit) {  /* < instead of <=, because repcode check at (ip+1) */ 
+        size_t mlCode; 
+        size_t offset; 
+        const size_t h = ZSTD_hashPtr(ip, hBits, mls); 
+        const U32 matchIndex = hashTable[h]; 
+        const BYTE* match = base + matchIndex; 
+        const U32 current = (U32)(ip-base); 
+        hashTable[h] = current;   /* update hash table */ 
+ 
+        if (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1)) {   /* note : by construction, offset_1 <= current */ 
+            mlCode = ZSTD_count(ip+1+EQUAL_READ32, ip+1+EQUAL_READ32-offset_1, iend) + EQUAL_READ32; 
+            ip++; 
+            ZSTD_storeSeq(seqStorePtr, ip-anchor, anchor, 0, mlCode-MINMATCH); 
+       } else { 
+            if ( (matchIndex <= lowIndex) || 
+                 (MEM_read32(match) != MEM_read32(ip)) ) { 
+                ip += ((ip-anchor) >> g_searchStrength) + 1; 
+                continue; 
+            } 
+            mlCode = ZSTD_count(ip+EQUAL_READ32, match+EQUAL_READ32, iend) + EQUAL_READ32; 
+            offset = ip-match; 
+            while ((ip>anchor) && (match>lowest) && (ip[-1] == match[-1])) { ip--; match--; mlCode++; }  /* catch up */ 
+            offset_2 = offset_1; 
+            offset_1 = offset; 
+ 
+            ZSTD_storeSeq(seqStorePtr, ip-anchor, anchor, offset + ZSTD_REP_MOVE, mlCode-MINMATCH); 
+        } 
+ 
+        /* match found */ 
+        ip += mlCode; 
+        anchor = ip; 
+ 
+        if (ip <= ilimit) { 
+            /* Fill Table */ 
+            hashTable[ZSTD_hashPtr(base+current+2, hBits, mls)] = current+2;  /* here because current+2 could be > iend-8 */ 
+            hashTable[ZSTD_hashPtr(ip-2, hBits, mls)] = (U32)(ip-2-base); 
+            /* check immediate repcode */ 
+            while ( (ip <= ilimit) 
+                 && (MEM_read32(ip) == MEM_read32(ip - offset_2)) ) { 
+                /* store sequence */ 
+                size_t const rlCode = ZSTD_count(ip+EQUAL_READ32, ip+EQUAL_READ32-offset_2, iend) + EQUAL_READ32; 
+                { size_t const tmpOff = offset_2; offset_2 = offset_1; offset_1 = tmpOff; } /* swap offset_2 <=> offset_1 */ 
+                hashTable[ZSTD_hashPtr(ip, hBits, mls)] = (U32)(ip-base); 
+                ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, rlCode-MINMATCH); 
+                ip += rlCode; 
+                anchor = ip; 
+                continue;   /* faster when present ... (?) */ 
+    }   }   } 
+ 
+    /* Last Literals */ 
+    {   size_t const lastLLSize = iend - anchor; 
+        memcpy(seqStorePtr->lit, anchor, lastLLSize); 
+        seqStorePtr->lit += lastLLSize; 
+    } 
+} 
+ 
+ 
+static void ZSTD_compressBlock_fast(ZSTD_CCtx* ctx, 
+                       const void* src, size_t srcSize) 
+{ 
+    const U32 mls = ctx->params.cParams.searchLength; 
+    switch(mls) 
+    { 
+    default: 
+    case 4 : 
+        ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 4); return; 
+    case 5 : 
+        ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 5); return; 
+    case 6 : 
+        ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 6); return; 
+    case 7 : 
+        ZSTD_compressBlock_fast_generic(ctx, src, srcSize, 7); return; 
+    } 
+} 
+ 
+ 
+static void ZSTD_compressBlock_fast_extDict_generic(ZSTD_CCtx* ctx, 
+                                 const void* src, size_t srcSize, 
+                                 const U32 mls) 
+{ 
+    U32* hashTable = ctx->hashTable; 
+    const U32 hBits = ctx->params.cParams.hashLog; 
+    seqStore_t* seqStorePtr = &(ctx->seqStore); 
+    const BYTE* const base = ctx->base; 
+    const BYTE* const dictBase = ctx->dictBase; 
+    const BYTE* const istart = (const BYTE*)src; 
+    const BYTE* ip = istart; 
+    const BYTE* anchor = istart; 
+    const U32   lowLimit = ctx->lowLimit; 
+    const BYTE* const dictStart = dictBase + lowLimit; 
+    const U32   dictLimit = ctx->dictLimit; 
+    const BYTE* const lowPrefixPtr = base + dictLimit; 
+    const BYTE* const dictEnd = dictBase + dictLimit; 
+    const BYTE* const iend = istart + srcSize; 
+    const BYTE* const ilimit = iend - 8; 
+ 
+    U32 offset_2=REPCODE_STARTVALUE, offset_1=REPCODE_STARTVALUE; 
+ 
+ 
+    /* init */ 
+    ZSTD_resetSeqStore(seqStorePtr); 
+    /* skip first position to avoid read overflow during repcode match check */ 
+    hashTable[ZSTD_hashPtr(ip+0, hBits, mls)] = (U32)(ip-base+0); 
+    ip += REPCODE_STARTVALUE; 
+ 
+    /* Main Search Loop */ 
+    while (ip < ilimit) {  /* < instead of <=, because (ip+1) */ 
+        const size_t h = ZSTD_hashPtr(ip, hBits, mls); 
+        const U32 matchIndex = hashTable[h]; 
+        const BYTE* matchBase = matchIndex < dictLimit ? dictBase : base; 
+        const BYTE* match = matchBase + matchIndex; 
+        const U32 current = (U32)(ip-base); 
+        const U32 repIndex = current + 1 - offset_1; 
+        const BYTE* repBase = repIndex < dictLimit ? dictBase : base; 
+        const BYTE* repMatch = repBase + repIndex; 
+        size_t mlCode; 
+        U32 offset; 
+        hashTable[h] = current;   /* update hash table */ 
+ 
+        if ( ((repIndex >= dictLimit) || (repIndex <= dictLimit-4)) 
+          && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) { 
+            const BYTE* repMatchEnd = repIndex < dictLimit ? dictEnd : iend; 
+            mlCode = ZSTD_count_2segments(ip+1+EQUAL_READ32, repMatch+EQUAL_READ32, iend, repMatchEnd, lowPrefixPtr) + EQUAL_READ32; 
+            ip++; 
+            ZSTD_storeSeq(seqStorePtr, ip-anchor, anchor, 0, mlCode-MINMATCH); 
+        } else { 
+            if ( (matchIndex < lowLimit) || 
+                 (MEM_read32(match) != MEM_read32(ip)) ) { 
+                ip += ((ip-anchor) >> g_searchStrength) + 1; 
+                continue; 
+            } 
+            {   const BYTE* matchEnd = matchIndex < dictLimit ? dictEnd : iend; 
+                const BYTE* lowMatchPtr = matchIndex < dictLimit ? dictStart : lowPrefixPtr; 
+                mlCode = ZSTD_count_2segments(ip+EQUAL_READ32, match+EQUAL_READ32, iend, matchEnd, lowPrefixPtr) + EQUAL_READ32; 
+                while ((ip>anchor) && (match>lowMatchPtr) && (ip[-1] == match[-1])) { ip--; match--; mlCode++; }   /* catch up */ 
+                offset = current - matchIndex; 
+                offset_2 = offset_1; 
+                offset_1 = offset; 
+                ZSTD_storeSeq(seqStorePtr, ip-anchor, anchor, offset + ZSTD_REP_MOVE, mlCode-MINMATCH); 
+        }   } 
+ 
+        /* found a match : store it */ 
+        ip += mlCode; 
+        anchor = ip; 
+ 
+        if (ip <= ilimit) { 
+            /* Fill Table */ 
+			hashTable[ZSTD_hashPtr(base+current+2, hBits, mls)] = current+2; 
+            hashTable[ZSTD_hashPtr(ip-2, hBits, mls)] = (U32)(ip-2-base); 
+            /* check immediate repcode */ 
+            while (ip <= ilimit) { 
+                U32 const current2 = (U32)(ip-base); 
+                U32 const repIndex2 = current2 - offset_2; 
+                const BYTE* repMatch2 = repIndex2 < dictLimit ? dictBase + repIndex2 : base + repIndex2; 
+                if ( ((repIndex2 <= dictLimit-4) || (repIndex2 >= dictLimit)) 
+                  && (MEM_read32(repMatch2) == MEM_read32(ip)) ) { 
+                    const BYTE* const repEnd2 = repIndex2 < dictLimit ? dictEnd : iend; 
+                    size_t repLength2 = ZSTD_count_2segments(ip+EQUAL_READ32, repMatch2+EQUAL_READ32, iend, repEnd2, lowPrefixPtr) + EQUAL_READ32; 
+                    U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */ 
+                    ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, repLength2-MINMATCH); 
+                    hashTable[ZSTD_hashPtr(ip, hBits, mls)] = current2; 
+                    ip += repLength2; 
+                    anchor = ip; 
+                    continue; 
+                } 
+                break; 
+    }   }   } 
+ 
+    /* Last Literals */ 
+    {   size_t const lastLLSize = iend - anchor; 
+        memcpy(seqStorePtr->lit, anchor, lastLLSize); 
+        seqStorePtr->lit += lastLLSize; 
+    } 
+} 
+ 
+ 
+static void ZSTD_compressBlock_fast_extDict(ZSTD_CCtx* ctx, 
+                         const void* src, size_t srcSize) 
+{ 
+    const U32 mls = ctx->params.cParams.searchLength; 
+    switch(mls) 
+    { 
+    default: 
+    case 4 : 
+        ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 4); return; 
+    case 5 : 
+        ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 5); return; 
+    case 6 : 
+        ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 6); return; 
+    case 7 : 
+        ZSTD_compressBlock_fast_extDict_generic(ctx, src, srcSize, 7); return; 
+    } 
+} 
+ 
+ 
+ 
+ 
+/*-************************************* 
+*  Binary Tree search 
+***************************************/ 
+/** ZSTD_insertBt1() : add one or multiple positions to tree. 
+*   ip : assumed <= iend-8 . 
+*   @return : nb of positions added */ 
+static U32 ZSTD_insertBt1(ZSTD_CCtx* zc, const BYTE* const ip, const U32 mls, const BYTE* const iend, U32 nbCompares, 
+                          U32 extDict) 
+{ 
+    U32* const hashTable = zc->hashTable; 
+    const U32 hashLog = zc->params.cParams.hashLog; 
+    const size_t h  = ZSTD_hashPtr(ip, hashLog, mls); 
+    U32* const bt   = zc->chainTable; 
+    const U32 btLog = zc->params.cParams.chainLog - 1; 
+    const U32 btMask= (1 << btLog) - 1; 
+    U32 matchIndex  = hashTable[h]; 
+    size_t commonLengthSmaller=0, commonLengthLarger=0; 
+    const BYTE* const base = zc->base; 
+    const BYTE* const dictBase = zc->dictBase; 
+    const U32 dictLimit = zc->dictLimit; 
+    const BYTE* const dictEnd = dictBase + dictLimit; 
+    const BYTE* const prefixStart = base + dictLimit; 
+    const BYTE* match = base + matchIndex; 
+    const U32 current = (U32)(ip-base); 
+    const U32 btLow = btMask >= current ? 0 : current - btMask; 
+    U32* smallerPtr = bt + 2*(current&btMask); 
+    U32* largerPtr  = smallerPtr + 1; 
+    U32 dummy32;   /* to be nullified at the end */ 
+    const U32 windowLow = zc->lowLimit; 
+    U32 matchEndIdx = current+8; 
+    size_t bestLength = 8; 
+    U32 predictedSmall = *(bt + 2*((current-1)&btMask) + 0); 
+    U32 predictedLarge = *(bt + 2*((current-1)&btMask) + 1); 
+    predictedSmall += (predictedSmall>0); 
+    predictedLarge += (predictedLarge>0); 
+ 
+    hashTable[h] = current;   /* Update Hash Table */ 
+ 
+    while (nbCompares-- && (matchIndex > windowLow)) { 
+        U32* nextPtr = bt + 2*(matchIndex & btMask); 
+        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */ 
+#if 0   /* note : can create issues when hlog small <= 11 */ 
+        const U32* predictPtr = bt + 2*((matchIndex-1) & btMask);   /* written this way, as bt is a roll buffer */ 
+        if (matchIndex == predictedSmall) { 
+            /* no need to check length, result known */ 
+            *smallerPtr = matchIndex; 
+            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */ 
+            smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */ 
+            matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */ 
+            predictedSmall = predictPtr[1] + (predictPtr[1]>0); 
+            continue; 
+        } 
+        if (matchIndex == predictedLarge) { 
+            *largerPtr = matchIndex; 
+            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */ 
+            largerPtr = nextPtr; 
+            matchIndex = nextPtr[0]; 
+            predictedLarge = predictPtr[0] + (predictPtr[0]>0); 
+            continue; 
+        } 
+#endif 
+        if ((!extDict) || (matchIndex+matchLength >= dictLimit)) { 
+            match = base + matchIndex; 
+            if (match[matchLength] == ip[matchLength]) 
+                matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iend) +1; 
+        } else { 
+            match = dictBase + matchIndex; 
+            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart); 
+            if (matchIndex+matchLength >= dictLimit) 
+				match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */ 
+        } 
+ 
+        if (matchLength > bestLength) { 
+            bestLength = matchLength; 
+            if (matchLength > matchEndIdx - matchIndex) 
+                matchEndIdx = matchIndex + (U32)matchLength; 
+        } 
+ 
+        if (ip+matchLength == iend)   /* equal : no way to know if inf or sup */ 
+            break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt the tree */ 
+ 
+        if (match[matchLength] < ip[matchLength]) {  /* necessarily within correct buffer */ 
+            /* match is smaller than current */ 
+            *smallerPtr = matchIndex;             /* update smaller idx */ 
+            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */ 
+            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */ 
+            smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */ 
+            matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */ 
+        } else { 
+            /* match is larger than current */ 
+            *largerPtr = matchIndex; 
+            commonLengthLarger = matchLength; 
+            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */ 
+            largerPtr = nextPtr; 
+            matchIndex = nextPtr[0]; 
+    }   } 
+ 
+    *smallerPtr = *largerPtr = 0; 
+    if (bestLength > 384) return MIN(192, (U32)(bestLength - 384)); 
+    if (matchEndIdx > current + 8) return matchEndIdx - current - 8; 
+    return 1; 
+} 
+ 
+ 
+static size_t ZSTD_insertBtAndFindBestMatch ( 
+                        ZSTD_CCtx* zc, 
+                        const BYTE* const ip, const BYTE* const iend, 
+                        size_t* offsetPtr, 
+                        U32 nbCompares, const U32 mls, 
+                        U32 extDict) 
+{ 
+    U32* const hashTable = zc->hashTable; 
+    const U32 hashLog = zc->params.cParams.hashLog; 
+    const size_t h  = ZSTD_hashPtr(ip, hashLog, mls); 
+    U32* const bt   = zc->chainTable; 
+    const U32 btLog = zc->params.cParams.chainLog - 1; 
+    const U32 btMask= (1 << btLog) - 1; 
+    U32 matchIndex  = hashTable[h]; 
+    size_t commonLengthSmaller=0, commonLengthLarger=0; 
+    const BYTE* const base = zc->base; 
+    const BYTE* const dictBase = zc->dictBase; 
+    const U32 dictLimit = zc->dictLimit; 
+    const BYTE* const dictEnd = dictBase + dictLimit; 
+    const BYTE* const prefixStart = base + dictLimit; 
+    const U32 current = (U32)(ip-base); 
+    const U32 btLow = btMask >= current ? 0 : current - btMask; 
+    const U32 windowLow = zc->lowLimit; 
+    U32* smallerPtr = bt + 2*(current&btMask); 
+    U32* largerPtr  = bt + 2*(current&btMask) + 1; 
+    U32 matchEndIdx = current+8; 
+    U32 dummy32;   /* to be nullified at the end */ 
+    size_t bestLength = 0; 
+ 
+    hashTable[h] = current;   /* Update Hash Table */ 
+ 
+    while (nbCompares-- && (matchIndex > windowLow)) { 
+        U32* nextPtr = bt + 2*(matchIndex & btMask); 
+        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */ 
+        const BYTE* match; 
+ 
+        if ((!extDict) || (matchIndex+matchLength >= dictLimit)) { 
+            match = base + matchIndex; 
+            if (match[matchLength] == ip[matchLength]) 
+                matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iend) +1; 
+        } else { 
+            match = dictBase + matchIndex; 
+            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart); 
+            if (matchIndex+matchLength >= dictLimit) 
+				match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */ 
+        } 
+ 
+        if (matchLength > bestLength) { 
+            if (matchLength > matchEndIdx - matchIndex) 
+                matchEndIdx = matchIndex + (U32)matchLength; 
+            if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit(current-matchIndex+1) - ZSTD_highbit((U32)offsetPtr[0]+1)) ) 
+                bestLength = matchLength, *offsetPtr = ZSTD_REP_MOVE + current - matchIndex; 
+            if (ip+matchLength == iend)   /* equal : no way to know if inf or sup */ 
+                break;   /* drop, to guarantee consistency (miss a little bit of compression) */ 
+        } 
+ 
+        if (match[matchLength] < ip[matchLength]) { 
+            /* match is smaller than current */ 
+            *smallerPtr = matchIndex;             /* update smaller idx */ 
+            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */ 
+            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */ 
+            smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */ 
+            matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */ 
+        } else { 
+            /* match is larger than current */ 
+            *largerPtr = matchIndex; 
+            commonLengthLarger = matchLength; 
+            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */ 
+            largerPtr = nextPtr; 
+            matchIndex = nextPtr[0]; 
+    }   } 
+ 
+    *smallerPtr = *largerPtr = 0; 
+ 
+    zc->nextToUpdate = (matchEndIdx > current + 8) ? matchEndIdx - 8 : current+1; 
+    return bestLength; 
+} 
+ 
+ 
+static void ZSTD_updateTree(ZSTD_CCtx* zc, const BYTE* const ip, const BYTE* const iend, const U32 nbCompares, const U32 mls) 
+{ 
+    const BYTE* const base = zc->base; 
+    const U32 target = (U32)(ip - base); 
+    U32 idx = zc->nextToUpdate; 
+ 
+    while(idx < target) 
+        idx += ZSTD_insertBt1(zc, base+idx, mls, iend, nbCompares, 0); 
+} 
+ 
+/** ZSTD_BtFindBestMatch() : Tree updater, providing best match */ 
+static size_t ZSTD_BtFindBestMatch ( 
+                        ZSTD_CCtx* zc, 
+                        const BYTE* const ip, const BYTE* const iLimit, 
+                        size_t* offsetPtr, 
+                        const U32 maxNbAttempts, const U32 mls) 
+{ 
+    if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */ 
+    ZSTD_updateTree(zc, ip, iLimit, maxNbAttempts, mls); 
+    return ZSTD_insertBtAndFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, mls, 0); 
+} 
+ 
+ 
+static size_t ZSTD_BtFindBestMatch_selectMLS ( 
+                        ZSTD_CCtx* zc,   /* Index table will be updated */ 
+                        const BYTE* ip, const BYTE* const iLimit, 
+                        size_t* offsetPtr, 
+                        const U32 maxNbAttempts, const U32 matchLengthSearch) 
+{ 
+    switch(matchLengthSearch) 
+    { 
+    default : 
+    case 4 : return ZSTD_BtFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, 4); 
+    case 5 : return ZSTD_BtFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, 5); 
+    case 6 : return ZSTD_BtFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, 6); 
+    } 
+} 
+ 
+ 
+static void ZSTD_updateTree_extDict(ZSTD_CCtx* zc, const BYTE* const ip, const BYTE* const iend, const U32 nbCompares, const U32 mls) 
+{ 
+    const BYTE* const base = zc->base; 
+    const U32 target = (U32)(ip - base); 
+    U32 idx = zc->nextToUpdate; 
+ 
+    while (idx < target) idx += ZSTD_insertBt1(zc, base+idx, mls, iend, nbCompares, 1); 
+} 
+ 
+ 
+ 
+/** Tree updater, providing best match */ 
+static size_t ZSTD_BtFindBestMatch_extDict ( 
+                        ZSTD_CCtx* zc, 
+                        const BYTE* const ip, const BYTE* const iLimit, 
+                        size_t* offsetPtr, 
+                        const U32 maxNbAttempts, const U32 mls) 
+{ 
+    if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */ 
+    ZSTD_updateTree_extDict(zc, ip, iLimit, maxNbAttempts, mls); 
+    return ZSTD_insertBtAndFindBestMatch(zc, ip, iLimit, offsetPtr, maxNbAttempts, mls, 1); 
+} 
+ 
+ 
+static size_t ZSTD_BtFindBestMatch_selectMLS_extDict ( 
+                        ZSTD_CCtx* zc,   /* Index table will be updated */ 
+                        const BYTE* ip, const BYTE* const iLimit, 
+                        size_t* offsetPtr, 
+                        const U32 maxNbAttempts, const U32 matchLengthSearch) 
+{ 
+    switch(matchLengthSearch) 
+    { 
+    default : 
+    case 4 : return ZSTD_BtFindBestMatch_extDict(zc, ip, iLimit, offsetPtr, maxNbAttempts, 4); 
+    case 5 : return ZSTD_BtFindBestMatch_extDict(zc, ip, iLimit, offsetPtr, maxNbAttempts, 5); 
+    case 6 : return ZSTD_BtFindBestMatch_extDict(zc, ip, iLimit, offsetPtr, maxNbAttempts, 6); 
+    } 
+} 
+ 
+ 
+ 
+/* *********************** 
+*  Hash Chain 
+*************************/ 
+ 
+#define NEXT_IN_CHAIN(d, mask)   chainTable[(d) & mask] 
+ 
+ 
+/* Update chains up to ip (excluded) 
+   Assumption : always within prefix (ie. not within extDict) */ 
+FORCE_INLINE 
+U32 ZSTD_insertAndFindFirstIndex (ZSTD_CCtx* zc, const BYTE* ip, U32 mls) 
+{ 
+    U32* const hashTable  = zc->hashTable; 
+    const U32 hashLog = zc->params.cParams.hashLog; 
+    U32* const chainTable = zc->chainTable; 
+    const U32 chainMask = (1 << zc->params.cParams.chainLog) - 1; 
+    const BYTE* const base = zc->base; 
+    const U32 target = (U32)(ip - base); 
+    U32 idx = zc->nextToUpdate; 
+ 
+    while(idx < target) { 
+        size_t const h = ZSTD_hashPtr(base+idx, hashLog, mls); 
+        NEXT_IN_CHAIN(idx, chainMask) = hashTable[h]; 
+        hashTable[h] = idx; 
+        idx++; 
+    } 
+ 
+    zc->nextToUpdate = target; 
+    return hashTable[ZSTD_hashPtr(ip, hashLog, mls)]; 
+} 
+ 
+ 
+ 
+FORCE_INLINE /* inlining is important to hardwire a hot branch (template emulation) */ 
+size_t ZSTD_HcFindBestMatch_generic ( 
+                        ZSTD_CCtx* zc,   /* Index table will be updated */ 
+                        const BYTE* const ip, const BYTE* const iLimit, 
+                        size_t* offsetPtr, 
+                        const U32 maxNbAttempts, const U32 mls, const U32 extDict) 
+{ 
+    U32* const chainTable = zc->chainTable; 
+    const U32 chainSize = (1 << zc->params.cParams.chainLog); 
+    const U32 chainMask = chainSize-1; 
+    const BYTE* const base = zc->base; 
+    const BYTE* const dictBase = zc->dictBase; 
+    const U32 dictLimit = zc->dictLimit; 
+    const BYTE* const prefixStart = base + dictLimit; 
+    const BYTE* const dictEnd = dictBase + dictLimit; 
+    const U32 lowLimit = zc->lowLimit; 
+    const U32 current = (U32)(ip-base); 
+    const U32 minChain = current > chainSize ? current - chainSize : 0; 
+    int nbAttempts=maxNbAttempts; 
+    size_t ml=EQUAL_READ32-1; 
+ 
+    /* HC4 match finder */ 
+    U32 matchIndex = ZSTD_insertAndFindFirstIndex (zc, ip, mls); 
+ 
+    for ( ; (matchIndex>lowLimit) && (nbAttempts) ; nbAttempts--) { 
+        const BYTE* match; 
+        size_t currentMl=0; 
+        if ((!extDict) || matchIndex >= dictLimit) { 
+            match = base + matchIndex; 
+            if (match[ml] == ip[ml])   /* potentially better */ 
+                currentMl = ZSTD_count(ip, match, iLimit); 
+        } else { 
+            match = dictBase + matchIndex; 
+            if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */ 
+                currentMl = ZSTD_count_2segments(ip+EQUAL_READ32, match+EQUAL_READ32, iLimit, dictEnd, prefixStart) + EQUAL_READ32; 
+        } 
+ 
+        /* save best solution */ 
+        if (currentMl > ml) { ml = currentMl; *offsetPtr = ZSTD_REP_MOVE + current - matchIndex; if (ip+currentMl == iLimit) break; /* best possible, and avoid read overflow*/ } 
+ 
+        if (matchIndex <= minChain) break; 
+        matchIndex = NEXT_IN_CHAIN(matchIndex, chainMask); 
+    } 
+ 
+    return ml; 
+} 
+ 
+ 
+FORCE_INLINE size_t ZSTD_HcFindBestMatch_selectMLS ( 
+                        ZSTD_CCtx* zc, 
+                        const BYTE* ip, const BYTE* const iLimit, 
+                        size_t* offsetPtr, 
+                        const U32 maxNbAttempts, const U32 matchLengthSearch) 
+{ 
+    switch(matchLengthSearch) 
+    { 
+    default : 
+    case 4 : return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 4, 0); 
+    case 5 : return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 5, 0); 
+    case 6 : return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 6, 0); 
+    } 
+} 
+ 
+ 
+FORCE_INLINE size_t ZSTD_HcFindBestMatch_extDict_selectMLS ( 
+                        ZSTD_CCtx* zc, 
+                        const BYTE* ip, const BYTE* const iLimit, 
+                        size_t* offsetPtr, 
+                        const U32 maxNbAttempts, const U32 matchLengthSearch) 
+{ 
+    switch(matchLengthSearch) 
+    { 
+    default : 
+    case 4 : return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 4, 1); 
+    case 5 : return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 5, 1); 
+    case 6 : return ZSTD_HcFindBestMatch_generic(zc, ip, iLimit, offsetPtr, maxNbAttempts, 6, 1); 
+    } 
+} 
+ 
+ 
+/* ******************************* 
+*  Common parser - lazy strategy 
+*********************************/ 
+FORCE_INLINE 
+void ZSTD_compressBlock_lazy_generic(ZSTD_CCtx* ctx, 
+                                     const void* src, size_t srcSize, 
+                                     const U32 searchMethod, const U32 depth) 
+{ 
+    seqStore_t* seqStorePtr = &(ctx->seqStore); 
+    const BYTE* const istart = (const BYTE*)src; 
+    const BYTE* ip = istart; 
+    const BYTE* anchor = istart; 
+    const BYTE* const iend = istart + srcSize; 
+    const BYTE* const ilimit = iend - 8; 
+    const BYTE* const base = ctx->base + ctx->dictLimit; 
+ 
+    U32 const maxSearches = 1 << ctx->params.cParams.searchLog; 
+    U32 const mls = ctx->params.cParams.searchLength; 
+ 
+    typedef size_t (*searchMax_f)(ZSTD_CCtx* zc, const BYTE* ip, const BYTE* iLimit, 
+                        size_t* offsetPtr, 
+                        U32 maxNbAttempts, U32 matchLengthSearch); 
+    searchMax_f searchMax = searchMethod ? ZSTD_BtFindBestMatch_selectMLS : ZSTD_HcFindBestMatch_selectMLS; 
+ 
+    /* init */ 
+    U32 rep[ZSTD_REP_INIT]; 
+    { U32 i ; for (i=0; i<ZSTD_REP_INIT; i++) rep[i]=REPCODE_STARTVALUE; } 
+ 
+    ctx->nextToUpdate3 = ctx->nextToUpdate; 
+    ZSTD_resetSeqStore(seqStorePtr); 
+    if ((ip-base) < REPCODE_STARTVALUE) ip = base + REPCODE_STARTVALUE; 
+ 
+    /* Match Loop */ 
+    while (ip < ilimit) { 
+        size_t matchLength=0; 
+        size_t offset=0; 
+        const BYTE* start=ip+1; 
+ 
+        /* check repCode */ 
+        if (MEM_read32(ip+1) == MEM_read32(ip+1 - rep[0])) { 
+            /* repcode : we take it */ 
+            matchLength = ZSTD_count(ip+1+EQUAL_READ32, ip+1+EQUAL_READ32-rep[0], iend) + EQUAL_READ32; 
+            if (depth==0) goto _storeSequence; 
+        } 
+ 
+        /* first search (depth 0) */ 
+        {   size_t offsetFound = 99999999; 
+            size_t const ml2 = searchMax(ctx, ip, iend, &offsetFound, maxSearches, mls); 
+            if (ml2 > matchLength) 
+                matchLength = ml2, start = ip, offset=offsetFound; 
+        } 
+ 
+        if (matchLength < EQUAL_READ32) { 
+            ip += ((ip-anchor) >> g_searchStrength) + 1;   /* jump faster over incompressible sections */ 
+            continue; 
+        } 
+ 
+        /* let's try to find a better solution */ 
+        if (depth>=1) 
+        while (ip<ilimit) { 
+            ip ++; 
+            if ((offset) && (MEM_read32(ip) == MEM_read32(ip - rep[0]))) { 
+                size_t const mlRep = ZSTD_count(ip+EQUAL_READ32, ip+EQUAL_READ32-rep[0], iend) + EQUAL_READ32; 
+                int const gain2 = (int)(mlRep * 3); 
+                int const gain1 = (int)(matchLength*3 - ZSTD_highbit((U32)offset+1) + 1); 
+                if ((mlRep >= EQUAL_READ32) && (gain2 > gain1)) 
+                    matchLength = mlRep, offset = 0, start = ip; 
+            } 
+            {   size_t offset2=99999999; 
+                size_t const ml2 = searchMax(ctx, ip, iend, &offset2, maxSearches, mls); 
+                int const gain2 = (int)(ml2*4 - ZSTD_highbit((U32)offset2+1));   /* raw approx */ 
+                int const gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 4); 
+                if ((ml2 >= EQUAL_READ32) && (gain2 > gain1)) { 
+                    matchLength = ml2, offset = offset2, start = ip; 
+                    continue;   /* search a better one */ 
+            }   } 
+ 
+            /* let's find an even better one */ 
+            if ((depth==2) && (ip<ilimit)) { 
+                ip ++; 
+                if ((offset) && (MEM_read32(ip) == MEM_read32(ip - rep[0]))) { 
+                    size_t const ml2 = ZSTD_count(ip+EQUAL_READ32, ip+EQUAL_READ32-rep[0], iend) + EQUAL_READ32; 
+                    int const gain2 = (int)(ml2 * 4); 
+                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 1); 
+                    if ((ml2 >= EQUAL_READ32) && (gain2 > gain1)) 
+                        matchLength = ml2, offset = 0, start = ip; 
+                } 
+                {   size_t offset2=99999999; 
+                    size_t const ml2 = searchMax(ctx, ip, iend, &offset2, maxSearches, mls); 
+                    int const gain2 = (int)(ml2*4 - ZSTD_highbit((U32)offset2+1));   /* raw approx */ 
+                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 7); 
+                    if ((ml2 >= EQUAL_READ32) && (gain2 > gain1)) { 
+                        matchLength = ml2, offset = offset2, start = ip; 
+                        continue; 
+            }   }   } 
+            break;  /* nothing found : store previous solution */ 
+        } 
+ 
+        /* catch up */ 
+        if (offset) { 
+            while ((start>anchor) && (start>base+offset-ZSTD_REP_MOVE) && (start[-1] == start[-1-offset+ZSTD_REP_MOVE]))   /* only search for offset within prefix */ 
+                { start--; matchLength++; } 
+            rep[1] = rep[0]; rep[0] = (U32)(offset - ZSTD_REP_MOVE); 
+        } 
+ 
+        /* store sequence */ 
+_storeSequence: 
+        {   size_t const litLength = start - anchor; 
+            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, matchLength-MINMATCH); 
+            anchor = ip = start + matchLength; 
+        } 
+ 
+        /* check immediate repcode */ 
+        while ( (ip <= ilimit) 
+             && (MEM_read32(ip) == MEM_read32(ip - rep[1])) ) { 
+            /* store sequence */ 
+            matchLength = ZSTD_count(ip+EQUAL_READ32, ip+EQUAL_READ32-rep[1], iend) + EQUAL_READ32; 
+            offset = rep[1]; rep[1] = rep[0]; rep[0] = (U32)offset; /* swap repcodes */ 
+            ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, matchLength-MINMATCH); 
+            ip += matchLength; 
+            anchor = ip; 
+            continue;   /* faster when present ... (?) */ 
+    }   } 
+ 
+    /* Last Literals */ 
+    {   size_t const lastLLSize = iend - anchor; 
+        memcpy(seqStorePtr->lit, anchor, lastLLSize); 
+        seqStorePtr->lit += lastLLSize; 
+        ZSTD_statsUpdatePrices(&seqStorePtr->stats, lastLLSize, anchor, 0, 0); 
+    } 
+} 
+ 
+ 
+static void ZSTD_compressBlock_btlazy2(ZSTD_CCtx* ctx, const void* src, size_t srcSize) 
+{ 
+    ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 1, 2); 
+} 
+ 
+static void ZSTD_compressBlock_lazy2(ZSTD_CCtx* ctx, const void* src, size_t srcSize) 
+{ 
+    ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 0, 2); 
+} 
+ 
+static void ZSTD_compressBlock_lazy(ZSTD_CCtx* ctx, const void* src, size_t srcSize) 
+{ 
+    ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 0, 1); 
+} 
+ 
+static void ZSTD_compressBlock_greedy(ZSTD_CCtx* ctx, const void* src, size_t srcSize) 
+{ 
+    ZSTD_compressBlock_lazy_generic(ctx, src, srcSize, 0, 0); 
+} 
+ 
+ 
+FORCE_INLINE 
+void ZSTD_compressBlock_lazy_extDict_generic(ZSTD_CCtx* ctx, 
+                                     const void* src, size_t srcSize, 
+                                     const U32 searchMethod, const U32 depth) 
+{ 
+    seqStore_t* seqStorePtr = &(ctx->seqStore); 
+    const BYTE* const istart = (const BYTE*)src; 
+    const BYTE* ip = istart; 
+    const BYTE* anchor = istart; 
+    const BYTE* const iend = istart + srcSize; 
+    const BYTE* const ilimit = iend - 8; 
+    const BYTE* const base = ctx->base; 
+    const U32 dictLimit = ctx->dictLimit; 
+    const BYTE* const prefixStart = base + dictLimit; 
+    const BYTE* const dictBase = ctx->dictBase; 
+    const BYTE* const dictEnd  = dictBase + dictLimit; 
+    const BYTE* const dictStart  = dictBase + ctx->lowLimit; 
+ 
+    const U32 maxSearches = 1 << ctx->params.cParams.searchLog; 
+    const U32 mls = ctx->params.cParams.searchLength; 
+ 
+    typedef size_t (*searchMax_f)(ZSTD_CCtx* zc, const BYTE* ip, const BYTE* iLimit, 
+                        size_t* offsetPtr, 
+                        U32 maxNbAttempts, U32 matchLengthSearch); 
+    searchMax_f searchMax = searchMethod ? ZSTD_BtFindBestMatch_selectMLS_extDict : ZSTD_HcFindBestMatch_extDict_selectMLS; 
+ 
+    /* init */ 
+    U32 rep[ZSTD_REP_INIT]; 
+    { U32 i; for (i=0; i<ZSTD_REP_INIT; i++) rep[i]=REPCODE_STARTVALUE; } 
+ 
+    ctx->nextToUpdate3 = ctx->nextToUpdate; 
+    ZSTD_resetSeqStore(seqStorePtr); 
+    if ((ip - prefixStart) < REPCODE_STARTVALUE) ip += REPCODE_STARTVALUE; 
+ 
+    /* Match Loop */ 
+    while (ip < ilimit) { 
+        size_t matchLength=0; 
+        size_t offset=0; 
+        const BYTE* start=ip+1; 
+        U32 current = (U32)(ip-base); 
+ 
+        /* check repCode */ 
+        { 
+            const U32 repIndex = (U32)(current+1 - rep[0]); 
+            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base; 
+            const BYTE* const repMatch = repBase + repIndex; 
+            if ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */ 
+            if (MEM_read32(ip+1) == MEM_read32(repMatch)) { 
+                /* repcode detected we should take it */ 
+                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; 
+                matchLength = ZSTD_count_2segments(ip+1+EQUAL_READ32, repMatch+EQUAL_READ32, iend, repEnd, prefixStart) + EQUAL_READ32; 
+                if (depth==0) goto _storeSequence; 
+        }   } 
+ 
+        /* first search (depth 0) */ 
+        {   size_t offsetFound = 99999999; 
+            size_t const ml2 = searchMax(ctx, ip, iend, &offsetFound, maxSearches, mls); 
+            if (ml2 > matchLength) 
+                matchLength = ml2, start = ip, offset=offsetFound; 
+        } 
+ 
+         if (matchLength < EQUAL_READ32) { 
+            ip += ((ip-anchor) >> g_searchStrength) + 1;   /* jump faster over incompressible sections */ 
+            continue; 
+        } 
+ 
+        /* let's try to find a better solution */ 
+        if (depth>=1) 
+        while (ip<ilimit) { 
+            ip ++; 
+            current++; 
+            /* check repCode */ 
+            if (offset) { 
+                const U32 repIndex = (U32)(current - rep[0]); 
+                const BYTE* const repBase = repIndex < dictLimit ? dictBase : base; 
+                const BYTE* const repMatch = repBase + repIndex; 
+                if ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */ 
+                if (MEM_read32(ip) == MEM_read32(repMatch)) { 
+                    /* repcode detected */ 
+                    const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; 
+                    size_t const repLength = ZSTD_count_2segments(ip+EQUAL_READ32, repMatch+EQUAL_READ32, iend, repEnd, prefixStart) + EQUAL_READ32; 
+                    int const gain2 = (int)(repLength * 3); 
+                    int const gain1 = (int)(matchLength*3 - ZSTD_highbit((U32)offset+1) + 1); 
+                    if ((repLength >= EQUAL_READ32) && (gain2 > gain1)) 
+                        matchLength = repLength, offset = 0, start = ip; 
+            }   } 
+ 
+            /* search match, depth 1 */ 
+            {   size_t offset2=99999999; 
+                size_t const ml2 = searchMax(ctx, ip, iend, &offset2, maxSearches, mls); 
+                int const gain2 = (int)(ml2*4 - ZSTD_highbit((U32)offset2+1));   /* raw approx */ 
+                int const gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 4); 
+                if ((ml2 >= EQUAL_READ32) && (gain2 > gain1)) { 
+                    matchLength = ml2, offset = offset2, start = ip; 
+                    continue;   /* search a better one */ 
+            }   } 
+ 
+            /* let's find an even better one */ 
+            if ((depth==2) && (ip<ilimit)) { 
+                ip ++; 
+                current++; 
+                /* check repCode */ 
+                if (offset) { 
+                    const U32 repIndex = (U32)(current - rep[0]); 
+                    const BYTE* const repBase = repIndex < dictLimit ? dictBase : base; 
+                    const BYTE* const repMatch = repBase + repIndex; 
+                    if ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */ 
+                    if (MEM_read32(ip) == MEM_read32(repMatch)) { 
+                        /* repcode detected */ 
+                        const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; 
+                        size_t repLength = ZSTD_count_2segments(ip+EQUAL_READ32, repMatch+EQUAL_READ32, iend, repEnd, prefixStart) + EQUAL_READ32; 
+                        int gain2 = (int)(repLength * 4); 
+                        int gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 1); 
+                        if ((repLength >= EQUAL_READ32) && (gain2 > gain1)) 
+                            matchLength = repLength, offset = 0, start = ip; 
+                }   } 
+ 
+                /* search match, depth 2 */ 
+                {   size_t offset2=99999999; 
+                    size_t const ml2 = searchMax(ctx, ip, iend, &offset2, maxSearches, mls); 
+                    int const gain2 = (int)(ml2*4 - ZSTD_highbit((U32)offset2+1));   /* raw approx */ 
+                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit((U32)offset+1) + 7); 
+                    if ((ml2 >= EQUAL_READ32) && (gain2 > gain1)) { 
+                        matchLength = ml2, offset = offset2, start = ip; 
+                        continue; 
+            }   }   } 
+            break;  /* nothing found : store previous solution */ 
+        } 
+ 
+        /* catch up */ 
+        if (offset) { 
+            U32 matchIndex = (U32)((start-base) - (offset - ZSTD_REP_MOVE)); 
+            const BYTE* match = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex; 
+            const BYTE* const mStart = (matchIndex < dictLimit) ? dictStart : prefixStart; 
+            while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; }  /* catch up */ 
+            rep[1] = rep[0]; rep[0] = (U32)(offset - ZSTD_REP_MOVE); 
+        } 
+ 
+        /* store sequence */ 
+_storeSequence: 
+        {   size_t const litLength = start - anchor; 
+            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, matchLength-MINMATCH); 
+            anchor = ip = start + matchLength; 
+        } 
+ 
+        /* check immediate repcode */ 
+        while (ip <= ilimit) { 
+            const U32 repIndex = (U32)((ip-base) - rep[1]); 
+            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base; 
+            const BYTE* const repMatch = repBase + repIndex; 
+            if ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */ 
+            if (MEM_read32(ip) == MEM_read32(repMatch)) { 
+                /* repcode detected we should take it */ 
+                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; 
+                matchLength = ZSTD_count_2segments(ip+EQUAL_READ32, repMatch+EQUAL_READ32, iend, repEnd, prefixStart) + EQUAL_READ32; 
+                offset = rep[1]; rep[1] = rep[0]; rep[0] = (U32)offset;   /* swap offset history */ 
+                ZSTD_storeSeq(seqStorePtr, 0, anchor, 0, matchLength-MINMATCH); 
+                ip += matchLength; 
+                anchor = ip; 
+                continue;   /* faster when present ... (?) */ 
+            } 
+            break; 
+    }   } 
+ 
+    /* Last Literals */ 
+    {   size_t const lastLLSize = iend - anchor; 
+        memcpy(seqStorePtr->lit, anchor, lastLLSize); 
+        seqStorePtr->lit += lastLLSize; 
+    } 
+} 
+ 
+ 
+void ZSTD_compressBlock_greedy_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize) 
+{ 
+    ZSTD_compressBlock_lazy_extDict_generic(ctx, src, srcSize, 0, 0); 
+} 
+ 
+static void ZSTD_compressBlock_lazy_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize) 
+{ 
+    ZSTD_compressBlock_lazy_extDict_generic(ctx, src, srcSize, 0, 1); 
+} 
+ 
+static void ZSTD_compressBlock_lazy2_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize) 
+{ 
+    ZSTD_compressBlock_lazy_extDict_generic(ctx, src, srcSize, 0, 2); 
+} 
+ 
+static void ZSTD_compressBlock_btlazy2_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize) 
+{ 
+    ZSTD_compressBlock_lazy_extDict_generic(ctx, src, srcSize, 1, 2); 
+} 
+ 
 
 
 /* The optimal parser */
@@ -1976,590 +1976,590 @@ static void ZSTD_compressBlock_btopt(ZSTD_CCtx* ctx, const void* src, size_t src
     ZSTD_compressBlock_opt_generic(ctx, src, srcSize);
 }
 
-static void ZSTD_compressBlock_btopt_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
-{
-    ZSTD_compressBlock_opt_extDict_generic(ctx, src, srcSize);
-}
-
-
-typedef void (*ZSTD_blockCompressor) (ZSTD_CCtx* ctx, const void* src, size_t srcSize);
-
-static ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, int extDict)
-{
-    static const ZSTD_blockCompressor blockCompressor[2][6] = {
-#if 1
-        { ZSTD_compressBlock_fast, ZSTD_compressBlock_greedy, ZSTD_compressBlock_lazy, ZSTD_compressBlock_lazy2, ZSTD_compressBlock_btlazy2, ZSTD_compressBlock_btopt },
-#else
-        { ZSTD_compressBlock_fast_extDict, ZSTD_compressBlock_greedy_extDict, ZSTD_compressBlock_lazy_extDict,ZSTD_compressBlock_lazy2_extDict, ZSTD_compressBlock_btlazy2_extDict, ZSTD_compressBlock_btopt_extDict },
-#endif
-        { ZSTD_compressBlock_fast_extDict, ZSTD_compressBlock_greedy_extDict, ZSTD_compressBlock_lazy_extDict,ZSTD_compressBlock_lazy2_extDict, ZSTD_compressBlock_btlazy2_extDict, ZSTD_compressBlock_btopt_extDict }
-    };
-
-    return blockCompressor[extDict][(U32)strat];
-}
-
-
-static size_t ZSTD_compressBlock_internal(ZSTD_CCtx* zc, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    ZSTD_blockCompressor blockCompressor = ZSTD_selectBlockCompressor(zc->params.cParams.strategy, zc->lowLimit < zc->dictLimit);
-    if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1) return 0;   /* don't even attempt compression below a certain srcSize */
-    blockCompressor(zc, src, srcSize);
-    return ZSTD_compressSequences(zc, dst, dstCapacity, srcSize);
-}
-
-
-
-
-static size_t ZSTD_compress_generic (ZSTD_CCtx* zc,
-                                        void* dst, size_t dstCapacity,
-                                  const void* src, size_t srcSize)
-{
-    size_t blockSize = zc->blockSize;
-    size_t remaining = srcSize;
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* op = ostart;
-    const U32 maxDist = 1 << zc->params.cParams.windowLog;
-    ZSTD_stats_t* stats = &zc->seqStore.stats;
-
-    ZSTD_statsInit(stats);
-
-    while (remaining) {
-        size_t cSize;
-        ZSTD_statsResetFreqs(stats);
-
-        if (dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE) return ERROR(dstSize_tooSmall);   /* not enough space to store compressed block */
-        if (remaining < blockSize) blockSize = remaining;
-
-        if ((U32)(ip+blockSize - zc->base) > zc->loadedDictEnd + maxDist) {
-            /* enforce maxDist */
-            U32 const newLowLimit = (U32)(ip+blockSize - zc->base) - maxDist;
-            if (zc->lowLimit < newLowLimit) zc->lowLimit = newLowLimit;
-            if (zc->dictLimit < zc->lowLimit) zc->dictLimit = zc->lowLimit;
-        }
-
-        cSize = ZSTD_compressBlock_internal(zc, op+ZSTD_blockHeaderSize, dstCapacity-ZSTD_blockHeaderSize, ip, blockSize);
-        if (ZSTD_isError(cSize)) return cSize;
-
-        if (cSize == 0) {  /* block is not compressible */
-            cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize);
-            if (ZSTD_isError(cSize)) return cSize;
-        } else {
-            op[0] = (BYTE)(cSize>>16);
-            op[1] = (BYTE)(cSize>>8);
-            op[2] = (BYTE)cSize;
-            op[0] += (BYTE)(bt_compressed << 6); /* is a compressed block */
-            cSize += 3;
-        }
-
-        remaining -= blockSize;
-        dstCapacity -= cSize;
-        ip += blockSize;
-        op += cSize;
-    }
-
-    ZSTD_statsPrint(stats, zc->params.cParams.searchLength);
-    return op-ostart;
-}
-
-
-static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,
-                                    ZSTD_parameters params, U64 pledgedSrcSize)
-{   BYTE* const op = (BYTE*)dst;
-    U32 const fcsId = params.fParams.contentSizeFlag ?
-                     (pledgedSrcSize>0) + (pledgedSrcSize>=256) + (pledgedSrcSize>=65536+256) :   /* 0-3 */
-                      0;
-    BYTE const fdescriptor = (BYTE)((params.cParams.windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN)   /* windowLog : 4 KB - 128 MB */
-                                  | (fcsId << 6) );
-    size_t const hSize = ZSTD_frameHeaderSize_min + ZSTD_fcs_fieldSize[fcsId];
-    if (hSize > dstCapacity) return ERROR(dstSize_tooSmall);
-
-    MEM_writeLE32(dst, ZSTD_MAGICNUMBER);
-    op[4] = fdescriptor;
-    switch(fcsId)
-    {
-        default:   /* impossible */
-        case 0 : break;
-        case 1 : op[5] = (BYTE)(pledgedSrcSize); break;
-        case 2 : MEM_writeLE16(op+5, (U16)(pledgedSrcSize-256)); break;
-        case 3 : MEM_writeLE64(op+5, (U64)(pledgedSrcSize)); break;
-    }
-    return hSize;
-}
-
-
-static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* zc,
-                              void* dst, size_t dstCapacity,
-                        const void* src, size_t srcSize,
-                               U32 frame)
-{
-    const BYTE* const ip = (const BYTE*) src;
-    size_t fhSize = 0;
-
-    if (zc->stage==0) return ERROR(stage_wrong);
-    if (frame && (zc->stage==1)) {   /* copy saved header */
-        fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, zc->params, srcSize);
-        if (ZSTD_isError(fhSize)) return fhSize;
-        dstCapacity -= fhSize;
-        dst = (char*)dst + fhSize;
-        zc->stage = 2;
-    }
-
-    /* Check if blocks follow each other */
-    if (src != zc->nextSrc) {
-        /* not contiguous */
-        size_t const delta = zc->nextSrc - ip;
-        zc->lowLimit = zc->dictLimit;
-        zc->dictLimit = (U32)(zc->nextSrc - zc->base);
-        zc->dictBase = zc->base;
-        zc->base -= delta;
-        zc->nextToUpdate = zc->dictLimit;
-        if (zc->dictLimit - zc->lowLimit < 8) zc->lowLimit = zc->dictLimit;   /* too small extDict */
-    }
-
-    /* preemptive overflow correction */
-    if (zc->lowLimit > (1<<30)) {
-        U32 const btplus = (zc->params.cParams.strategy == ZSTD_btlazy2) || (zc->params.cParams.strategy == ZSTD_btopt);
-        U32 const chainMask = (1 << (zc->params.cParams.chainLog - btplus)) - 1;
-        U32 const newLowLimit = zc->lowLimit & chainMask;   /* preserve position % chainSize */
-        U32 const correction = zc->lowLimit - newLowLimit;
-        ZSTD_reduceIndex(zc, correction);
-        zc->base += correction;
-        zc->dictBase += correction;
-        zc->lowLimit = newLowLimit;
-        zc->dictLimit -= correction;
-        if (zc->nextToUpdate < correction) zc->nextToUpdate = 0;
-        else zc->nextToUpdate -= correction;
-    }
-
-    /* if input and dictionary overlap : reduce dictionary (presumed modified by input) */
-    if ((ip+srcSize > zc->dictBase + zc->lowLimit) && (ip < zc->dictBase + zc->dictLimit)) {
-        zc->lowLimit = (U32)(ip + srcSize - zc->dictBase);
-        if (zc->lowLimit > zc->dictLimit) zc->lowLimit = zc->dictLimit;
-    }
-
-    zc->nextSrc = ip + srcSize;
-    {   size_t const cSize = frame ?
-                             ZSTD_compress_generic (zc, dst, dstCapacity, src, srcSize) :
-                             ZSTD_compressBlock_internal (zc, dst, dstCapacity, src, srcSize);
-        if (ZSTD_isError(cSize)) return cSize;
-        return cSize + fhSize;
-    }
-}
-
-
-size_t ZSTD_compressContinue (ZSTD_CCtx* zc,
-                              void* dst, size_t dstCapacity,
-                        const void* src, size_t srcSize)
-{
-    return ZSTD_compressContinue_internal(zc, dst, dstCapacity, src, srcSize, 1);
-}
-
-
-size_t ZSTD_compressBlock(ZSTD_CCtx* zc, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    if (srcSize > ZSTD_BLOCKSIZE_MAX) return ERROR(srcSize_wrong);
-    ZSTD_LOG_BLOCK("%p: ZSTD_compressBlock searchLength=%d\n", zc->base, zc->params.cParams.searchLength);
-    return ZSTD_compressContinue_internal(zc, dst, dstCapacity, src, srcSize, 0);
-}
-
-
-static size_t ZSTD_loadDictionaryContent(ZSTD_CCtx* zc, const void* src, size_t srcSize)
-{
-    const BYTE* const ip = (const BYTE*) src;
-    const BYTE* const iend = ip + srcSize;
-
-    /* input becomes current prefix */
-    zc->lowLimit = zc->dictLimit;
-    zc->dictLimit = (U32)(zc->nextSrc - zc->base);
-    zc->dictBase = zc->base;
-    zc->base += ip - zc->nextSrc;
-    zc->nextToUpdate = zc->dictLimit;
-    zc->loadedDictEnd = (U32)(iend - zc->base);
-
-    zc->nextSrc = iend;
-    if (srcSize <= 8) return 0;
-
-    switch(zc->params.cParams.strategy)
-    {
-    case ZSTD_fast:
-        ZSTD_fillHashTable (zc, iend, zc->params.cParams.searchLength);
-        break;
-
-    case ZSTD_greedy:
-    case ZSTD_lazy:
-    case ZSTD_lazy2:
-        ZSTD_insertAndFindFirstIndex (zc, iend-8, zc->params.cParams.searchLength);
-        break;
-
-    case ZSTD_btlazy2:
-    case ZSTD_btopt:
-        ZSTD_updateTree(zc, iend-8, iend, 1 << zc->params.cParams.searchLog, zc->params.cParams.searchLength);
-        break;
-
-    default:
-        return ERROR(GENERIC);   /* strategy doesn't exist; impossible */
-    }
-
-    zc->nextToUpdate = zc->loadedDictEnd;
-    return 0;
-}
-
-
-/* Dictionary format :
-     Magic == ZSTD_DICT_MAGIC (4 bytes)
-     HUF_writeCTable(256)
-     Dictionary content
-*/
-/*! ZSTD_loadDictEntropyStats() :
-    @return : size read from dictionary */
-static size_t ZSTD_loadDictEntropyStats(ZSTD_CCtx* zc, const void* dict, size_t dictSize)
-{
-    /* note : magic number already checked */
-    size_t offcodeHeaderSize, matchlengthHeaderSize, litlengthHeaderSize, errorCode;
-    short offcodeNCount[MaxOff+1];
-    unsigned offcodeMaxValue = MaxOff, offcodeLog = OffFSELog;
-    short matchlengthNCount[MaxML+1];
-    unsigned matchlengthMaxValue = MaxML, matchlengthLog = MLFSELog;
-    short litlengthNCount[MaxLL+1];
-    unsigned litlengthMaxValue = MaxLL, litlengthLog = LLFSELog;
-
-    size_t const hufHeaderSize = HUF_readCTable(zc->hufTable, 255, dict, dictSize);
-    if (HUF_isError(hufHeaderSize)) return ERROR(dictionary_corrupted);
-    zc->flagStaticTables = 1;
-    dict = (const char*)dict + hufHeaderSize;
-    dictSize -= hufHeaderSize;
-
-    offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dict, dictSize);
-    if (FSE_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);
-    errorCode = FSE_buildCTable(zc->offcodeCTable, offcodeNCount, offcodeMaxValue, offcodeLog);
-    if (FSE_isError(errorCode)) return ERROR(dictionary_corrupted);
-    dict = (const char*)dict + offcodeHeaderSize;
-    dictSize -= offcodeHeaderSize;
-
-    matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dict, dictSize);
-    if (FSE_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted);
-    errorCode = FSE_buildCTable(zc->matchlengthCTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog);
-    if (FSE_isError(errorCode)) return ERROR(dictionary_corrupted);
-    dict = (const char*)dict + matchlengthHeaderSize;
-    dictSize -= matchlengthHeaderSize;
-
-    litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dict, dictSize);
-    if (FSE_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted);
-    errorCode = FSE_buildCTable(zc->litlengthCTable, litlengthNCount, litlengthMaxValue, litlengthLog);
-    if (FSE_isError(errorCode)) return ERROR(dictionary_corrupted);
-
-    return hufHeaderSize + offcodeHeaderSize + matchlengthHeaderSize + litlengthHeaderSize;
-}
-
-/** ZSTD_compress_insertDictionary() :
-*   @return : 0, or an error code */
-static size_t ZSTD_compress_insertDictionary(ZSTD_CCtx* zc, const void* dict, size_t dictSize)
-{
-    if ((dict==NULL) || (dictSize<=4)) return 0;
-
-    /* default : dict is pure content */
-    if (MEM_readLE32(dict) != ZSTD_DICT_MAGIC) return ZSTD_loadDictionaryContent(zc, dict, dictSize);
-
-    /* known magic number : dict is parsed for entropy stats and content */
-    {   size_t const eSize = ZSTD_loadDictEntropyStats(zc, (const char*)dict+4 /* skip magic */, dictSize-4) + 4;
-        if (ZSTD_isError(eSize)) return eSize;
-        return ZSTD_loadDictionaryContent(zc, (const char*)dict+eSize, dictSize-eSize);
-    }
-}
-
-
-/*! ZSTD_compressBegin_internal() :
-*   @return : 0, or an error code */
-static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* zc,
-                             const void* dict, size_t dictSize,
-                                   ZSTD_parameters params, U64 pledgedSrcSize)
-{
-    { U32 const hashLog3 = (pledgedSrcSize || pledgedSrcSize >= 8192) ? ZSTD_HASHLOG3_MAX : ((pledgedSrcSize >= 2048) ? ZSTD_HASHLOG3_MIN + 1 : ZSTD_HASHLOG3_MIN);
-      zc->hashLog3 = (params.cParams.searchLength==3) ? hashLog3 : 0; }
-
-    { size_t const resetError = ZSTD_resetCCtx_advanced(zc, params, 1);
-      if (ZSTD_isError(resetError)) return resetError; }
-
-    return ZSTD_compress_insertDictionary(zc, dict, dictSize);
-}
-
-
-/*! ZSTD_compressBegin_advanced() :
-*   @return : 0, or an error code */
-size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* zc,
-                             const void* dict, size_t dictSize,
-                                   ZSTD_parameters params, U64 pledgedSrcSize)
-{
-    /* compression parameters verification and optimization */
-    { size_t const errorCode = ZSTD_checkCParams_advanced(params.cParams, pledgedSrcSize);
-      if (ZSTD_isError(errorCode)) return errorCode; }
-
-    return ZSTD_compressBegin_internal(zc, dict, dictSize, params, pledgedSrcSize);
-}
-
-
-size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* zc, const void* dict, size_t dictSize, int compressionLevel)
-{
-    ZSTD_parameters params;
-    params.cParams = ZSTD_getCParams(compressionLevel, 0, dictSize);
-    params.fParams.contentSizeFlag = 0;
-    ZSTD_adjustCParams(&params.cParams, 0, dictSize);
-    ZSTD_LOG_BLOCK("%p: ZSTD_compressBegin_usingDict compressionLevel=%d\n", zc->base, compressionLevel);
-    return ZSTD_compressBegin_internal(zc, dict, dictSize, params, 0);
-}
-
-
-size_t ZSTD_compressBegin(ZSTD_CCtx* zc, int compressionLevel)
-{
-    ZSTD_LOG_BLOCK("%p: ZSTD_compressBegin compressionLevel=%d\n", zc->base, compressionLevel);
-    return ZSTD_compressBegin_usingDict(zc, NULL, 0, compressionLevel);
-}
-
-
-/*! ZSTD_compressEnd() :
-*   Write frame epilogue.
-*   @return : nb of bytes written into dst (or an error code) */
-size_t ZSTD_compressEnd(ZSTD_CCtx* zc, void* dst, size_t dstCapacity)
-{
-    BYTE* op = (BYTE*)dst;
-    size_t fhSize = 0;
-
-    /* not even init ! */
-    if (zc->stage==0) return ERROR(stage_wrong);
-
-    /* special case : empty frame */
-    if (zc->stage==1) {
-        fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, zc->params, 0);
-        if (ZSTD_isError(fhSize)) return fhSize;
-        dstCapacity -= fhSize;
-        op += fhSize;
-        zc->stage = 2;
-    }
-
-    /* frame epilogue */
-    if (dstCapacity < 3) return ERROR(dstSize_tooSmall);
-    op[0] = (BYTE)(bt_end << 6);
-    op[1] = 0;
-    op[2] = 0;
-
-    zc->stage = 0;  /* return to "created by not init" status */
-    return 3+fhSize;
-}
-
-
-size_t ZSTD_compress_usingPreparedCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx,
-                                       void* dst, size_t dstCapacity,
-                                 const void* src, size_t srcSize)
-{
-    {   size_t const errorCode = ZSTD_copyCCtx(cctx, preparedCCtx);
-        if (ZSTD_isError(errorCode)) return errorCode;
-    }
-    {   size_t const cSize = ZSTD_compressContinue(cctx, dst, dstCapacity, src, srcSize);
-        if (ZSTD_isError(cSize)) return cSize;
-
-        {   size_t const endSize = ZSTD_compressEnd(cctx, (char*)dst+cSize, dstCapacity-cSize);
-            if (ZSTD_isError(endSize)) return endSize;
-            return cSize + endSize;
-    }   }
-}
-
-
-static size_t ZSTD_compress_internal (ZSTD_CCtx* ctx,
-                               void* dst, size_t dstCapacity,
-                         const void* src, size_t srcSize,
-                         const void* dict,size_t dictSize,
-                               ZSTD_parameters params)
-{
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* op = ostart;
-
-    /* Init */
-    { size_t const errorCode = ZSTD_compressBegin_internal(ctx, dict, dictSize, params, srcSize);
-      if(ZSTD_isError(errorCode)) return errorCode; }
-
-    /* body (compression) */
-    { size_t const oSize = ZSTD_compressContinue (ctx, op,  dstCapacity, src, srcSize);
-      if(ZSTD_isError(oSize)) return oSize;
-      op += oSize;
-      dstCapacity -= oSize; }
-
-    /* Close frame */
-    { size_t const oSize = ZSTD_compressEnd(ctx, op, dstCapacity);
-      if(ZSTD_isError(oSize)) return oSize;
-      op += oSize; }
-
-    return (op - ostart);
-}
-
-size_t ZSTD_compress_advanced (ZSTD_CCtx* ctx,
-                               void* dst, size_t dstCapacity,
-                         const void* src, size_t srcSize,
-                         const void* dict,size_t dictSize,
-                               ZSTD_parameters params)
-{
-    size_t const errorCode = ZSTD_checkCParams_advanced(params.cParams, srcSize);
-    if (ZSTD_isError(errorCode)) return errorCode;
-    return ZSTD_compress_internal(ctx, dst, dstCapacity, src, srcSize, dict, dictSize, params);
-}
-
-size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict, size_t dictSize, int compressionLevel)
-{
-    ZSTD_parameters params;
-    ZSTD_LOG_BLOCK("%p: ZSTD_compress_usingDict srcSize=%d dictSize=%d compressionLevel=%d\n", ctx->base, (int)srcSize, (int)dictSize, compressionLevel);
-    params.cParams =  ZSTD_getCParams(compressionLevel, srcSize, dictSize);
-    params.fParams.contentSizeFlag = 1;
-    ZSTD_adjustCParams(&params.cParams, srcSize, dictSize);
-    return ZSTD_compress_internal(ctx, dst, dstCapacity, src, srcSize, dict, dictSize, params);
-}
-
-size_t ZSTD_compressCCtx (ZSTD_CCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, int compressionLevel)
-{
-    ZSTD_LOG_BLOCK("%p: ZSTD_compressCCtx srcSize=%d compressionLevel=%d\n", ctx->base, (int)srcSize, compressionLevel);
-    return ZSTD_compress_usingDict(ctx, dst, dstCapacity, src, srcSize, NULL, 0, compressionLevel);
-}
-
-size_t ZSTD_compress(void* dst, size_t dstCapacity, const void* src, size_t srcSize, int compressionLevel)
-{
-    size_t result;
-    ZSTD_CCtx ctxBody;
-    memset(&ctxBody, 0, sizeof(ctxBody));
-    result = ZSTD_compressCCtx(&ctxBody, dst, dstCapacity, src, srcSize, compressionLevel);
-    free(ctxBody.workSpace);   /* can't free ctxBody, since it's on stack; just free heap content */
-    return result;
-}
-
-
-/*-=====  Pre-defined compression levels  =====-*/
-
+static void ZSTD_compressBlock_btopt_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize) 
+{ 
+    ZSTD_compressBlock_opt_extDict_generic(ctx, src, srcSize); 
+} 
+ 
+ 
+typedef void (*ZSTD_blockCompressor) (ZSTD_CCtx* ctx, const void* src, size_t srcSize); 
+ 
+static ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, int extDict) 
+{ 
+    static const ZSTD_blockCompressor blockCompressor[2][6] = { 
+#if 1 
+        { ZSTD_compressBlock_fast, ZSTD_compressBlock_greedy, ZSTD_compressBlock_lazy, ZSTD_compressBlock_lazy2, ZSTD_compressBlock_btlazy2, ZSTD_compressBlock_btopt }, 
+#else 
+        { ZSTD_compressBlock_fast_extDict, ZSTD_compressBlock_greedy_extDict, ZSTD_compressBlock_lazy_extDict,ZSTD_compressBlock_lazy2_extDict, ZSTD_compressBlock_btlazy2_extDict, ZSTD_compressBlock_btopt_extDict }, 
+#endif 
+        { ZSTD_compressBlock_fast_extDict, ZSTD_compressBlock_greedy_extDict, ZSTD_compressBlock_lazy_extDict,ZSTD_compressBlock_lazy2_extDict, ZSTD_compressBlock_btlazy2_extDict, ZSTD_compressBlock_btopt_extDict } 
+    }; 
+ 
+    return blockCompressor[extDict][(U32)strat]; 
+} 
+ 
+ 
+static size_t ZSTD_compressBlock_internal(ZSTD_CCtx* zc, void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    ZSTD_blockCompressor blockCompressor = ZSTD_selectBlockCompressor(zc->params.cParams.strategy, zc->lowLimit < zc->dictLimit); 
+    if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1) return 0;   /* don't even attempt compression below a certain srcSize */ 
+    blockCompressor(zc, src, srcSize); 
+    return ZSTD_compressSequences(zc, dst, dstCapacity, srcSize); 
+} 
+ 
+ 
+ 
+ 
+static size_t ZSTD_compress_generic (ZSTD_CCtx* zc, 
+                                        void* dst, size_t dstCapacity, 
+                                  const void* src, size_t srcSize) 
+{ 
+    size_t blockSize = zc->blockSize; 
+    size_t remaining = srcSize; 
+    const BYTE* ip = (const BYTE*)src; 
+    BYTE* const ostart = (BYTE*)dst; 
+    BYTE* op = ostart; 
+    const U32 maxDist = 1 << zc->params.cParams.windowLog; 
+    ZSTD_stats_t* stats = &zc->seqStore.stats; 
+ 
+    ZSTD_statsInit(stats); 
+ 
+    while (remaining) { 
+        size_t cSize; 
+        ZSTD_statsResetFreqs(stats); 
+ 
+        if (dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE) return ERROR(dstSize_tooSmall);   /* not enough space to store compressed block */ 
+        if (remaining < blockSize) blockSize = remaining; 
+ 
+        if ((U32)(ip+blockSize - zc->base) > zc->loadedDictEnd + maxDist) { 
+            /* enforce maxDist */ 
+            U32 const newLowLimit = (U32)(ip+blockSize - zc->base) - maxDist; 
+            if (zc->lowLimit < newLowLimit) zc->lowLimit = newLowLimit; 
+            if (zc->dictLimit < zc->lowLimit) zc->dictLimit = zc->lowLimit; 
+        } 
+ 
+        cSize = ZSTD_compressBlock_internal(zc, op+ZSTD_blockHeaderSize, dstCapacity-ZSTD_blockHeaderSize, ip, blockSize); 
+        if (ZSTD_isError(cSize)) return cSize; 
+ 
+        if (cSize == 0) {  /* block is not compressible */ 
+            cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize); 
+            if (ZSTD_isError(cSize)) return cSize; 
+        } else { 
+            op[0] = (BYTE)(cSize>>16); 
+            op[1] = (BYTE)(cSize>>8); 
+            op[2] = (BYTE)cSize; 
+            op[0] += (BYTE)(bt_compressed << 6); /* is a compressed block */ 
+            cSize += 3; 
+        } 
+ 
+        remaining -= blockSize; 
+        dstCapacity -= cSize; 
+        ip += blockSize; 
+        op += cSize; 
+    } 
+ 
+    ZSTD_statsPrint(stats, zc->params.cParams.searchLength); 
+    return op-ostart; 
+} 
+ 
+ 
+static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity, 
+                                    ZSTD_parameters params, U64 pledgedSrcSize) 
+{   BYTE* const op = (BYTE*)dst; 
+    U32 const fcsId = params.fParams.contentSizeFlag ? 
+                     (pledgedSrcSize>0) + (pledgedSrcSize>=256) + (pledgedSrcSize>=65536+256) :   /* 0-3 */ 
+                      0; 
+    BYTE const fdescriptor = (BYTE)((params.cParams.windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN)   /* windowLog : 4 KB - 128 MB */ 
+                                  | (fcsId << 6) ); 
+    size_t const hSize = ZSTD_frameHeaderSize_min + ZSTD_fcs_fieldSize[fcsId]; 
+    if (hSize > dstCapacity) return ERROR(dstSize_tooSmall); 
+ 
+    MEM_writeLE32(dst, ZSTD_MAGICNUMBER); 
+    op[4] = fdescriptor; 
+    switch(fcsId) 
+    { 
+        default:   /* impossible */ 
+        case 0 : break; 
+        case 1 : op[5] = (BYTE)(pledgedSrcSize); break; 
+        case 2 : MEM_writeLE16(op+5, (U16)(pledgedSrcSize-256)); break; 
+        case 3 : MEM_writeLE64(op+5, (U64)(pledgedSrcSize)); break; 
+    } 
+    return hSize; 
+} 
+ 
+ 
+static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* zc, 
+                              void* dst, size_t dstCapacity, 
+                        const void* src, size_t srcSize, 
+                               U32 frame) 
+{ 
+    const BYTE* const ip = (const BYTE*) src; 
+    size_t fhSize = 0; 
+ 
+    if (zc->stage==0) return ERROR(stage_wrong); 
+    if (frame && (zc->stage==1)) {   /* copy saved header */ 
+        fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, zc->params, srcSize); 
+        if (ZSTD_isError(fhSize)) return fhSize; 
+        dstCapacity -= fhSize; 
+        dst = (char*)dst + fhSize; 
+        zc->stage = 2; 
+    } 
+ 
+    /* Check if blocks follow each other */ 
+    if (src != zc->nextSrc) { 
+        /* not contiguous */ 
+        size_t const delta = zc->nextSrc - ip; 
+        zc->lowLimit = zc->dictLimit; 
+        zc->dictLimit = (U32)(zc->nextSrc - zc->base); 
+        zc->dictBase = zc->base; 
+        zc->base -= delta; 
+        zc->nextToUpdate = zc->dictLimit; 
+        if (zc->dictLimit - zc->lowLimit < 8) zc->lowLimit = zc->dictLimit;   /* too small extDict */ 
+    } 
+ 
+    /* preemptive overflow correction */ 
+    if (zc->lowLimit > (1<<30)) { 
+        U32 const btplus = (zc->params.cParams.strategy == ZSTD_btlazy2) || (zc->params.cParams.strategy == ZSTD_btopt); 
+        U32 const chainMask = (1 << (zc->params.cParams.chainLog - btplus)) - 1; 
+        U32 const newLowLimit = zc->lowLimit & chainMask;   /* preserve position % chainSize */ 
+        U32 const correction = zc->lowLimit - newLowLimit; 
+        ZSTD_reduceIndex(zc, correction); 
+        zc->base += correction; 
+        zc->dictBase += correction; 
+        zc->lowLimit = newLowLimit; 
+        zc->dictLimit -= correction; 
+        if (zc->nextToUpdate < correction) zc->nextToUpdate = 0; 
+        else zc->nextToUpdate -= correction; 
+    } 
+ 
+    /* if input and dictionary overlap : reduce dictionary (presumed modified by input) */ 
+    if ((ip+srcSize > zc->dictBase + zc->lowLimit) && (ip < zc->dictBase + zc->dictLimit)) { 
+        zc->lowLimit = (U32)(ip + srcSize - zc->dictBase); 
+        if (zc->lowLimit > zc->dictLimit) zc->lowLimit = zc->dictLimit; 
+    } 
+ 
+    zc->nextSrc = ip + srcSize; 
+    {   size_t const cSize = frame ? 
+                             ZSTD_compress_generic (zc, dst, dstCapacity, src, srcSize) : 
+                             ZSTD_compressBlock_internal (zc, dst, dstCapacity, src, srcSize); 
+        if (ZSTD_isError(cSize)) return cSize; 
+        return cSize + fhSize; 
+    } 
+} 
+ 
+ 
+size_t ZSTD_compressContinue (ZSTD_CCtx* zc, 
+                              void* dst, size_t dstCapacity, 
+                        const void* src, size_t srcSize) 
+{ 
+    return ZSTD_compressContinue_internal(zc, dst, dstCapacity, src, srcSize, 1); 
+} 
+ 
+ 
+size_t ZSTD_compressBlock(ZSTD_CCtx* zc, void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    if (srcSize > ZSTD_BLOCKSIZE_MAX) return ERROR(srcSize_wrong); 
+    ZSTD_LOG_BLOCK("%p: ZSTD_compressBlock searchLength=%d\n", zc->base, zc->params.cParams.searchLength); 
+    return ZSTD_compressContinue_internal(zc, dst, dstCapacity, src, srcSize, 0); 
+} 
+ 
+ 
+static size_t ZSTD_loadDictionaryContent(ZSTD_CCtx* zc, const void* src, size_t srcSize) 
+{ 
+    const BYTE* const ip = (const BYTE*) src; 
+    const BYTE* const iend = ip + srcSize; 
+ 
+    /* input becomes current prefix */ 
+    zc->lowLimit = zc->dictLimit; 
+    zc->dictLimit = (U32)(zc->nextSrc - zc->base); 
+    zc->dictBase = zc->base; 
+    zc->base += ip - zc->nextSrc; 
+    zc->nextToUpdate = zc->dictLimit; 
+    zc->loadedDictEnd = (U32)(iend - zc->base); 
+ 
+    zc->nextSrc = iend; 
+    if (srcSize <= 8) return 0; 
+ 
+    switch(zc->params.cParams.strategy) 
+    { 
+    case ZSTD_fast: 
+        ZSTD_fillHashTable (zc, iend, zc->params.cParams.searchLength); 
+        break; 
+ 
+    case ZSTD_greedy: 
+    case ZSTD_lazy: 
+    case ZSTD_lazy2: 
+        ZSTD_insertAndFindFirstIndex (zc, iend-8, zc->params.cParams.searchLength); 
+        break; 
+ 
+    case ZSTD_btlazy2: 
+    case ZSTD_btopt: 
+        ZSTD_updateTree(zc, iend-8, iend, 1 << zc->params.cParams.searchLog, zc->params.cParams.searchLength); 
+        break; 
+ 
+    default: 
+        return ERROR(GENERIC);   /* strategy doesn't exist; impossible */ 
+    } 
+ 
+    zc->nextToUpdate = zc->loadedDictEnd; 
+    return 0; 
+} 
+ 
+ 
+/* Dictionary format : 
+     Magic == ZSTD_DICT_MAGIC (4 bytes) 
+     HUF_writeCTable(256) 
+     Dictionary content 
+*/ 
+/*! ZSTD_loadDictEntropyStats() : 
+    @return : size read from dictionary */ 
+static size_t ZSTD_loadDictEntropyStats(ZSTD_CCtx* zc, const void* dict, size_t dictSize) 
+{ 
+    /* note : magic number already checked */ 
+    size_t offcodeHeaderSize, matchlengthHeaderSize, litlengthHeaderSize, errorCode; 
+    short offcodeNCount[MaxOff+1]; 
+    unsigned offcodeMaxValue = MaxOff, offcodeLog = OffFSELog; 
+    short matchlengthNCount[MaxML+1]; 
+    unsigned matchlengthMaxValue = MaxML, matchlengthLog = MLFSELog; 
+    short litlengthNCount[MaxLL+1]; 
+    unsigned litlengthMaxValue = MaxLL, litlengthLog = LLFSELog; 
+ 
+    size_t const hufHeaderSize = HUF_readCTable(zc->hufTable, 255, dict, dictSize); 
+    if (HUF_isError(hufHeaderSize)) return ERROR(dictionary_corrupted); 
+    zc->flagStaticTables = 1; 
+    dict = (const char*)dict + hufHeaderSize; 
+    dictSize -= hufHeaderSize; 
+ 
+    offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dict, dictSize); 
+    if (FSE_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted); 
+    errorCode = FSE_buildCTable(zc->offcodeCTable, offcodeNCount, offcodeMaxValue, offcodeLog); 
+    if (FSE_isError(errorCode)) return ERROR(dictionary_corrupted); 
+    dict = (const char*)dict + offcodeHeaderSize; 
+    dictSize -= offcodeHeaderSize; 
+ 
+    matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dict, dictSize); 
+    if (FSE_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted); 
+    errorCode = FSE_buildCTable(zc->matchlengthCTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog); 
+    if (FSE_isError(errorCode)) return ERROR(dictionary_corrupted); 
+    dict = (const char*)dict + matchlengthHeaderSize; 
+    dictSize -= matchlengthHeaderSize; 
+ 
+    litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dict, dictSize); 
+    if (FSE_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted); 
+    errorCode = FSE_buildCTable(zc->litlengthCTable, litlengthNCount, litlengthMaxValue, litlengthLog); 
+    if (FSE_isError(errorCode)) return ERROR(dictionary_corrupted); 
+ 
+    return hufHeaderSize + offcodeHeaderSize + matchlengthHeaderSize + litlengthHeaderSize; 
+} 
+ 
+/** ZSTD_compress_insertDictionary() : 
+*   @return : 0, or an error code */ 
+static size_t ZSTD_compress_insertDictionary(ZSTD_CCtx* zc, const void* dict, size_t dictSize) 
+{ 
+    if ((dict==NULL) || (dictSize<=4)) return 0; 
+ 
+    /* default : dict is pure content */ 
+    if (MEM_readLE32(dict) != ZSTD_DICT_MAGIC) return ZSTD_loadDictionaryContent(zc, dict, dictSize); 
+ 
+    /* known magic number : dict is parsed for entropy stats and content */ 
+    {   size_t const eSize = ZSTD_loadDictEntropyStats(zc, (const char*)dict+4 /* skip magic */, dictSize-4) + 4; 
+        if (ZSTD_isError(eSize)) return eSize; 
+        return ZSTD_loadDictionaryContent(zc, (const char*)dict+eSize, dictSize-eSize); 
+    } 
+} 
+ 
+ 
+/*! ZSTD_compressBegin_internal() : 
+*   @return : 0, or an error code */ 
+static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* zc, 
+                             const void* dict, size_t dictSize, 
+                                   ZSTD_parameters params, U64 pledgedSrcSize) 
+{ 
+    { U32 const hashLog3 = (pledgedSrcSize || pledgedSrcSize >= 8192) ? ZSTD_HASHLOG3_MAX : ((pledgedSrcSize >= 2048) ? ZSTD_HASHLOG3_MIN + 1 : ZSTD_HASHLOG3_MIN); 
+      zc->hashLog3 = (params.cParams.searchLength==3) ? hashLog3 : 0; } 
+ 
+    { size_t const resetError = ZSTD_resetCCtx_advanced(zc, params, 1); 
+      if (ZSTD_isError(resetError)) return resetError; } 
+ 
+    return ZSTD_compress_insertDictionary(zc, dict, dictSize); 
+} 
+ 
+ 
+/*! ZSTD_compressBegin_advanced() : 
+*   @return : 0, or an error code */ 
+size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* zc, 
+                             const void* dict, size_t dictSize, 
+                                   ZSTD_parameters params, U64 pledgedSrcSize) 
+{ 
+    /* compression parameters verification and optimization */ 
+    { size_t const errorCode = ZSTD_checkCParams_advanced(params.cParams, pledgedSrcSize); 
+      if (ZSTD_isError(errorCode)) return errorCode; } 
+ 
+    return ZSTD_compressBegin_internal(zc, dict, dictSize, params, pledgedSrcSize); 
+} 
+ 
+ 
+size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* zc, const void* dict, size_t dictSize, int compressionLevel) 
+{ 
+    ZSTD_parameters params; 
+    params.cParams = ZSTD_getCParams(compressionLevel, 0, dictSize); 
+    params.fParams.contentSizeFlag = 0; 
+    ZSTD_adjustCParams(&params.cParams, 0, dictSize); 
+    ZSTD_LOG_BLOCK("%p: ZSTD_compressBegin_usingDict compressionLevel=%d\n", zc->base, compressionLevel); 
+    return ZSTD_compressBegin_internal(zc, dict, dictSize, params, 0); 
+} 
+ 
+ 
+size_t ZSTD_compressBegin(ZSTD_CCtx* zc, int compressionLevel) 
+{ 
+    ZSTD_LOG_BLOCK("%p: ZSTD_compressBegin compressionLevel=%d\n", zc->base, compressionLevel); 
+    return ZSTD_compressBegin_usingDict(zc, NULL, 0, compressionLevel); 
+} 
+ 
+ 
+/*! ZSTD_compressEnd() : 
+*   Write frame epilogue. 
+*   @return : nb of bytes written into dst (or an error code) */ 
+size_t ZSTD_compressEnd(ZSTD_CCtx* zc, void* dst, size_t dstCapacity) 
+{ 
+    BYTE* op = (BYTE*)dst; 
+    size_t fhSize = 0; 
+ 
+    /* not even init ! */ 
+    if (zc->stage==0) return ERROR(stage_wrong); 
+ 
+    /* special case : empty frame */ 
+    if (zc->stage==1) { 
+        fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, zc->params, 0); 
+        if (ZSTD_isError(fhSize)) return fhSize; 
+        dstCapacity -= fhSize; 
+        op += fhSize; 
+        zc->stage = 2; 
+    } 
+ 
+    /* frame epilogue */ 
+    if (dstCapacity < 3) return ERROR(dstSize_tooSmall); 
+    op[0] = (BYTE)(bt_end << 6); 
+    op[1] = 0; 
+    op[2] = 0; 
+ 
+    zc->stage = 0;  /* return to "created by not init" status */ 
+    return 3+fhSize; 
+} 
+ 
+ 
+size_t ZSTD_compress_usingPreparedCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, 
+                                       void* dst, size_t dstCapacity, 
+                                 const void* src, size_t srcSize) 
+{ 
+    {   size_t const errorCode = ZSTD_copyCCtx(cctx, preparedCCtx); 
+        if (ZSTD_isError(errorCode)) return errorCode; 
+    } 
+    {   size_t const cSize = ZSTD_compressContinue(cctx, dst, dstCapacity, src, srcSize); 
+        if (ZSTD_isError(cSize)) return cSize; 
+ 
+        {   size_t const endSize = ZSTD_compressEnd(cctx, (char*)dst+cSize, dstCapacity-cSize); 
+            if (ZSTD_isError(endSize)) return endSize; 
+            return cSize + endSize; 
+    }   } 
+} 
+ 
+ 
+static size_t ZSTD_compress_internal (ZSTD_CCtx* ctx, 
+                               void* dst, size_t dstCapacity, 
+                         const void* src, size_t srcSize, 
+                         const void* dict,size_t dictSize, 
+                               ZSTD_parameters params) 
+{ 
+    BYTE* const ostart = (BYTE*)dst; 
+    BYTE* op = ostart; 
+ 
+    /* Init */ 
+    { size_t const errorCode = ZSTD_compressBegin_internal(ctx, dict, dictSize, params, srcSize); 
+      if(ZSTD_isError(errorCode)) return errorCode; } 
+ 
+    /* body (compression) */ 
+    { size_t const oSize = ZSTD_compressContinue (ctx, op,  dstCapacity, src, srcSize); 
+      if(ZSTD_isError(oSize)) return oSize; 
+      op += oSize; 
+      dstCapacity -= oSize; } 
+ 
+    /* Close frame */ 
+    { size_t const oSize = ZSTD_compressEnd(ctx, op, dstCapacity); 
+      if(ZSTD_isError(oSize)) return oSize; 
+      op += oSize; } 
+ 
+    return (op - ostart); 
+} 
+ 
+size_t ZSTD_compress_advanced (ZSTD_CCtx* ctx, 
+                               void* dst, size_t dstCapacity, 
+                         const void* src, size_t srcSize, 
+                         const void* dict,size_t dictSize, 
+                               ZSTD_parameters params) 
+{ 
+    size_t const errorCode = ZSTD_checkCParams_advanced(params.cParams, srcSize); 
+    if (ZSTD_isError(errorCode)) return errorCode; 
+    return ZSTD_compress_internal(ctx, dst, dstCapacity, src, srcSize, dict, dictSize, params); 
+} 
+ 
+size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, const void* dict, size_t dictSize, int compressionLevel) 
+{ 
+    ZSTD_parameters params; 
+    ZSTD_LOG_BLOCK("%p: ZSTD_compress_usingDict srcSize=%d dictSize=%d compressionLevel=%d\n", ctx->base, (int)srcSize, (int)dictSize, compressionLevel); 
+    params.cParams =  ZSTD_getCParams(compressionLevel, srcSize, dictSize); 
+    params.fParams.contentSizeFlag = 1; 
+    ZSTD_adjustCParams(&params.cParams, srcSize, dictSize); 
+    return ZSTD_compress_internal(ctx, dst, dstCapacity, src, srcSize, dict, dictSize, params); 
+} 
+ 
+size_t ZSTD_compressCCtx (ZSTD_CCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize, int compressionLevel) 
+{ 
+    ZSTD_LOG_BLOCK("%p: ZSTD_compressCCtx srcSize=%d compressionLevel=%d\n", ctx->base, (int)srcSize, compressionLevel); 
+    return ZSTD_compress_usingDict(ctx, dst, dstCapacity, src, srcSize, NULL, 0, compressionLevel); 
+} 
+ 
+size_t ZSTD_compress(void* dst, size_t dstCapacity, const void* src, size_t srcSize, int compressionLevel) 
+{ 
+    size_t result; 
+    ZSTD_CCtx ctxBody; 
+    memset(&ctxBody, 0, sizeof(ctxBody)); 
+    result = ZSTD_compressCCtx(&ctxBody, dst, dstCapacity, src, srcSize, compressionLevel); 
+    free(ctxBody.workSpace);   /* can't free ctxBody, since it's on stack; just free heap content */ 
+    return result; 
+} 
+ 
+ 
+/*-=====  Pre-defined compression levels  =====-*/ 
+ 
 #define ZSTD_DEFAULT_CLEVEL 5
 #define ZSTD_MAX_CLEVEL     22
-unsigned ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
-
-static const ZSTD_compressionParameters ZSTD_defaultCParameters[4][ZSTD_MAX_CLEVEL+1] = {
-{   /* "default" */
-    /* W,  C,  H,  S,  L, TL, strat */
-    {  0,  0,  0,  0,  0,  0, ZSTD_fast    },  /* level  0 - never used */
-    { 19, 13, 14,  1,  7,  4, ZSTD_fast    },  /* level  1 */
-    { 19, 15, 16,  1,  6,  4, ZSTD_fast    },  /* level  2 */
-    { 20, 18, 20,  1,  6,  4, ZSTD_fast    },  /* level  3 */
-    { 20, 13, 17,  2,  5,  4, ZSTD_greedy  },  /* level  4.*/
-    { 20, 15, 18,  3,  5,  4, ZSTD_greedy  },  /* level  5 */
-    { 21, 16, 19,  2,  5,  4, ZSTD_lazy    },  /* level  6 */
-    { 21, 17, 20,  3,  5,  4, ZSTD_lazy    },  /* level  7 */
-    { 21, 18, 20,  3,  5,  4, ZSTD_lazy2   },  /* level  8.*/
-    { 21, 20, 20,  3,  5,  4, ZSTD_lazy2   },  /* level  9 */
-    { 21, 19, 21,  4,  5,  4, ZSTD_lazy2   },  /* level 10 */
-    { 22, 20, 22,  4,  5,  4, ZSTD_lazy2   },  /* level 11 */
-    { 22, 20, 22,  5,  5,  4, ZSTD_lazy2   },  /* level 12 */
-    { 22, 21, 22,  5,  5,  4, ZSTD_lazy2   },  /* level 13 */
-    { 22, 21, 22,  6,  5,  4, ZSTD_lazy2   },  /* level 14 */
-    { 22, 21, 21,  5,  5,  4, ZSTD_btlazy2 },  /* level 15 */
-    { 23, 22, 22,  5,  5,  4, ZSTD_btlazy2 },  /* level 16 */
-    { 23, 23, 22,  5,  5,  4, ZSTD_btlazy2 },  /* level 17.*/
-    { 23, 23, 22,  6,  5, 24, ZSTD_btopt   },  /* level 18.*/
-    { 23, 23, 22,  6,  3, 48, ZSTD_btopt   },  /* level 19.*/
-    { 25, 26, 23,  7,  3, 64, ZSTD_btopt   },  /* level 20.*/
-    { 26, 26, 23,  7,  3,256, ZSTD_btopt   },  /* level 21.*/
-    { 27, 27, 25,  9,  3,512, ZSTD_btopt   },  /* level 22.*/
-},
-{   /* for srcSize <= 256 KB */
-    /* W,  C,  H,  S,  L,  T, strat */
-    {  0,  0,  0,  0,  0,  0, ZSTD_fast    },  /* level  0 */
-    { 18, 13, 14,  1,  6,  4, ZSTD_fast    },  /* level  1 */
-    { 18, 15, 17,  1,  5,  4, ZSTD_fast    },  /* level  2 */
-    { 18, 13, 15,  1,  5,  4, ZSTD_greedy  },  /* level  3.*/
-    { 18, 15, 17,  1,  5,  4, ZSTD_greedy  },  /* level  4.*/
-    { 18, 16, 17,  4,  5,  4, ZSTD_greedy  },  /* level  5 */
-    { 18, 17, 17,  5,  5,  4, ZSTD_greedy  },  /* level  6 */
-    { 18, 17, 17,  4,  4,  4, ZSTD_lazy    },  /* level  7 */
-    { 18, 17, 17,  4,  4,  4, ZSTD_lazy2   },  /* level  8 */
-    { 18, 17, 17,  5,  4,  4, ZSTD_lazy2   },  /* level  9 */
-    { 18, 17, 17,  6,  4,  4, ZSTD_lazy2   },  /* level 10 */
-    { 18, 18, 17,  6,  4,  4, ZSTD_lazy2   },  /* level 11.*/
-    { 18, 18, 17,  7,  4,  4, ZSTD_lazy2   },  /* level 12.*/
-    { 18, 19, 17,  7,  4,  4, ZSTD_btlazy2 },  /* level 13 */
-    { 18, 18, 18,  4,  4, 16, ZSTD_btopt   },  /* level 14.*/
-    { 18, 18, 18,  8,  4, 24, ZSTD_btopt   },  /* level 15.*/
-    { 18, 19, 18,  8,  3, 48, ZSTD_btopt   },  /* level 16.*/
-    { 18, 19, 18,  8,  3, 96, ZSTD_btopt   },  /* level 17.*/
-    { 18, 19, 18,  9,  3,128, ZSTD_btopt   },  /* level 18.*/
-    { 18, 19, 18, 10,  3,256, ZSTD_btopt   },  /* level 19.*/
-    { 18, 19, 18, 11,  3,512, ZSTD_btopt   },  /* level 20.*/
-    { 18, 19, 18, 12,  3,512, ZSTD_btopt   },  /* level 21.*/
-    { 18, 19, 18, 13,  3,512, ZSTD_btopt   },  /* level 22.*/
-},
-{   /* for srcSize <= 128 KB */
-    /* W,  C,  H,  S,  L,  T, strat */
-    {  0,  0,  0,  0,  0,  0, ZSTD_fast    },  /* level  0 - never used */
-    { 17, 12, 13,  1,  6,  4, ZSTD_fast    },  /* level  1 */
-    { 17, 13, 16,  1,  5,  4, ZSTD_fast    },  /* level  2 */
-    { 17, 13, 14,  2,  5,  4, ZSTD_greedy  },  /* level  3 */
-    { 17, 13, 15,  3,  4,  4, ZSTD_greedy  },  /* level  4 */
-    { 17, 15, 17,  4,  4,  4, ZSTD_greedy  },  /* level  5 */
-    { 17, 16, 17,  3,  4,  4, ZSTD_lazy    },  /* level  6 */
-    { 17, 15, 17,  4,  4,  4, ZSTD_lazy2   },  /* level  7 */
-    { 17, 17, 17,  4,  4,  4, ZSTD_lazy2   },  /* level  8 */
-    { 17, 17, 17,  5,  4,  4, ZSTD_lazy2   },  /* level  9 */
-    { 17, 17, 17,  6,  4,  4, ZSTD_lazy2   },  /* level 10 */
-    { 17, 17, 17,  7,  4,  4, ZSTD_lazy2   },  /* level 11 */
-    { 17, 17, 17,  8,  4,  4, ZSTD_lazy2   },  /* level 12 */
-    { 17, 18, 17,  6,  4,  4, ZSTD_btlazy2 },  /* level 13.*/
-    { 17, 17, 17,  7,  3,  8, ZSTD_btopt   },  /* level 14.*/
-    { 17, 17, 17,  7,  3, 16, ZSTD_btopt   },  /* level 15.*/
-    { 17, 18, 17,  7,  3, 32, ZSTD_btopt   },  /* level 16.*/
-    { 17, 18, 17,  7,  3, 64, ZSTD_btopt   },  /* level 17.*/
-    { 17, 18, 17,  7,  3,256, ZSTD_btopt   },  /* level 18.*/
-    { 17, 18, 17,  8,  3,256, ZSTD_btopt   },  /* level 19.*/
-    { 17, 18, 17,  9,  3,256, ZSTD_btopt   },  /* level 20.*/
-    { 17, 18, 17, 10,  3,256, ZSTD_btopt   },  /* level 21.*/
-    { 17, 18, 17, 11,  3,256, ZSTD_btopt   },  /* level 22.*/
-},
-{   /* for srcSize <= 16 KB */
-    /* W,  C,  H,  S,  L,  T, strat */
-    {  0,  0,  0,  0,  0,  0, ZSTD_fast    },  /* level  0 -- never used */
-    { 14, 14, 14,  1,  4,  4, ZSTD_fast    },  /* level  1 */
-    { 14, 14, 15,  1,  4,  4, ZSTD_fast    },  /* level  2 */
-    { 14, 14, 14,  4,  4,  4, ZSTD_greedy  },  /* level  3.*/
-    { 14, 14, 14,  3,  4,  4, ZSTD_lazy    },  /* level  4.*/
-    { 14, 14, 14,  4,  4,  4, ZSTD_lazy2   },  /* level  5 */
-    { 14, 14, 14,  5,  4,  4, ZSTD_lazy2   },  /* level  6 */
-    { 14, 14, 14,  6,  4,  4, ZSTD_lazy2   },  /* level  7.*/
-    { 14, 14, 14,  7,  4,  4, ZSTD_lazy2   },  /* level  8.*/
-    { 14, 15, 14,  6,  4,  4, ZSTD_btlazy2 },  /* level  9.*/
-    { 14, 15, 14,  3,  3,  6, ZSTD_btopt   },  /* level 10.*/
-    { 14, 15, 14,  6,  3,  8, ZSTD_btopt   },  /* level 11.*/
-    { 14, 15, 14,  6,  3, 16, ZSTD_btopt   },  /* level 12.*/
-    { 14, 15, 14,  6,  3, 24, ZSTD_btopt   },  /* level 13.*/
-    { 14, 15, 15,  6,  3, 48, ZSTD_btopt   },  /* level 14.*/
-    { 14, 15, 15,  6,  3, 64, ZSTD_btopt   },  /* level 15.*/
-    { 14, 15, 15,  6,  3, 96, ZSTD_btopt   },  /* level 16.*/
-    { 14, 15, 15,  6,  3,128, ZSTD_btopt   },  /* level 17.*/
-    { 14, 15, 15,  6,  3,256, ZSTD_btopt   },  /* level 18.*/
-    { 14, 15, 15,  7,  3,256, ZSTD_btopt   },  /* level 19.*/
-    { 14, 15, 15,  8,  3,256, ZSTD_btopt   },  /* level 20.*/
-    { 14, 15, 15,  9,  3,256, ZSTD_btopt   },  /* level 21.*/
-    { 14, 15, 15, 10,  3,256, ZSTD_btopt   },  /* level 22.*/
-},
-};
-
-/*! ZSTD_getParams() :
-*   @return ZSTD_parameters structure for a selected compression level and srcSize.
-*   `srcSize` value is optional, select 0 if not known */
-ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, U64 srcSize, size_t dictSize)
-{
-    ZSTD_compressionParameters cp;
-    size_t const addedSize = srcSize ? 0 : 500;
-    U64 const rSize = srcSize+dictSize ? srcSize+dictSize+addedSize : (U64)-1;
-    U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);   /* intentional underflow for srcSizeHint == 0 */
+unsigned ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; } 
+ 
+static const ZSTD_compressionParameters ZSTD_defaultCParameters[4][ZSTD_MAX_CLEVEL+1] = { 
+{   /* "default" */ 
+    /* W,  C,  H,  S,  L, TL, strat */ 
+    {  0,  0,  0,  0,  0,  0, ZSTD_fast    },  /* level  0 - never used */ 
+    { 19, 13, 14,  1,  7,  4, ZSTD_fast    },  /* level  1 */ 
+    { 19, 15, 16,  1,  6,  4, ZSTD_fast    },  /* level  2 */ 
+    { 20, 18, 20,  1,  6,  4, ZSTD_fast    },  /* level  3 */ 
+    { 20, 13, 17,  2,  5,  4, ZSTD_greedy  },  /* level  4.*/ 
+    { 20, 15, 18,  3,  5,  4, ZSTD_greedy  },  /* level  5 */ 
+    { 21, 16, 19,  2,  5,  4, ZSTD_lazy    },  /* level  6 */ 
+    { 21, 17, 20,  3,  5,  4, ZSTD_lazy    },  /* level  7 */ 
+    { 21, 18, 20,  3,  5,  4, ZSTD_lazy2   },  /* level  8.*/ 
+    { 21, 20, 20,  3,  5,  4, ZSTD_lazy2   },  /* level  9 */ 
+    { 21, 19, 21,  4,  5,  4, ZSTD_lazy2   },  /* level 10 */ 
+    { 22, 20, 22,  4,  5,  4, ZSTD_lazy2   },  /* level 11 */ 
+    { 22, 20, 22,  5,  5,  4, ZSTD_lazy2   },  /* level 12 */ 
+    { 22, 21, 22,  5,  5,  4, ZSTD_lazy2   },  /* level 13 */ 
+    { 22, 21, 22,  6,  5,  4, ZSTD_lazy2   },  /* level 14 */ 
+    { 22, 21, 21,  5,  5,  4, ZSTD_btlazy2 },  /* level 15 */ 
+    { 23, 22, 22,  5,  5,  4, ZSTD_btlazy2 },  /* level 16 */ 
+    { 23, 23, 22,  5,  5,  4, ZSTD_btlazy2 },  /* level 17.*/ 
+    { 23, 23, 22,  6,  5, 24, ZSTD_btopt   },  /* level 18.*/ 
+    { 23, 23, 22,  6,  3, 48, ZSTD_btopt   },  /* level 19.*/ 
+    { 25, 26, 23,  7,  3, 64, ZSTD_btopt   },  /* level 20.*/ 
+    { 26, 26, 23,  7,  3,256, ZSTD_btopt   },  /* level 21.*/ 
+    { 27, 27, 25,  9,  3,512, ZSTD_btopt   },  /* level 22.*/ 
+}, 
+{   /* for srcSize <= 256 KB */ 
+    /* W,  C,  H,  S,  L,  T, strat */ 
+    {  0,  0,  0,  0,  0,  0, ZSTD_fast    },  /* level  0 */ 
+    { 18, 13, 14,  1,  6,  4, ZSTD_fast    },  /* level  1 */ 
+    { 18, 15, 17,  1,  5,  4, ZSTD_fast    },  /* level  2 */ 
+    { 18, 13, 15,  1,  5,  4, ZSTD_greedy  },  /* level  3.*/ 
+    { 18, 15, 17,  1,  5,  4, ZSTD_greedy  },  /* level  4.*/ 
+    { 18, 16, 17,  4,  5,  4, ZSTD_greedy  },  /* level  5 */ 
+    { 18, 17, 17,  5,  5,  4, ZSTD_greedy  },  /* level  6 */ 
+    { 18, 17, 17,  4,  4,  4, ZSTD_lazy    },  /* level  7 */ 
+    { 18, 17, 17,  4,  4,  4, ZSTD_lazy2   },  /* level  8 */ 
+    { 18, 17, 17,  5,  4,  4, ZSTD_lazy2   },  /* level  9 */ 
+    { 18, 17, 17,  6,  4,  4, ZSTD_lazy2   },  /* level 10 */ 
+    { 18, 18, 17,  6,  4,  4, ZSTD_lazy2   },  /* level 11.*/ 
+    { 18, 18, 17,  7,  4,  4, ZSTD_lazy2   },  /* level 12.*/ 
+    { 18, 19, 17,  7,  4,  4, ZSTD_btlazy2 },  /* level 13 */ 
+    { 18, 18, 18,  4,  4, 16, ZSTD_btopt   },  /* level 14.*/ 
+    { 18, 18, 18,  8,  4, 24, ZSTD_btopt   },  /* level 15.*/ 
+    { 18, 19, 18,  8,  3, 48, ZSTD_btopt   },  /* level 16.*/ 
+    { 18, 19, 18,  8,  3, 96, ZSTD_btopt   },  /* level 17.*/ 
+    { 18, 19, 18,  9,  3,128, ZSTD_btopt   },  /* level 18.*/ 
+    { 18, 19, 18, 10,  3,256, ZSTD_btopt   },  /* level 19.*/ 
+    { 18, 19, 18, 11,  3,512, ZSTD_btopt   },  /* level 20.*/ 
+    { 18, 19, 18, 12,  3,512, ZSTD_btopt   },  /* level 21.*/ 
+    { 18, 19, 18, 13,  3,512, ZSTD_btopt   },  /* level 22.*/ 
+}, 
+{   /* for srcSize <= 128 KB */ 
+    /* W,  C,  H,  S,  L,  T, strat */ 
+    {  0,  0,  0,  0,  0,  0, ZSTD_fast    },  /* level  0 - never used */ 
+    { 17, 12, 13,  1,  6,  4, ZSTD_fast    },  /* level  1 */ 
+    { 17, 13, 16,  1,  5,  4, ZSTD_fast    },  /* level  2 */ 
+    { 17, 13, 14,  2,  5,  4, ZSTD_greedy  },  /* level  3 */ 
+    { 17, 13, 15,  3,  4,  4, ZSTD_greedy  },  /* level  4 */ 
+    { 17, 15, 17,  4,  4,  4, ZSTD_greedy  },  /* level  5 */ 
+    { 17, 16, 17,  3,  4,  4, ZSTD_lazy    },  /* level  6 */ 
+    { 17, 15, 17,  4,  4,  4, ZSTD_lazy2   },  /* level  7 */ 
+    { 17, 17, 17,  4,  4,  4, ZSTD_lazy2   },  /* level  8 */ 
+    { 17, 17, 17,  5,  4,  4, ZSTD_lazy2   },  /* level  9 */ 
+    { 17, 17, 17,  6,  4,  4, ZSTD_lazy2   },  /* level 10 */ 
+    { 17, 17, 17,  7,  4,  4, ZSTD_lazy2   },  /* level 11 */ 
+    { 17, 17, 17,  8,  4,  4, ZSTD_lazy2   },  /* level 12 */ 
+    { 17, 18, 17,  6,  4,  4, ZSTD_btlazy2 },  /* level 13.*/ 
+    { 17, 17, 17,  7,  3,  8, ZSTD_btopt   },  /* level 14.*/ 
+    { 17, 17, 17,  7,  3, 16, ZSTD_btopt   },  /* level 15.*/ 
+    { 17, 18, 17,  7,  3, 32, ZSTD_btopt   },  /* level 16.*/ 
+    { 17, 18, 17,  7,  3, 64, ZSTD_btopt   },  /* level 17.*/ 
+    { 17, 18, 17,  7,  3,256, ZSTD_btopt   },  /* level 18.*/ 
+    { 17, 18, 17,  8,  3,256, ZSTD_btopt   },  /* level 19.*/ 
+    { 17, 18, 17,  9,  3,256, ZSTD_btopt   },  /* level 20.*/ 
+    { 17, 18, 17, 10,  3,256, ZSTD_btopt   },  /* level 21.*/ 
+    { 17, 18, 17, 11,  3,256, ZSTD_btopt   },  /* level 22.*/ 
+}, 
+{   /* for srcSize <= 16 KB */ 
+    /* W,  C,  H,  S,  L,  T, strat */ 
+    {  0,  0,  0,  0,  0,  0, ZSTD_fast    },  /* level  0 -- never used */ 
+    { 14, 14, 14,  1,  4,  4, ZSTD_fast    },  /* level  1 */ 
+    { 14, 14, 15,  1,  4,  4, ZSTD_fast    },  /* level  2 */ 
+    { 14, 14, 14,  4,  4,  4, ZSTD_greedy  },  /* level  3.*/ 
+    { 14, 14, 14,  3,  4,  4, ZSTD_lazy    },  /* level  4.*/ 
+    { 14, 14, 14,  4,  4,  4, ZSTD_lazy2   },  /* level  5 */ 
+    { 14, 14, 14,  5,  4,  4, ZSTD_lazy2   },  /* level  6 */ 
+    { 14, 14, 14,  6,  4,  4, ZSTD_lazy2   },  /* level  7.*/ 
+    { 14, 14, 14,  7,  4,  4, ZSTD_lazy2   },  /* level  8.*/ 
+    { 14, 15, 14,  6,  4,  4, ZSTD_btlazy2 },  /* level  9.*/ 
+    { 14, 15, 14,  3,  3,  6, ZSTD_btopt   },  /* level 10.*/ 
+    { 14, 15, 14,  6,  3,  8, ZSTD_btopt   },  /* level 11.*/ 
+    { 14, 15, 14,  6,  3, 16, ZSTD_btopt   },  /* level 12.*/ 
+    { 14, 15, 14,  6,  3, 24, ZSTD_btopt   },  /* level 13.*/ 
+    { 14, 15, 15,  6,  3, 48, ZSTD_btopt   },  /* level 14.*/ 
+    { 14, 15, 15,  6,  3, 64, ZSTD_btopt   },  /* level 15.*/ 
+    { 14, 15, 15,  6,  3, 96, ZSTD_btopt   },  /* level 16.*/ 
+    { 14, 15, 15,  6,  3,128, ZSTD_btopt   },  /* level 17.*/ 
+    { 14, 15, 15,  6,  3,256, ZSTD_btopt   },  /* level 18.*/ 
+    { 14, 15, 15,  7,  3,256, ZSTD_btopt   },  /* level 19.*/ 
+    { 14, 15, 15,  8,  3,256, ZSTD_btopt   },  /* level 20.*/ 
+    { 14, 15, 15,  9,  3,256, ZSTD_btopt   },  /* level 21.*/ 
+    { 14, 15, 15, 10,  3,256, ZSTD_btopt   },  /* level 22.*/ 
+}, 
+}; 
+ 
+/*! ZSTD_getParams() : 
+*   @return ZSTD_parameters structure for a selected compression level and srcSize. 
+*   `srcSize` value is optional, select 0 if not known */ 
+ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, U64 srcSize, size_t dictSize) 
+{ 
+    ZSTD_compressionParameters cp; 
+    size_t const addedSize = srcSize ? 0 : 500; 
+    U64 const rSize = srcSize+dictSize ? srcSize+dictSize+addedSize : (U64)-1; 
+    U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);   /* intentional underflow for srcSizeHint == 0 */ 
     if (compressionLevel < 0) compressionLevel = ZSTD_DEFAULT_CLEVEL;
     if (compressionLevel==0) compressionLevel = 1;
-    if (compressionLevel > ZSTD_MAX_CLEVEL) compressionLevel = ZSTD_MAX_CLEVEL;
-    cp = ZSTD_defaultCParameters[tableID][compressionLevel];
-    if (MEM_32bits()) {   /* auto-correction, for 32-bits mode */
-        if (cp.windowLog > ZSTD_WINDOWLOG_MAX) cp.windowLog = ZSTD_WINDOWLOG_MAX;
-        if (cp.chainLog > ZSTD_CHAINLOG_MAX) cp.chainLog = ZSTD_CHAINLOG_MAX;
-        if (cp.hashLog > ZSTD_HASHLOG_MAX) cp.hashLog = ZSTD_HASHLOG_MAX;
-    }
-    return cp;
-}
+    if (compressionLevel > ZSTD_MAX_CLEVEL) compressionLevel = ZSTD_MAX_CLEVEL; 
+    cp = ZSTD_defaultCParameters[tableID][compressionLevel]; 
+    if (MEM_32bits()) {   /* auto-correction, for 32-bits mode */ 
+        if (cp.windowLog > ZSTD_WINDOWLOG_MAX) cp.windowLog = ZSTD_WINDOWLOG_MAX; 
+        if (cp.chainLog > ZSTD_CHAINLOG_MAX) cp.chainLog = ZSTD_CHAINLOG_MAX; 
+        if (cp.hashLog > ZSTD_HASHLOG_MAX) cp.hashLog = ZSTD_HASHLOG_MAX; 
+    } 
+    return cp; 
+} 
diff --git a/contrib/libs/zstd06/decompress/zstd_decompress.c b/contrib/libs/zstd06/decompress/zstd_decompress.c
index 177e9c8a21..c4ce3f81d8 100644
--- a/contrib/libs/zstd06/decompress/zstd_decompress.c
+++ b/contrib/libs/zstd06/decompress/zstd_decompress.c
@@ -1,88 +1,88 @@
-/*
-    zstd - standard compression library
-    Copyright (C) 2014-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
-*/
-
-/* ***************************************************************
-*  Tuning parameters
-*****************************************************************/
-/*!
- * HEAPMODE :
- * Select how default decompression function ZSTD_decompress() will allocate memory,
- * in memory stack (0), or in memory heap (1, requires malloc())
- */
-#ifndef ZSTD_HEAPMODE
-#  define ZSTD_HEAPMODE 1
-#endif
-
-/*!
-*  LEGACY_SUPPORT :
-*  if set to 1, ZSTD_decompress() can decode older formats (v0.1+)
-*/
-#ifndef ZSTD_LEGACY_SUPPORT
-#  define ZSTD_LEGACY_SUPPORT 0
-#endif
-
-
-/*-*******************************************************
-*  Dependencies
-*********************************************************/
-#include <stdlib.h>      /* calloc */
-#include <string.h>      /* memcpy, memmove */
-#include <stdio.h>       /* debug only : printf */
-#include "mem.h"         /* low level memory routines */
-#include "zstd_internal.h"
-#include "fse_static.h"
+/* 
+    zstd - standard compression library 
+    Copyright (C) 2014-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 
+*/ 
+ 
+/* *************************************************************** 
+*  Tuning parameters 
+*****************************************************************/ 
+/*! 
+ * HEAPMODE : 
+ * Select how default decompression function ZSTD_decompress() will allocate memory, 
+ * in memory stack (0), or in memory heap (1, requires malloc()) 
+ */ 
+#ifndef ZSTD_HEAPMODE 
+#  define ZSTD_HEAPMODE 1 
+#endif 
+ 
+/*! 
+*  LEGACY_SUPPORT : 
+*  if set to 1, ZSTD_decompress() can decode older formats (v0.1+) 
+*/ 
+#ifndef ZSTD_LEGACY_SUPPORT 
+#  define ZSTD_LEGACY_SUPPORT 0 
+#endif 
+ 
+ 
+/*-******************************************************* 
+*  Dependencies 
+*********************************************************/ 
+#include <stdlib.h>      /* calloc */ 
+#include <string.h>      /* memcpy, memmove */ 
+#include <stdio.h>       /* debug only : printf */ 
+#include "mem.h"         /* low level memory routines */ 
+#include "zstd_internal.h" 
+#include "fse_static.h" 
 #include "huf_static.h"
-
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT==1)
-#  include "zstd_legacy.h"
-#endif
-
-
-/*-*******************************************************
-*  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 : 4324)        /* disable: C4324: padded structure */
-#else
-#  ifdef __GNUC__
-#    define FORCE_INLINE static inline __attribute__((always_inline))
-#  else
-#    define FORCE_INLINE static inline
-#  endif
-#endif
-
-
+ 
+#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT==1) 
+#  include "zstd_legacy.h" 
+#endif 
+ 
+ 
+/*-******************************************************* 
+*  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 : 4324)        /* disable: C4324: padded structure */ 
+#else 
+#  ifdef __GNUC__ 
+#    define FORCE_INLINE static inline __attribute__((always_inline)) 
+#  else 
+#    define FORCE_INLINE static inline 
+#  endif 
+#endif 
+ 
+ 
 /*-*************************************
 *  Macros
 ***************************************/
@@ -91,892 +91,892 @@
 #define HUF_isError  ERR_isError
 
 
-/*_*******************************************************
-*  Memory operations
-**********************************************************/
-static void ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
-
-
-/*-*************************************************************
-*   Context management
-***************************************************************/
-typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,
-               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock } ZSTD_dStage;
-
-struct ZSTD_DCtx_s
-{
-    FSE_DTable LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)];
-    FSE_DTable OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)];
-    FSE_DTable MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)];
-    unsigned   hufTableX4[HUF_DTABLE_SIZE(HufLog)];
-    const void* previousDstEnd;
-    const void* base;
-    const void* vBase;
-    const void* dictEnd;
-    size_t expected;
-    size_t headerSize;
-    ZSTD_frameParams fParams;
-    blockType_t bType;   /* used in ZSTD_decompressContinue(), to transfer blockType between header decoding and block decoding stages */
-    ZSTD_dStage stage;
-    U32 flagRepeatTable;
-    const BYTE* litPtr;
-    size_t litBufSize;
-    size_t litSize;
-    BYTE litBuffer[ZSTD_BLOCKSIZE_MAX + WILDCOPY_OVERLENGTH];
-    BYTE headerBuffer[ZSTD_FRAMEHEADERSIZE_MAX];
-};  /* typedef'd to ZSTD_DCtx within "zstd_static.h" */
-
-size_t ZSTD_sizeofDCtx (void) { return sizeof(ZSTD_DCtx); }   /* non published interface */
-
-size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx)
-{
-    dctx->expected = ZSTD_frameHeaderSize_min;
-    dctx->stage = ZSTDds_getFrameHeaderSize;
-    dctx->previousDstEnd = NULL;
-    dctx->base = NULL;
-    dctx->vBase = NULL;
-    dctx->dictEnd = NULL;
-    dctx->hufTableX4[0] = HufLog;
-    dctx->flagRepeatTable = 0;
-    return 0;
-}
-
-ZSTD_DCtx* ZSTD_createDCtx(void)
-{
-    ZSTD_DCtx* dctx = (ZSTD_DCtx*)malloc(sizeof(ZSTD_DCtx));
-    if (dctx==NULL) return NULL;
-    ZSTD_decompressBegin(dctx);
-    return dctx;
-}
-
-size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
-{
-    free(dctx);
-    return 0;   /* reserved as a potential error code in the future */
-}
-
-void ZSTD_copyDCtx(ZSTD_DCtx* dstDCtx, const ZSTD_DCtx* srcDCtx)
-{
-    memcpy(dstDCtx, srcDCtx,
-           sizeof(ZSTD_DCtx) - (ZSTD_BLOCKSIZE_MAX+WILDCOPY_OVERLENGTH + ZSTD_frameHeaderSize_max));  /* no need to copy workspace */
-}
-
-
-/*-*************************************************************
-*   Decompression section
-***************************************************************/
-
-/* Frame format description
-   Frame Header -  [ Block Header - Block ] - Frame End
-   1) Frame Header
-      - 4 bytes - Magic Number : ZSTD_MAGICNUMBER (defined within zstd_static.h)
-      - 1 byte  - Frame Descriptor
-   2) Block Header
-      - 3 bytes, starting with a 2-bits descriptor
-                 Uncompressed, Compressed, Frame End, unused
-   3) Block
-      See Block Format Description
-   4) Frame End
-      - 3 bytes, compatible with Block Header
-*/
-
-
-/* Frame descriptor
-
-   1 byte, using :
-   bit 0-3 : windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN   (see zstd_internal.h)
-   bit 4   : minmatch 4(0) or 3(1)
-   bit 5   : reserved (must be zero)
-   bit 6-7 : Frame content size : unknown, 1 byte, 2 bytes, 8 bytes
-
-   Optional : content size (0, 1, 2 or 8 bytes)
-   0 : unknown
-   1 : 0-255 bytes
-   2 : 256 - 65535+256
-   8 : up to 16 exa
-*/
-
-
-/* Compressed Block, format description
-
-   Block = Literal Section - Sequences Section
-   Prerequisite : size of (compressed) block, maximum size of regenerated data
-
-   1) Literal Section
-
-   1.1) Header : 1-5 bytes
-        flags: 2 bits
-            00 compressed by Huff0
-            01 unused
-            10 is Raw (uncompressed)
-            11 is Rle
-            Note : using 01 => Huff0 with precomputed table ?
-            Note : delta map ? => compressed ?
-
-   1.1.1) Huff0-compressed literal block : 3-5 bytes
-            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream
-            srcSize < 1 KB => 3 bytes (2-2-10-10)
-            srcSize < 16KB => 4 bytes (2-2-14-14)
-            else           => 5 bytes (2-2-18-18)
-            big endian convention
-
-   1.1.2) Raw (uncompressed) literal block header : 1-3 bytes
-        size :  5 bits: (IS_RAW<<6) + (0<<4) + size
-               12 bits: (IS_RAW<<6) + (2<<4) + (size>>8)
-                        size&255
-               20 bits: (IS_RAW<<6) + (3<<4) + (size>>16)
-                        size>>8&255
-                        size&255
-
-   1.1.3) Rle (repeated single byte) literal block header : 1-3 bytes
-        size :  5 bits: (IS_RLE<<6) + (0<<4) + size
-               12 bits: (IS_RLE<<6) + (2<<4) + (size>>8)
-                        size&255
-               20 bits: (IS_RLE<<6) + (3<<4) + (size>>16)
-                        size>>8&255
-                        size&255
-
-   1.1.4) Huff0-compressed literal block, using precomputed CTables : 3-5 bytes
-            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream
-            srcSize < 1 KB => 3 bytes (2-2-10-10)
-            srcSize < 16KB => 4 bytes (2-2-14-14)
-            else           => 5 bytes (2-2-18-18)
-            big endian convention
-
-        1- CTable available (stored into workspace ?)
-        2- Small input (fast heuristic ? Full comparison ? depend on clevel ?)
-
-
-   1.2) Literal block content
-
-   1.2.1) Huff0 block, using sizes from header
-        See Huff0 format
-
-   1.2.2) Huff0 block, using prepared table
-
-   1.2.3) Raw content
-
-   1.2.4) single byte
-
-
-   2) Sequences section
-      TO DO
-*/
-
-/** ZSTD_frameHeaderSize() :
-*   srcSize must be >= ZSTD_frameHeaderSize_min.
-*   @return : size of the Frame Header */
-static size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize)
-{
-    if (srcSize < ZSTD_frameHeaderSize_min) return ERROR(srcSize_wrong);
+/*_******************************************************* 
+*  Memory operations 
+**********************************************************/ 
+static void ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); } 
+ 
+ 
+/*-************************************************************* 
+*   Context management 
+***************************************************************/ 
+typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader, 
+               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock } ZSTD_dStage; 
+ 
+struct ZSTD_DCtx_s 
+{ 
+    FSE_DTable LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)]; 
+    FSE_DTable OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)]; 
+    FSE_DTable MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)]; 
+    unsigned   hufTableX4[HUF_DTABLE_SIZE(HufLog)]; 
+    const void* previousDstEnd; 
+    const void* base; 
+    const void* vBase; 
+    const void* dictEnd; 
+    size_t expected; 
+    size_t headerSize; 
+    ZSTD_frameParams fParams; 
+    blockType_t bType;   /* used in ZSTD_decompressContinue(), to transfer blockType between header decoding and block decoding stages */ 
+    ZSTD_dStage stage; 
+    U32 flagRepeatTable; 
+    const BYTE* litPtr; 
+    size_t litBufSize; 
+    size_t litSize; 
+    BYTE litBuffer[ZSTD_BLOCKSIZE_MAX + WILDCOPY_OVERLENGTH]; 
+    BYTE headerBuffer[ZSTD_FRAMEHEADERSIZE_MAX]; 
+};  /* typedef'd to ZSTD_DCtx within "zstd_static.h" */ 
+ 
+size_t ZSTD_sizeofDCtx (void) { return sizeof(ZSTD_DCtx); }   /* non published interface */ 
+ 
+size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx) 
+{ 
+    dctx->expected = ZSTD_frameHeaderSize_min; 
+    dctx->stage = ZSTDds_getFrameHeaderSize; 
+    dctx->previousDstEnd = NULL; 
+    dctx->base = NULL; 
+    dctx->vBase = NULL; 
+    dctx->dictEnd = NULL; 
+    dctx->hufTableX4[0] = HufLog; 
+    dctx->flagRepeatTable = 0; 
+    return 0; 
+} 
+ 
+ZSTD_DCtx* ZSTD_createDCtx(void) 
+{ 
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)malloc(sizeof(ZSTD_DCtx)); 
+    if (dctx==NULL) return NULL; 
+    ZSTD_decompressBegin(dctx); 
+    return dctx; 
+} 
+ 
+size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx) 
+{ 
+    free(dctx); 
+    return 0;   /* reserved as a potential error code in the future */ 
+} 
+ 
+void ZSTD_copyDCtx(ZSTD_DCtx* dstDCtx, const ZSTD_DCtx* srcDCtx) 
+{ 
+    memcpy(dstDCtx, srcDCtx, 
+           sizeof(ZSTD_DCtx) - (ZSTD_BLOCKSIZE_MAX+WILDCOPY_OVERLENGTH + ZSTD_frameHeaderSize_max));  /* no need to copy workspace */ 
+} 
+ 
+ 
+/*-************************************************************* 
+*   Decompression section 
+***************************************************************/ 
+ 
+/* Frame format description 
+   Frame Header -  [ Block Header - Block ] - Frame End 
+   1) Frame Header 
+      - 4 bytes - Magic Number : ZSTD_MAGICNUMBER (defined within zstd_static.h) 
+      - 1 byte  - Frame Descriptor 
+   2) Block Header 
+      - 3 bytes, starting with a 2-bits descriptor 
+                 Uncompressed, Compressed, Frame End, unused 
+   3) Block 
+      See Block Format Description 
+   4) Frame End 
+      - 3 bytes, compatible with Block Header 
+*/ 
+ 
+ 
+/* Frame descriptor 
+ 
+   1 byte, using : 
+   bit 0-3 : windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN   (see zstd_internal.h) 
+   bit 4   : minmatch 4(0) or 3(1) 
+   bit 5   : reserved (must be zero) 
+   bit 6-7 : Frame content size : unknown, 1 byte, 2 bytes, 8 bytes 
+ 
+   Optional : content size (0, 1, 2 or 8 bytes) 
+   0 : unknown 
+   1 : 0-255 bytes 
+   2 : 256 - 65535+256 
+   8 : up to 16 exa 
+*/ 
+ 
+ 
+/* Compressed Block, format description 
+ 
+   Block = Literal Section - Sequences Section 
+   Prerequisite : size of (compressed) block, maximum size of regenerated data 
+ 
+   1) Literal Section 
+ 
+   1.1) Header : 1-5 bytes 
+        flags: 2 bits 
+            00 compressed by Huff0 
+            01 unused 
+            10 is Raw (uncompressed) 
+            11 is Rle 
+            Note : using 01 => Huff0 with precomputed table ? 
+            Note : delta map ? => compressed ? 
+ 
+   1.1.1) Huff0-compressed literal block : 3-5 bytes 
+            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream 
+            srcSize < 1 KB => 3 bytes (2-2-10-10) 
+            srcSize < 16KB => 4 bytes (2-2-14-14) 
+            else           => 5 bytes (2-2-18-18) 
+            big endian convention 
+ 
+   1.1.2) Raw (uncompressed) literal block header : 1-3 bytes 
+        size :  5 bits: (IS_RAW<<6) + (0<<4) + size 
+               12 bits: (IS_RAW<<6) + (2<<4) + (size>>8) 
+                        size&255 
+               20 bits: (IS_RAW<<6) + (3<<4) + (size>>16) 
+                        size>>8&255 
+                        size&255 
+ 
+   1.1.3) Rle (repeated single byte) literal block header : 1-3 bytes 
+        size :  5 bits: (IS_RLE<<6) + (0<<4) + size 
+               12 bits: (IS_RLE<<6) + (2<<4) + (size>>8) 
+                        size&255 
+               20 bits: (IS_RLE<<6) + (3<<4) + (size>>16) 
+                        size>>8&255 
+                        size&255 
+ 
+   1.1.4) Huff0-compressed literal block, using precomputed CTables : 3-5 bytes 
+            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream 
+            srcSize < 1 KB => 3 bytes (2-2-10-10) 
+            srcSize < 16KB => 4 bytes (2-2-14-14) 
+            else           => 5 bytes (2-2-18-18) 
+            big endian convention 
+ 
+        1- CTable available (stored into workspace ?) 
+        2- Small input (fast heuristic ? Full comparison ? depend on clevel ?) 
+ 
+ 
+   1.2) Literal block content 
+ 
+   1.2.1) Huff0 block, using sizes from header 
+        See Huff0 format 
+ 
+   1.2.2) Huff0 block, using prepared table 
+ 
+   1.2.3) Raw content 
+ 
+   1.2.4) single byte 
+ 
+ 
+   2) Sequences section 
+      TO DO 
+*/ 
+ 
+/** ZSTD_frameHeaderSize() : 
+*   srcSize must be >= ZSTD_frameHeaderSize_min. 
+*   @return : size of the Frame Header */ 
+static size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize) 
+{ 
+    if (srcSize < ZSTD_frameHeaderSize_min) return ERROR(srcSize_wrong); 
     { U32 const fcsId = (((const BYTE*)src)[4]) >> 6;
       return ZSTD_frameHeaderSize_min + ZSTD_fcs_fieldSize[fcsId]; }
-}
-
-
-/** ZSTD_getFrameParams() :
-*   decode Frame Header, or provide expected `srcSize`.
-*   @return : 0, `fparamsPtr` is correctly filled,
-*            >0, `srcSize` is too small, result is expected `srcSize`,
-*             or an error code, which can be tested using ZSTD_isError() */
-size_t ZSTD_getFrameParams(ZSTD_frameParams* fparamsPtr, const void* src, size_t srcSize)
-{
-    const BYTE* ip = (const BYTE*)src;
-
-    if (srcSize < ZSTD_frameHeaderSize_min) return ZSTD_frameHeaderSize_min;
-    if (MEM_readLE32(src) != ZSTD_MAGICNUMBER) return ERROR(prefix_unknown);
-
-    /* ensure there is enough `srcSize` to fully read/decode frame header */
-    { size_t const fhsize = ZSTD_frameHeaderSize(src, srcSize);
-      if (srcSize < fhsize) return fhsize; }
-
-    memset(fparamsPtr, 0, sizeof(*fparamsPtr));
-    {   BYTE const frameDesc = ip[4];
-        fparamsPtr->windowLog = (frameDesc & 0xF) + ZSTD_WINDOWLOG_ABSOLUTEMIN;
-        if ((frameDesc & 0x20) != 0) return ERROR(frameParameter_unsupported);   /* reserved 1 bit */
-        switch(frameDesc >> 6)  /* fcsId */
-        {
-            default:   /* impossible */
-            case 0 : fparamsPtr->frameContentSize = 0; break;
-            case 1 : fparamsPtr->frameContentSize = ip[5]; break;
-            case 2 : fparamsPtr->frameContentSize = MEM_readLE16(ip+5)+256; break;
-            case 3 : fparamsPtr->frameContentSize = MEM_readLE64(ip+5); break;
-    }   }
-    return 0;
-}
-
-
-/** ZSTD_decodeFrameHeader() :
-*   `srcSize` must be the size provided by ZSTD_frameHeaderSize().
-*   @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */
-static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* zc, const void* src, size_t srcSize)
-{
-    size_t const result = ZSTD_getFrameParams(&(zc->fParams), src, srcSize);
-    if ((MEM_32bits()) && (zc->fParams.windowLog > 25)) return ERROR(frameParameter_unsupportedBy32bits);
-    return result;
-}
-
-
-typedef struct
-{
-    blockType_t blockType;
-    U32 origSize;
-} blockProperties_t;
-
-/*! ZSTD_getcBlockSize() :
-*   Provides the size of compressed block from block header `src` */
-size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
-{
-    const BYTE* const in = (const BYTE* const)src;
-    U32 cSize;
-
-    if (srcSize < ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
-
-    bpPtr->blockType = (blockType_t)((*in) >> 6);
-    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);
-    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;
-
-    if (bpPtr->blockType == bt_end) return 0;
-    if (bpPtr->blockType == bt_rle) return 1;
-    return cSize;
-}
-
-
-static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall);
-    memcpy(dst, src, srcSize);
-    return srcSize;
-}
-
-
-/*! ZSTD_decodeLiteralsBlock() :
-    @return : nb of bytes read from src (< srcSize ) */
-size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
-                          const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */
-{
-    const BYTE* const istart = (const BYTE*) src;
-
-    /* any compressed block with literals segment must be at least this size */
-    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
-
-    switch(istart[0]>> 6)
-    {
-    case IS_HUF:
-        {   size_t litSize, litCSize, singleStream=0;
-            U32 lhSize = ((istart[0]) >> 4) & 3;
-            if (srcSize < 5) return ERROR(corruption_detected);   /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for lhSize, + cSize (+nbSeq) */
-            switch(lhSize)
-            {
-            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
-                /* 2 - 2 - 10 - 10 */
-                lhSize=3;
-                singleStream = istart[0] & 16;
-                litSize  = ((istart[0] & 15) << 6) + (istart[1] >> 2);
-                litCSize = ((istart[1] &  3) << 8) + istart[2];
-                break;
-            case 2:
-                /* 2 - 2 - 14 - 14 */
-                lhSize=4;
-                litSize  = ((istart[0] & 15) << 10) + (istart[1] << 2) + (istart[2] >> 6);
-                litCSize = ((istart[2] & 63) <<  8) + istart[3];
-                break;
-            case 3:
-                /* 2 - 2 - 18 - 18 */
-                lhSize=5;
-                litSize  = ((istart[0] & 15) << 14) + (istart[1] << 6) + (istart[2] >> 2);
-                litCSize = ((istart[2] &  3) << 16) + (istart[3] << 8) + istart[4];
-                break;
-            }
-            if (litSize > ZSTD_BLOCKSIZE_MAX) return ERROR(corruption_detected);
-            if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
-
-            if (HUF_isError(singleStream ?
-                            HUF_decompress1X2(dctx->litBuffer, litSize, istart+lhSize, litCSize) :
-                            HUF_decompress   (dctx->litBuffer, litSize, istart+lhSize, litCSize) ))
-                return ERROR(corruption_detected);
-
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litBufSize = ZSTD_BLOCKSIZE_MAX+8;
-            dctx->litSize = litSize;
-            return litCSize + lhSize;
-        }
-    case IS_PCH:
-        {   size_t litSize, litCSize;
-            U32 lhSize = ((istart[0]) >> 4) & 3;
-            if (lhSize != 1)  /* only case supported for now : small litSize, single stream */
-                return ERROR(corruption_detected);
-            if (!dctx->flagRepeatTable)
-                return ERROR(dictionary_corrupted);
-
-            /* 2 - 2 - 10 - 10 */
-            lhSize=3;
-            litSize  = ((istart[0] & 15) << 6) + (istart[1] >> 2);
-            litCSize = ((istart[1] &  3) << 8) + istart[2];
-
-            {   size_t const errorCode = HUF_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTableX4);
-                if (HUF_isError(errorCode)) return ERROR(corruption_detected);
-            }
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litBufSize = ZSTD_BLOCKSIZE_MAX+WILDCOPY_OVERLENGTH;
-            dctx->litSize = litSize;
-            return litCSize + lhSize;
-        }
-    case IS_RAW:
-        {   size_t litSize;
-            U32 lhSize = ((istart[0]) >> 4) & 3;
-            switch(lhSize)
-            {
-            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
-                lhSize=1;
-                litSize = istart[0] & 31;
-                break;
-            case 2:
-                litSize = ((istart[0] & 15) << 8) + istart[1];
-                break;
-            case 3:
-                litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];
-                break;
-            }
-
-            if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) {  /* risk reading beyond src buffer with wildcopy */
-                if (litSize+lhSize > srcSize) return ERROR(corruption_detected);
-                memcpy(dctx->litBuffer, istart+lhSize, litSize);
-                dctx->litPtr = dctx->litBuffer;
-                dctx->litBufSize = ZSTD_BLOCKSIZE_MAX+8;
-                dctx->litSize = litSize;
-                return lhSize+litSize;
-            }
-            /* direct reference into compressed stream */
-            dctx->litPtr = istart+lhSize;
-            dctx->litBufSize = srcSize-lhSize;
-            dctx->litSize = litSize;
-            return lhSize+litSize;
-        }
-    case IS_RLE:
-        {   size_t litSize;
-            U32 lhSize = ((istart[0]) >> 4) & 3;
-            switch(lhSize)
-            {
-            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
-                lhSize = 1;
-                litSize = istart[0] & 31;
-                break;
-            case 2:
-                litSize = ((istart[0] & 15) << 8) + istart[1];
-                break;
-            case 3:
-                litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];
-                if (srcSize<4) return ERROR(corruption_detected);   /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4 */
-                break;
-            }
-            if (litSize > ZSTD_BLOCKSIZE_MAX) return ERROR(corruption_detected);
-            memset(dctx->litBuffer, istart[lhSize], litSize);
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litBufSize = ZSTD_BLOCKSIZE_MAX+WILDCOPY_OVERLENGTH;
-            dctx->litSize = litSize;
-            return lhSize+1;
-        }
-    default:
-        return ERROR(corruption_detected);   /* impossible */
-    }
-}
-
-
-/*! ZSTD_buildSeqTable() :
-    @return : nb bytes read from src,
-              or an error code if it fails, testable with ZSTD_isError()
-*/
-FORCE_INLINE size_t ZSTD_buildSeqTable(FSE_DTable* DTable, U32 type, U32 max, U32 maxLog,
-                                 const void* src, size_t srcSize,
-                                 const S16* defaultNorm, U32 defaultLog, U32 flagRepeatTable)
-{
-    switch(type)
-    {
-    case FSE_ENCODING_RLE :
-        if (!srcSize) return ERROR(srcSize_wrong);
-        if ( (*(const BYTE*)src) > max) return ERROR(corruption_detected);
-        FSE_buildDTable_rle(DTable, *(const BYTE*)src);   /* if *src > max, data is corrupted */
-        return 1;
-    case FSE_ENCODING_RAW :
-        FSE_buildDTable(DTable, defaultNorm, max, defaultLog);
-        return 0;
-    case FSE_ENCODING_STATIC:
-        if (!flagRepeatTable) return ERROR(corruption_detected);
-        return 0;
-    default :   /* impossible */
-    case FSE_ENCODING_DYNAMIC :
-        {   U32 tableLog;
-            S16 norm[MaxSeq+1];
-            size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize);
-            if (FSE_isError(headerSize)) return ERROR(corruption_detected);
-            if (tableLog > maxLog) return ERROR(corruption_detected);
-            FSE_buildDTable(DTable, norm, max, tableLog);
-            return headerSize;
-    }   }
-}
-
-
-size_t ZSTD_decodeSeqHeaders(int* nbSeqPtr,
-                             FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb, U32 flagRepeatTable,
-                             const void* src, size_t srcSize)
-{
-    const BYTE* const istart = (const BYTE* const)src;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* ip = istart;
-
-    /* check */
-    if (srcSize < MIN_SEQUENCES_SIZE) return ERROR(srcSize_wrong);
-
-    /* SeqHead */
-    {   int nbSeq = *ip++;
-        if (!nbSeq) { *nbSeqPtr=0; return 1; }
-        if (nbSeq > 0x7F) {
-            if (nbSeq == 0xFF)
-                nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2;
-            else
-                nbSeq = ((nbSeq-0x80)<<8) + *ip++;
-        }
-        *nbSeqPtr = nbSeq;
-    }
-
-    /* FSE table descriptors */
-    {   U32 const LLtype  = *ip >> 6;
-        U32 const Offtype = (*ip >> 4) & 3;
-        U32 const MLtype  = (*ip >> 2) & 3;
-        ip++;
-
-        /* check */
-        if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */
-
-        /* Build DTables */
-        {   size_t const bhSize = ZSTD_buildSeqTable(DTableLL, LLtype, MaxLL, LLFSELog, ip, iend-ip, LL_defaultNorm, LL_defaultNormLog, flagRepeatTable);
-            if (ZSTD_isError(bhSize)) return ERROR(corruption_detected);
-            ip += bhSize;
-        }
-        {   size_t const bhSize = ZSTD_buildSeqTable(DTableOffb, Offtype, MaxOff, OffFSELog, ip, iend-ip, OF_defaultNorm, OF_defaultNormLog, flagRepeatTable);
-            if (ZSTD_isError(bhSize)) return ERROR(corruption_detected);
-            ip += bhSize;
-        }
-        {   size_t const bhSize = ZSTD_buildSeqTable(DTableML, MLtype, MaxML, MLFSELog, ip, iend-ip, ML_defaultNorm, ML_defaultNormLog, flagRepeatTable);
-            if (ZSTD_isError(bhSize)) return ERROR(corruption_detected);
-            ip += bhSize;
-    }   }
-
-    return ip-istart;
-}
-
-
-typedef struct {
-    size_t litLength;
-    size_t matchLength;
-    size_t offset;
-} seq_t;
-
-typedef struct {
-    BIT_DStream_t DStream;
-    FSE_DState_t stateLL;
-    FSE_DState_t stateOffb;
-    FSE_DState_t stateML;
-    size_t prevOffset[ZSTD_REP_INIT];
-} seqState_t;
-
-
-
-static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState)
-{
-    /* Literal length */
-    U32 const llCode = FSE_peekSymbol(&(seqState->stateLL));
-    U32 const mlCode = FSE_peekSymbol(&(seqState->stateML));
-    U32 const ofCode = FSE_peekSymbol(&(seqState->stateOffb));   /* <= maxOff, by table construction */
-
-    U32 const llBits = LL_bits[llCode];
-    U32 const mlBits = ML_bits[mlCode];
-    U32 const ofBits = ofCode;
-    U32 const totalBits = llBits+mlBits+ofBits;
-
-    static const U32 LL_base[MaxLL+1] = {
-                             0,  1,  2,  3,  4,  5,  6,  7,  8,  9,   10,    11,    12,    13,    14,     15,
-                            16, 18, 20, 22, 24, 28, 32, 40, 48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000,
-                            0x2000, 0x4000, 0x8000, 0x10000 };
-
-    static const U32 ML_base[MaxML+1] = {
-                             0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10,   11,    12,    13,    14,    15,
-                            16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,   27,    28,    29,    30,    31,
-                            32, 34, 36, 38, 40, 44, 48, 56, 64, 80, 96, 0x80, 0x100, 0x200, 0x400, 0x800,
-                            0x1000, 0x2000, 0x4000, 0x8000, 0x10000 };
-
-    static const U32 OF_base[MaxOff+1] = {
-                 0,        1,       3,       7,     0xF,     0x1F,     0x3F,     0x7F,
-                 0xFF,   0x1FF,   0x3FF,   0x7FF,   0xFFF,   0x1FFF,   0x3FFF,   0x7FFF,
-                 0xFFFF, 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF,
-                 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, /*fake*/ 1, 1 };
-
-    /* sequence */
-    {   size_t offset;
-        if (!ofCode)
-            offset = 0;
-        else {
-            offset = OF_base[ofCode] + BIT_readBits(&(seqState->DStream), ofBits);   /* <=  26 bits */
-            if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));
-        }
-
-        if (offset < ZSTD_REP_NUM) {
-            if (llCode == 0 && offset <= 1) offset = 1-offset;
-
-            if (offset != 0) {
-                size_t temp = seqState->prevOffset[offset];
-                if (offset != 1) {
-                    seqState->prevOffset[2] = seqState->prevOffset[1];
-                }
-                seqState->prevOffset[1] = seqState->prevOffset[0];
-                seqState->prevOffset[0] = offset = temp;
-
-            } else {
-                offset = seqState->prevOffset[0];
-            }
-        } else {
-            offset -= ZSTD_REP_MOVE;
-            seqState->prevOffset[2] = seqState->prevOffset[1];
-            seqState->prevOffset[1] = seqState->prevOffset[0];
-            seqState->prevOffset[0] = offset;
-        }
-        seq->offset = offset;
-    }
-
-    seq->matchLength = ML_base[mlCode] + MINMATCH + ((mlCode>31) ? BIT_readBits(&(seqState->DStream), mlBits) : 0);   /* <=  16 bits */
-    if (MEM_32bits() && (mlBits+llBits>24)) BIT_reloadDStream(&(seqState->DStream));
-
-    seq->litLength = LL_base[llCode] + ((llCode>15) ? BIT_readBits(&(seqState->DStream), llBits) : 0);   /* <=  16 bits */
-    if (MEM_32bits() ||
-       (totalBits > 64 - 7 - (LLFSELog+MLFSELog+OffFSELog)) ) BIT_reloadDStream(&(seqState->DStream));
-
-    /* ANS state update */
-    FSE_updateState(&(seqState->stateLL), &(seqState->DStream));   /* <=  9 bits */
-    FSE_updateState(&(seqState->stateML), &(seqState->DStream));   /* <=  9 bits */
-    if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));     /* <= 18 bits */
-    FSE_updateState(&(seqState->stateOffb), &(seqState->DStream)); /* <=  8 bits */
-}
-
-
+} 
+ 
+ 
+/** ZSTD_getFrameParams() : 
+*   decode Frame Header, or provide expected `srcSize`. 
+*   @return : 0, `fparamsPtr` is correctly filled, 
+*            >0, `srcSize` is too small, result is expected `srcSize`, 
+*             or an error code, which can be tested using ZSTD_isError() */ 
+size_t ZSTD_getFrameParams(ZSTD_frameParams* fparamsPtr, const void* src, size_t srcSize) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+ 
+    if (srcSize < ZSTD_frameHeaderSize_min) return ZSTD_frameHeaderSize_min; 
+    if (MEM_readLE32(src) != ZSTD_MAGICNUMBER) return ERROR(prefix_unknown); 
+ 
+    /* ensure there is enough `srcSize` to fully read/decode frame header */ 
+    { size_t const fhsize = ZSTD_frameHeaderSize(src, srcSize); 
+      if (srcSize < fhsize) return fhsize; } 
+ 
+    memset(fparamsPtr, 0, sizeof(*fparamsPtr)); 
+    {   BYTE const frameDesc = ip[4]; 
+        fparamsPtr->windowLog = (frameDesc & 0xF) + ZSTD_WINDOWLOG_ABSOLUTEMIN; 
+        if ((frameDesc & 0x20) != 0) return ERROR(frameParameter_unsupported);   /* reserved 1 bit */ 
+        switch(frameDesc >> 6)  /* fcsId */ 
+        { 
+            default:   /* impossible */ 
+            case 0 : fparamsPtr->frameContentSize = 0; break; 
+            case 1 : fparamsPtr->frameContentSize = ip[5]; break; 
+            case 2 : fparamsPtr->frameContentSize = MEM_readLE16(ip+5)+256; break; 
+            case 3 : fparamsPtr->frameContentSize = MEM_readLE64(ip+5); break; 
+    }   } 
+    return 0; 
+} 
+ 
+ 
+/** ZSTD_decodeFrameHeader() : 
+*   `srcSize` must be the size provided by ZSTD_frameHeaderSize(). 
+*   @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */ 
+static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* zc, const void* src, size_t srcSize) 
+{ 
+    size_t const result = ZSTD_getFrameParams(&(zc->fParams), src, srcSize); 
+    if ((MEM_32bits()) && (zc->fParams.windowLog > 25)) return ERROR(frameParameter_unsupportedBy32bits); 
+    return result; 
+} 
+ 
+ 
+typedef struct 
+{ 
+    blockType_t blockType; 
+    U32 origSize; 
+} blockProperties_t; 
+ 
+/*! ZSTD_getcBlockSize() : 
+*   Provides the size of compressed block from block header `src` */ 
+size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr) 
+{ 
+    const BYTE* const in = (const BYTE* const)src; 
+    U32 cSize; 
+ 
+    if (srcSize < ZSTD_blockHeaderSize) return ERROR(srcSize_wrong); 
+ 
+    bpPtr->blockType = (blockType_t)((*in) >> 6); 
+    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16); 
+    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0; 
+ 
+    if (bpPtr->blockType == bt_end) return 0; 
+    if (bpPtr->blockType == bt_rle) return 1; 
+    return cSize; 
+} 
+ 
+ 
+static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall); 
+    memcpy(dst, src, srcSize); 
+    return srcSize; 
+} 
+ 
+ 
+/*! ZSTD_decodeLiteralsBlock() : 
+    @return : nb of bytes read from src (< srcSize ) */ 
+size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx, 
+                          const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */ 
+{ 
+    const BYTE* const istart = (const BYTE*) src; 
+ 
+    /* any compressed block with literals segment must be at least this size */ 
+    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected); 
+ 
+    switch(istart[0]>> 6) 
+    { 
+    case IS_HUF: 
+        {   size_t litSize, litCSize, singleStream=0; 
+            U32 lhSize = ((istart[0]) >> 4) & 3; 
+            if (srcSize < 5) return ERROR(corruption_detected);   /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for lhSize, + cSize (+nbSeq) */ 
+            switch(lhSize) 
+            { 
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */ 
+                /* 2 - 2 - 10 - 10 */ 
+                lhSize=3; 
+                singleStream = istart[0] & 16; 
+                litSize  = ((istart[0] & 15) << 6) + (istart[1] >> 2); 
+                litCSize = ((istart[1] &  3) << 8) + istart[2]; 
+                break; 
+            case 2: 
+                /* 2 - 2 - 14 - 14 */ 
+                lhSize=4; 
+                litSize  = ((istart[0] & 15) << 10) + (istart[1] << 2) + (istart[2] >> 6); 
+                litCSize = ((istart[2] & 63) <<  8) + istart[3]; 
+                break; 
+            case 3: 
+                /* 2 - 2 - 18 - 18 */ 
+                lhSize=5; 
+                litSize  = ((istart[0] & 15) << 14) + (istart[1] << 6) + (istart[2] >> 2); 
+                litCSize = ((istart[2] &  3) << 16) + (istart[3] << 8) + istart[4]; 
+                break; 
+            } 
+            if (litSize > ZSTD_BLOCKSIZE_MAX) return ERROR(corruption_detected); 
+            if (litCSize + lhSize > srcSize) return ERROR(corruption_detected); 
+ 
+            if (HUF_isError(singleStream ? 
+                            HUF_decompress1X2(dctx->litBuffer, litSize, istart+lhSize, litCSize) : 
+                            HUF_decompress   (dctx->litBuffer, litSize, istart+lhSize, litCSize) )) 
+                return ERROR(corruption_detected); 
+ 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litBufSize = ZSTD_BLOCKSIZE_MAX+8; 
+            dctx->litSize = litSize; 
+            return litCSize + lhSize; 
+        } 
+    case IS_PCH: 
+        {   size_t litSize, litCSize; 
+            U32 lhSize = ((istart[0]) >> 4) & 3; 
+            if (lhSize != 1)  /* only case supported for now : small litSize, single stream */ 
+                return ERROR(corruption_detected); 
+            if (!dctx->flagRepeatTable) 
+                return ERROR(dictionary_corrupted); 
+ 
+            /* 2 - 2 - 10 - 10 */ 
+            lhSize=3; 
+            litSize  = ((istart[0] & 15) << 6) + (istart[1] >> 2); 
+            litCSize = ((istart[1] &  3) << 8) + istart[2]; 
+ 
+            {   size_t const errorCode = HUF_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTableX4); 
+                if (HUF_isError(errorCode)) return ERROR(corruption_detected); 
+            } 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litBufSize = ZSTD_BLOCKSIZE_MAX+WILDCOPY_OVERLENGTH; 
+            dctx->litSize = litSize; 
+            return litCSize + lhSize; 
+        } 
+    case IS_RAW: 
+        {   size_t litSize; 
+            U32 lhSize = ((istart[0]) >> 4) & 3; 
+            switch(lhSize) 
+            { 
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */ 
+                lhSize=1; 
+                litSize = istart[0] & 31; 
+                break; 
+            case 2: 
+                litSize = ((istart[0] & 15) << 8) + istart[1]; 
+                break; 
+            case 3: 
+                litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2]; 
+                break; 
+            } 
+ 
+            if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) {  /* risk reading beyond src buffer with wildcopy */ 
+                if (litSize+lhSize > srcSize) return ERROR(corruption_detected); 
+                memcpy(dctx->litBuffer, istart+lhSize, litSize); 
+                dctx->litPtr = dctx->litBuffer; 
+                dctx->litBufSize = ZSTD_BLOCKSIZE_MAX+8; 
+                dctx->litSize = litSize; 
+                return lhSize+litSize; 
+            } 
+            /* direct reference into compressed stream */ 
+            dctx->litPtr = istart+lhSize; 
+            dctx->litBufSize = srcSize-lhSize; 
+            dctx->litSize = litSize; 
+            return lhSize+litSize; 
+        } 
+    case IS_RLE: 
+        {   size_t litSize; 
+            U32 lhSize = ((istart[0]) >> 4) & 3; 
+            switch(lhSize) 
+            { 
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */ 
+                lhSize = 1; 
+                litSize = istart[0] & 31; 
+                break; 
+            case 2: 
+                litSize = ((istart[0] & 15) << 8) + istart[1]; 
+                break; 
+            case 3: 
+                litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2]; 
+                if (srcSize<4) return ERROR(corruption_detected);   /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need lhSize+1 = 4 */ 
+                break; 
+            } 
+            if (litSize > ZSTD_BLOCKSIZE_MAX) return ERROR(corruption_detected); 
+            memset(dctx->litBuffer, istart[lhSize], litSize); 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litBufSize = ZSTD_BLOCKSIZE_MAX+WILDCOPY_OVERLENGTH; 
+            dctx->litSize = litSize; 
+            return lhSize+1; 
+        } 
+    default: 
+        return ERROR(corruption_detected);   /* impossible */ 
+    } 
+} 
+ 
+ 
+/*! ZSTD_buildSeqTable() : 
+    @return : nb bytes read from src, 
+              or an error code if it fails, testable with ZSTD_isError() 
+*/ 
+FORCE_INLINE size_t ZSTD_buildSeqTable(FSE_DTable* DTable, U32 type, U32 max, U32 maxLog, 
+                                 const void* src, size_t srcSize, 
+                                 const S16* defaultNorm, U32 defaultLog, U32 flagRepeatTable) 
+{ 
+    switch(type) 
+    { 
+    case FSE_ENCODING_RLE : 
+        if (!srcSize) return ERROR(srcSize_wrong); 
+        if ( (*(const BYTE*)src) > max) return ERROR(corruption_detected); 
+        FSE_buildDTable_rle(DTable, *(const BYTE*)src);   /* if *src > max, data is corrupted */ 
+        return 1; 
+    case FSE_ENCODING_RAW : 
+        FSE_buildDTable(DTable, defaultNorm, max, defaultLog); 
+        return 0; 
+    case FSE_ENCODING_STATIC: 
+        if (!flagRepeatTable) return ERROR(corruption_detected); 
+        return 0; 
+    default :   /* impossible */ 
+    case FSE_ENCODING_DYNAMIC : 
+        {   U32 tableLog; 
+            S16 norm[MaxSeq+1]; 
+            size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize); 
+            if (FSE_isError(headerSize)) return ERROR(corruption_detected); 
+            if (tableLog > maxLog) return ERROR(corruption_detected); 
+            FSE_buildDTable(DTable, norm, max, tableLog); 
+            return headerSize; 
+    }   } 
+} 
+ 
+ 
+size_t ZSTD_decodeSeqHeaders(int* nbSeqPtr, 
+                             FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb, U32 flagRepeatTable, 
+                             const void* src, size_t srcSize) 
+{ 
+    const BYTE* const istart = (const BYTE* const)src; 
+    const BYTE* const iend = istart + srcSize; 
+    const BYTE* ip = istart; 
+ 
+    /* check */ 
+    if (srcSize < MIN_SEQUENCES_SIZE) return ERROR(srcSize_wrong); 
+ 
+    /* SeqHead */ 
+    {   int nbSeq = *ip++; 
+        if (!nbSeq) { *nbSeqPtr=0; return 1; } 
+        if (nbSeq > 0x7F) { 
+            if (nbSeq == 0xFF) 
+                nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2; 
+            else 
+                nbSeq = ((nbSeq-0x80)<<8) + *ip++; 
+        } 
+        *nbSeqPtr = nbSeq; 
+    } 
+ 
+    /* FSE table descriptors */ 
+    {   U32 const LLtype  = *ip >> 6; 
+        U32 const Offtype = (*ip >> 4) & 3; 
+        U32 const MLtype  = (*ip >> 2) & 3; 
+        ip++; 
+ 
+        /* check */ 
+        if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */ 
+ 
+        /* Build DTables */ 
+        {   size_t const bhSize = ZSTD_buildSeqTable(DTableLL, LLtype, MaxLL, LLFSELog, ip, iend-ip, LL_defaultNorm, LL_defaultNormLog, flagRepeatTable); 
+            if (ZSTD_isError(bhSize)) return ERROR(corruption_detected); 
+            ip += bhSize; 
+        } 
+        {   size_t const bhSize = ZSTD_buildSeqTable(DTableOffb, Offtype, MaxOff, OffFSELog, ip, iend-ip, OF_defaultNorm, OF_defaultNormLog, flagRepeatTable); 
+            if (ZSTD_isError(bhSize)) return ERROR(corruption_detected); 
+            ip += bhSize; 
+        } 
+        {   size_t const bhSize = ZSTD_buildSeqTable(DTableML, MLtype, MaxML, MLFSELog, ip, iend-ip, ML_defaultNorm, ML_defaultNormLog, flagRepeatTable); 
+            if (ZSTD_isError(bhSize)) return ERROR(corruption_detected); 
+            ip += bhSize; 
+    }   } 
+ 
+    return ip-istart; 
+} 
+ 
+ 
+typedef struct { 
+    size_t litLength; 
+    size_t matchLength; 
+    size_t offset; 
+} seq_t; 
+ 
+typedef struct { 
+    BIT_DStream_t DStream; 
+    FSE_DState_t stateLL; 
+    FSE_DState_t stateOffb; 
+    FSE_DState_t stateML; 
+    size_t prevOffset[ZSTD_REP_INIT]; 
+} seqState_t; 
+ 
+ 
+ 
+static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState) 
+{ 
+    /* Literal length */ 
+    U32 const llCode = FSE_peekSymbol(&(seqState->stateLL)); 
+    U32 const mlCode = FSE_peekSymbol(&(seqState->stateML)); 
+    U32 const ofCode = FSE_peekSymbol(&(seqState->stateOffb));   /* <= maxOff, by table construction */ 
+ 
+    U32 const llBits = LL_bits[llCode]; 
+    U32 const mlBits = ML_bits[mlCode]; 
+    U32 const ofBits = ofCode; 
+    U32 const totalBits = llBits+mlBits+ofBits; 
+ 
+    static const U32 LL_base[MaxLL+1] = { 
+                             0,  1,  2,  3,  4,  5,  6,  7,  8,  9,   10,    11,    12,    13,    14,     15, 
+                            16, 18, 20, 22, 24, 28, 32, 40, 48, 64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000, 
+                            0x2000, 0x4000, 0x8000, 0x10000 }; 
+ 
+    static const U32 ML_base[MaxML+1] = { 
+                             0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10,   11,    12,    13,    14,    15, 
+                            16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,   27,    28,    29,    30,    31, 
+                            32, 34, 36, 38, 40, 44, 48, 56, 64, 80, 96, 0x80, 0x100, 0x200, 0x400, 0x800, 
+                            0x1000, 0x2000, 0x4000, 0x8000, 0x10000 }; 
+ 
+    static const U32 OF_base[MaxOff+1] = { 
+                 0,        1,       3,       7,     0xF,     0x1F,     0x3F,     0x7F, 
+                 0xFF,   0x1FF,   0x3FF,   0x7FF,   0xFFF,   0x1FFF,   0x3FFF,   0x7FFF, 
+                 0xFFFF, 0x1FFFF, 0x3FFFF, 0x7FFFF, 0xFFFFF, 0x1FFFFF, 0x3FFFFF, 0x7FFFFF, 
+                 0xFFFFFF, 0x1FFFFFF, 0x3FFFFFF, /*fake*/ 1, 1 }; 
+ 
+    /* sequence */ 
+    {   size_t offset; 
+        if (!ofCode) 
+            offset = 0; 
+        else { 
+            offset = OF_base[ofCode] + BIT_readBits(&(seqState->DStream), ofBits);   /* <=  26 bits */ 
+            if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream)); 
+        } 
+ 
+        if (offset < ZSTD_REP_NUM) { 
+            if (llCode == 0 && offset <= 1) offset = 1-offset; 
+ 
+            if (offset != 0) { 
+                size_t temp = seqState->prevOffset[offset]; 
+                if (offset != 1) { 
+                    seqState->prevOffset[2] = seqState->prevOffset[1]; 
+                } 
+                seqState->prevOffset[1] = seqState->prevOffset[0]; 
+                seqState->prevOffset[0] = offset = temp; 
+ 
+            } else { 
+                offset = seqState->prevOffset[0]; 
+            } 
+        } else { 
+            offset -= ZSTD_REP_MOVE; 
+            seqState->prevOffset[2] = seqState->prevOffset[1]; 
+            seqState->prevOffset[1] = seqState->prevOffset[0]; 
+            seqState->prevOffset[0] = offset; 
+        } 
+        seq->offset = offset; 
+    } 
+ 
+    seq->matchLength = ML_base[mlCode] + MINMATCH + ((mlCode>31) ? BIT_readBits(&(seqState->DStream), mlBits) : 0);   /* <=  16 bits */ 
+    if (MEM_32bits() && (mlBits+llBits>24)) BIT_reloadDStream(&(seqState->DStream)); 
+ 
+    seq->litLength = LL_base[llCode] + ((llCode>15) ? BIT_readBits(&(seqState->DStream), llBits) : 0);   /* <=  16 bits */ 
+    if (MEM_32bits() || 
+       (totalBits > 64 - 7 - (LLFSELog+MLFSELog+OffFSELog)) ) BIT_reloadDStream(&(seqState->DStream)); 
+ 
+    /* ANS state update */ 
+    FSE_updateState(&(seqState->stateLL), &(seqState->DStream));   /* <=  9 bits */ 
+    FSE_updateState(&(seqState->stateML), &(seqState->DStream));   /* <=  9 bits */ 
+    if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));     /* <= 18 bits */ 
+    FSE_updateState(&(seqState->stateOffb), &(seqState->DStream)); /* <=  8 bits */ 
+} 
+ 
+ 
 FORCE_INLINE
 size_t ZSTD_execSequence(BYTE* op,
-                                BYTE* const oend, seq_t sequence,
-                                const BYTE** litPtr, const BYTE* const litLimit_8,
-                                const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)
-{
-    BYTE* const oLitEnd = op + sequence.litLength;
-    size_t const sequenceLength = sequence.litLength + sequence.matchLength;
-    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */
-    BYTE* const oend_8 = oend-8;
-    const BYTE* const iLitEnd = *litPtr + sequence.litLength;
-    const BYTE* match = oLitEnd - sequence.offset;
-
-    /* check */
-    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */
-    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */
-    if (iLitEnd > litLimit_8) return ERROR(corruption_detected);   /* over-read beyond lit buffer */
-
-    /* copy Literals */
-    ZSTD_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */
-    op = oLitEnd;
-    *litPtr = iLitEnd;   /* update for next sequence */
-
-    /* copy Match */
-    if (sequence.offset > (size_t)(oLitEnd - base)) {
-        /* offset beyond prefix */
-        if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected);
-        match = dictEnd - (base-match);
-        if (match + sequence.matchLength <= dictEnd) {
-            memmove(oLitEnd, match, sequence.matchLength);
-            return sequenceLength;
-        }
-        /* span extDict & currentPrefixSegment */
-        {   size_t const length1 = dictEnd - match;
-            memmove(oLitEnd, match, length1);
-            op = oLitEnd + length1;
-            sequence.matchLength -= length1;
-            match = base;
-    }   }
-
-    /* match within prefix */
-    if (sequence.offset < 8) {
-        /* close range match, overlap */
-        static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */
-        static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 };   /* substracted */
-        int const sub2 = dec64table[sequence.offset];
-        op[0] = match[0];
-        op[1] = match[1];
-        op[2] = match[2];
-        op[3] = match[3];
-        match += dec32table[sequence.offset];
-        ZSTD_copy4(op+4, match);
-        match -= sub2;
-    } else {
-        ZSTD_copy8(op, match);
-    }
-    op += 8; match += 8;
-
-    if (oMatchEnd > oend-(16-MINMATCH)) {
-        if (op < oend_8) {
-            ZSTD_wildcopy(op, match, oend_8 - op);
-            match += oend_8 - op;
-            op = oend_8;
-        }
-        while (op < oMatchEnd) *op++ = *match++;
-    } else {
-        ZSTD_wildcopy(op, match, sequence.matchLength-8);   /* works even if matchLength < 8 */
-    }
-    return sequenceLength;
-}
-
-
-static size_t ZSTD_decompressSequences(
-                               ZSTD_DCtx* dctx,
-                               void* dst, size_t maxDstSize,
-                         const void* seqStart, size_t seqSize)
-{
-    const BYTE* ip = (const BYTE*)seqStart;
-    const BYTE* const iend = ip + seqSize;
-    BYTE* const ostart = (BYTE* const)dst;
-    BYTE* const oend = ostart + maxDstSize;
-    BYTE* op = ostart;
-    const BYTE* litPtr = dctx->litPtr;
-    const BYTE* const litLimit_8 = litPtr + dctx->litBufSize - 8;
-    const BYTE* const litEnd = litPtr + dctx->litSize;
-    FSE_DTable* DTableLL = dctx->LLTable;
-    FSE_DTable* DTableML = dctx->MLTable;
-    FSE_DTable* DTableOffb = dctx->OffTable;
-    const BYTE* const base = (const BYTE*) (dctx->base);
-    const BYTE* const vBase = (const BYTE*) (dctx->vBase);
-    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
-    int nbSeq;
-
-    /* Build Decoding Tables */
-    {   size_t const seqHSize = ZSTD_decodeSeqHeaders(&nbSeq, DTableLL, DTableML, DTableOffb, dctx->flagRepeatTable, ip, seqSize);
-        if (ZSTD_isError(seqHSize)) return seqHSize;
-        ip += seqHSize;
-        dctx->flagRepeatTable = 0;
-    }
-
-    /* Regen sequences */
-    if (nbSeq) {
-        seq_t sequence;
-        seqState_t seqState;
-
-        memset(&sequence, 0, sizeof(sequence));
-        sequence.offset = REPCODE_STARTVALUE;
-        { U32 i; for (i=0; i<ZSTD_REP_INIT; i++) seqState.prevOffset[i] = REPCODE_STARTVALUE; }
-        { size_t const errorCode = BIT_initDStream(&(seqState.DStream), ip, iend-ip);
-          if (ERR_isError(errorCode)) return ERROR(corruption_detected); }
-        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
-        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
-        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
-
-        for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && nbSeq ; ) {
-            nbSeq--;
-            ZSTD_decodeSequence(&sequence, &seqState);
-
-#if 0  /* debug */
-            static BYTE* start = NULL;
-            if (start==NULL) start = op;
-            size_t pos = (size_t)(op-start);
-            if ((pos >= 5810037) && (pos < 5810400))
-                printf("Dpos %6u :%5u literals & match %3u bytes at distance %6u \n",
-                       pos, (U32)sequence.litLength, (U32)sequence.matchLength, (U32)sequence.offset);
-#endif
-
-            {   size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litLimit_8, base, vBase, dictEnd);
-                if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
-                op += oneSeqSize;
-        }   }
-
-        /* check if reached exact end */
-        if (nbSeq) return ERROR(corruption_detected);
-    }
-
-    /* last literal segment */
-    {   size_t const lastLLSize = litEnd - litPtr;
-        if (litPtr > litEnd) return ERROR(corruption_detected);   /* too many literals already used */
-        if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);
-        memcpy(op, litPtr, lastLLSize);
-        op += lastLLSize;
-    }
-
-    return op-ostart;
-}
-
-
-static void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst)
-{
-    if (dst != dctx->previousDstEnd) {   /* not contiguous */
-        dctx->dictEnd = dctx->previousDstEnd;
-        dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));
-        dctx->base = dst;
-        dctx->previousDstEnd = dst;
-    }
-}
-
-
-static size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
-                            void* dst, size_t dstCapacity,
-                      const void* src, size_t srcSize)
-{   /* blockType == blockCompressed */
-    const BYTE* ip = (const BYTE*)src;
-
-    if (srcSize >= ZSTD_BLOCKSIZE_MAX) return ERROR(srcSize_wrong);
-
-    /* Decode literals sub-block */
-    {   size_t const litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize);
-        if (ZSTD_isError(litCSize)) return litCSize;
-        ip += litCSize;
-        srcSize -= litCSize;
-    }
-    return ZSTD_decompressSequences(dctx, dst, dstCapacity, ip, srcSize);
-}
-
-
-size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,
-                            void* dst, size_t dstCapacity,
-                      const void* src, size_t srcSize)
-{
-    ZSTD_checkContinuity(dctx, dst);
-    return ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
-}
-
-
+                                BYTE* const oend, seq_t sequence, 
+                                const BYTE** litPtr, const BYTE* const litLimit_8, 
+                                const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd) 
+{ 
+    BYTE* const oLitEnd = op + sequence.litLength; 
+    size_t const sequenceLength = sequence.litLength + sequence.matchLength; 
+    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */ 
+    BYTE* const oend_8 = oend-8; 
+    const BYTE* const iLitEnd = *litPtr + sequence.litLength; 
+    const BYTE* match = oLitEnd - sequence.offset; 
+ 
+    /* check */ 
+    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */ 
+    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */ 
+    if (iLitEnd > litLimit_8) return ERROR(corruption_detected);   /* over-read beyond lit buffer */ 
+ 
+    /* copy Literals */ 
+    ZSTD_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */ 
+    op = oLitEnd; 
+    *litPtr = iLitEnd;   /* update for next sequence */ 
+ 
+    /* copy Match */ 
+    if (sequence.offset > (size_t)(oLitEnd - base)) { 
+        /* offset beyond prefix */ 
+        if (sequence.offset > (size_t)(oLitEnd - vBase)) return ERROR(corruption_detected); 
+        match = dictEnd - (base-match); 
+        if (match + sequence.matchLength <= dictEnd) { 
+            memmove(oLitEnd, match, sequence.matchLength); 
+            return sequenceLength; 
+        } 
+        /* span extDict & currentPrefixSegment */ 
+        {   size_t const length1 = dictEnd - match; 
+            memmove(oLitEnd, match, length1); 
+            op = oLitEnd + length1; 
+            sequence.matchLength -= length1; 
+            match = base; 
+    }   } 
+ 
+    /* match within prefix */ 
+    if (sequence.offset < 8) { 
+        /* close range match, overlap */ 
+        static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */ 
+        static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 };   /* substracted */ 
+        int const sub2 = dec64table[sequence.offset]; 
+        op[0] = match[0]; 
+        op[1] = match[1]; 
+        op[2] = match[2]; 
+        op[3] = match[3]; 
+        match += dec32table[sequence.offset]; 
+        ZSTD_copy4(op+4, match); 
+        match -= sub2; 
+    } else { 
+        ZSTD_copy8(op, match); 
+    } 
+    op += 8; match += 8; 
+ 
+    if (oMatchEnd > oend-(16-MINMATCH)) { 
+        if (op < oend_8) { 
+            ZSTD_wildcopy(op, match, oend_8 - op); 
+            match += oend_8 - op; 
+            op = oend_8; 
+        } 
+        while (op < oMatchEnd) *op++ = *match++; 
+    } else { 
+        ZSTD_wildcopy(op, match, sequence.matchLength-8);   /* works even if matchLength < 8 */ 
+    } 
+    return sequenceLength; 
+} 
+ 
+ 
+static size_t ZSTD_decompressSequences( 
+                               ZSTD_DCtx* dctx, 
+                               void* dst, size_t maxDstSize, 
+                         const void* seqStart, size_t seqSize) 
+{ 
+    const BYTE* ip = (const BYTE*)seqStart; 
+    const BYTE* const iend = ip + seqSize; 
+    BYTE* const ostart = (BYTE* const)dst; 
+    BYTE* const oend = ostart + maxDstSize; 
+    BYTE* op = ostart; 
+    const BYTE* litPtr = dctx->litPtr; 
+    const BYTE* const litLimit_8 = litPtr + dctx->litBufSize - 8; 
+    const BYTE* const litEnd = litPtr + dctx->litSize; 
+    FSE_DTable* DTableLL = dctx->LLTable; 
+    FSE_DTable* DTableML = dctx->MLTable; 
+    FSE_DTable* DTableOffb = dctx->OffTable; 
+    const BYTE* const base = (const BYTE*) (dctx->base); 
+    const BYTE* const vBase = (const BYTE*) (dctx->vBase); 
+    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd); 
+    int nbSeq; 
+ 
+    /* Build Decoding Tables */ 
+    {   size_t const seqHSize = ZSTD_decodeSeqHeaders(&nbSeq, DTableLL, DTableML, DTableOffb, dctx->flagRepeatTable, ip, seqSize); 
+        if (ZSTD_isError(seqHSize)) return seqHSize; 
+        ip += seqHSize; 
+        dctx->flagRepeatTable = 0; 
+    } 
+ 
+    /* Regen sequences */ 
+    if (nbSeq) { 
+        seq_t sequence; 
+        seqState_t seqState; 
+ 
+        memset(&sequence, 0, sizeof(sequence)); 
+        sequence.offset = REPCODE_STARTVALUE; 
+        { U32 i; for (i=0; i<ZSTD_REP_INIT; i++) seqState.prevOffset[i] = REPCODE_STARTVALUE; } 
+        { size_t const errorCode = BIT_initDStream(&(seqState.DStream), ip, iend-ip); 
+          if (ERR_isError(errorCode)) return ERROR(corruption_detected); } 
+        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL); 
+        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb); 
+        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML); 
+ 
+        for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && nbSeq ; ) { 
+            nbSeq--; 
+            ZSTD_decodeSequence(&sequence, &seqState); 
+ 
+#if 0  /* debug */ 
+            static BYTE* start = NULL; 
+            if (start==NULL) start = op; 
+            size_t pos = (size_t)(op-start); 
+            if ((pos >= 5810037) && (pos < 5810400)) 
+                printf("Dpos %6u :%5u literals & match %3u bytes at distance %6u \n", 
+                       pos, (U32)sequence.litLength, (U32)sequence.matchLength, (U32)sequence.offset); 
+#endif 
+ 
+            {   size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litLimit_8, base, vBase, dictEnd); 
+                if (ZSTD_isError(oneSeqSize)) return oneSeqSize; 
+                op += oneSeqSize; 
+        }   } 
+ 
+        /* check if reached exact end */ 
+        if (nbSeq) return ERROR(corruption_detected); 
+    } 
+ 
+    /* last literal segment */ 
+    {   size_t const lastLLSize = litEnd - litPtr; 
+        if (litPtr > litEnd) return ERROR(corruption_detected);   /* too many literals already used */ 
+        if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall); 
+        memcpy(op, litPtr, lastLLSize); 
+        op += lastLLSize; 
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+static void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst) 
+{ 
+    if (dst != dctx->previousDstEnd) {   /* not contiguous */ 
+        dctx->dictEnd = dctx->previousDstEnd; 
+        dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base)); 
+        dctx->base = dst; 
+        dctx->previousDstEnd = dst; 
+    } 
+} 
+ 
+ 
+static size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx, 
+                            void* dst, size_t dstCapacity, 
+                      const void* src, size_t srcSize) 
+{   /* blockType == blockCompressed */ 
+    const BYTE* ip = (const BYTE*)src; 
+ 
+    if (srcSize >= ZSTD_BLOCKSIZE_MAX) return ERROR(srcSize_wrong); 
+ 
+    /* Decode literals sub-block */ 
+    {   size_t const litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize); 
+        if (ZSTD_isError(litCSize)) return litCSize; 
+        ip += litCSize; 
+        srcSize -= litCSize; 
+    } 
+    return ZSTD_decompressSequences(dctx, dst, dstCapacity, ip, srcSize); 
+} 
+ 
+ 
+size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, 
+                            void* dst, size_t dstCapacity, 
+                      const void* src, size_t srcSize) 
+{ 
+    ZSTD_checkContinuity(dctx, dst); 
+    return ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize); 
+} 
+ 
+ 
 /*! ZSTD_decompressFrame() :
 *   `dctx` must be properly initialized */
-static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
-                                 void* dst, size_t dstCapacity,
-                                 const void* src, size_t srcSize)
-{
-    const BYTE* ip = (const BYTE*)src;
+static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx, 
+                                 void* dst, size_t dstCapacity, 
+                                 const void* src, size_t srcSize) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
     const BYTE* const iend = ip + srcSize;
-    BYTE* const ostart = (BYTE* const)dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + dstCapacity;
-    size_t remainingSize = srcSize;
+    BYTE* const ostart = (BYTE* const)dst; 
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + dstCapacity; 
+    size_t remainingSize = srcSize; 
     blockProperties_t blockProperties = { bt_compressed, 0 };
-
-    /* check */
-    if (srcSize < ZSTD_frameHeaderSize_min+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
-
-    /* Frame Header */
-    {   size_t const frameHeaderSize = ZSTD_frameHeaderSize(src, ZSTD_frameHeaderSize_min);
-        if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;
-        if (srcSize < frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
-        if (ZSTD_decodeFrameHeader(dctx, src, frameHeaderSize)) return ERROR(corruption_detected);
-        ip += frameHeaderSize; remainingSize -= frameHeaderSize;
-    }
-
-    /* Loop on each block */
-    while (1) {
-        size_t decodedSize=0;
-        size_t const cBlockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties);
-        if (ZSTD_isError(cBlockSize)) return cBlockSize;
-
-        ip += ZSTD_blockHeaderSize;
-        remainingSize -= ZSTD_blockHeaderSize;
-        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);
-
-        switch(blockProperties.blockType)
-        {
-        case bt_compressed:
-            decodedSize = ZSTD_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize);
-            break;
-        case bt_raw :
-            decodedSize = ZSTD_copyRawBlock(op, oend-op, ip, cBlockSize);
-            break;
-        case bt_rle :
-            return ERROR(GENERIC);   /* not yet supported */
-            break;
-        case bt_end :
-            /* end of frame */
-            if (remainingSize) return ERROR(srcSize_wrong);
-            break;
-        default:
-            return ERROR(GENERIC);   /* impossible */
-        }
-        if (cBlockSize == 0) break;   /* bt_end */
-
-        if (ZSTD_isError(decodedSize)) return decodedSize;
-        op += decodedSize;
-        ip += cBlockSize;
-        remainingSize -= cBlockSize;
-    }
-
-    return op-ostart;
-}
-
-
-size_t ZSTD_decompress_usingPreparedDCtx(ZSTD_DCtx* dctx, const ZSTD_DCtx* refDCtx,
-                                         void* dst, size_t dstCapacity,
-                                   const void* src, size_t srcSize)
-{
-    ZSTD_copyDCtx(dctx, refDCtx);
-    ZSTD_checkContinuity(dctx, dst);
-    return ZSTD_decompressFrame(dctx, dst, dstCapacity, src, srcSize);
-}
-
-
-size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
-                                 void* dst, size_t dstCapacity,
-                                 const void* src, size_t srcSize,
-                                 const void* dict, size_t dictSize)
-{
+ 
+    /* check */ 
+    if (srcSize < ZSTD_frameHeaderSize_min+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong); 
+ 
+    /* Frame Header */ 
+    {   size_t const frameHeaderSize = ZSTD_frameHeaderSize(src, ZSTD_frameHeaderSize_min); 
+        if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize; 
+        if (srcSize < frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong); 
+        if (ZSTD_decodeFrameHeader(dctx, src, frameHeaderSize)) return ERROR(corruption_detected); 
+        ip += frameHeaderSize; remainingSize -= frameHeaderSize; 
+    } 
+ 
+    /* Loop on each block */ 
+    while (1) { 
+        size_t decodedSize=0; 
+        size_t const cBlockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties); 
+        if (ZSTD_isError(cBlockSize)) return cBlockSize; 
+ 
+        ip += ZSTD_blockHeaderSize; 
+        remainingSize -= ZSTD_blockHeaderSize; 
+        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong); 
+ 
+        switch(blockProperties.blockType) 
+        { 
+        case bt_compressed: 
+            decodedSize = ZSTD_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize); 
+            break; 
+        case bt_raw : 
+            decodedSize = ZSTD_copyRawBlock(op, oend-op, ip, cBlockSize); 
+            break; 
+        case bt_rle : 
+            return ERROR(GENERIC);   /* not yet supported */ 
+            break; 
+        case bt_end : 
+            /* end of frame */ 
+            if (remainingSize) return ERROR(srcSize_wrong); 
+            break; 
+        default: 
+            return ERROR(GENERIC);   /* impossible */ 
+        } 
+        if (cBlockSize == 0) break;   /* bt_end */ 
+ 
+        if (ZSTD_isError(decodedSize)) return decodedSize; 
+        op += decodedSize; 
+        ip += cBlockSize; 
+        remainingSize -= cBlockSize; 
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+size_t ZSTD_decompress_usingPreparedDCtx(ZSTD_DCtx* dctx, const ZSTD_DCtx* refDCtx, 
+                                         void* dst, size_t dstCapacity, 
+                                   const void* src, size_t srcSize) 
+{ 
+    ZSTD_copyDCtx(dctx, refDCtx); 
+    ZSTD_checkContinuity(dctx, dst); 
+    return ZSTD_decompressFrame(dctx, dst, dstCapacity, src, srcSize); 
+} 
+ 
+ 
+size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx, 
+                                 void* dst, size_t dstCapacity, 
+                                 const void* src, size_t srcSize, 
+                                 const void* dict, size_t dictSize) 
+{ 
 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT==1)
     {   const U32 magicNumber = MEM_readLE32(src);
         if (ZSTD_isLegacy(magicNumber))
             return ZSTD_decompressLegacy(dst, dstCapacity, src, srcSize, dict, dictSize, magicNumber);
     }
 #endif
-    ZSTD_decompressBegin_usingDict(dctx, dict, dictSize);
-    ZSTD_checkContinuity(dctx, dst);
-    return ZSTD_decompressFrame(dctx, dst, dstCapacity, src, srcSize);
-}
-
-
-size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    return ZSTD_decompress_usingDict(dctx, dst, dstCapacity, src, srcSize, NULL, 0);
-}
-
-
-size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE==1)
-    size_t regenSize;
-    ZSTD_DCtx* dctx = ZSTD_createDCtx();
-    if (dctx==NULL) return ERROR(memory_allocation);
-    regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);
-    ZSTD_freeDCtx(dctx);
-    return regenSize;
+    ZSTD_decompressBegin_usingDict(dctx, dict, dictSize); 
+    ZSTD_checkContinuity(dctx, dst); 
+    return ZSTD_decompressFrame(dctx, dst, dstCapacity, src, srcSize); 
+} 
+ 
+ 
+size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    return ZSTD_decompress_usingDict(dctx, dst, dstCapacity, src, srcSize, NULL, 0); 
+} 
+ 
+ 
+size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE==1) 
+    size_t regenSize; 
+    ZSTD_DCtx* dctx = ZSTD_createDCtx(); 
+    if (dctx==NULL) return ERROR(memory_allocation); 
+    regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize); 
+    ZSTD_freeDCtx(dctx); 
+    return regenSize; 
 #else   /* stack mode */
-    ZSTD_DCtx dctx;
-    return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
-#endif
-}
-
-
-/*_******************************
-*  Streaming Decompression API
-********************************/
-size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx)
-{
-    return dctx->expected;
-}
-
+    ZSTD_DCtx dctx; 
+    return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize); 
+#endif 
+} 
+ 
+ 
+/*_****************************** 
+*  Streaming Decompression API 
+********************************/ 
+size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) 
+{ 
+    return dctx->expected; 
+} 
+ 
 size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    /* Sanity check */
-    if (srcSize != dctx->expected) return ERROR(srcSize_wrong);
+{ 
+    /* Sanity check */ 
+    if (srcSize != dctx->expected) return ERROR(srcSize_wrong); 
     if (dstCapacity) ZSTD_checkContinuity(dctx, dst);
-
-    /* Decompress : frame header; part 1 */
-    switch (dctx->stage)
-    {
-    case ZSTDds_getFrameHeaderSize :
+ 
+    /* Decompress : frame header; part 1 */ 
+    switch (dctx->stage) 
+    { 
+    case ZSTDds_getFrameHeaderSize : 
         if (srcSize != ZSTD_frameHeaderSize_min) return ERROR(srcSize_wrong);   /* impossible */
         dctx->headerSize = ZSTD_frameHeaderSize(src, ZSTD_frameHeaderSize_min);
         if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize;
@@ -985,79 +985,79 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, c
             dctx->expected = dctx->headerSize - ZSTD_frameHeaderSize_min;
             dctx->stage = ZSTDds_decodeFrameHeader;
             return 0;
-        }
+        } 
         dctx->expected = 0;   /* not necessary to copy more */
 
-    case ZSTDds_decodeFrameHeader:
+    case ZSTDds_decodeFrameHeader: 
         {   size_t result;
-            memcpy(dctx->headerBuffer + ZSTD_frameHeaderSize_min, src, dctx->expected);
-            result = ZSTD_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize);
-            if (ZSTD_isError(result)) return result;
-            dctx->expected = ZSTD_blockHeaderSize;
-            dctx->stage = ZSTDds_decodeBlockHeader;
-            return 0;
-        }
-    case ZSTDds_decodeBlockHeader:
+            memcpy(dctx->headerBuffer + ZSTD_frameHeaderSize_min, src, dctx->expected); 
+            result = ZSTD_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize); 
+            if (ZSTD_isError(result)) return result; 
+            dctx->expected = ZSTD_blockHeaderSize; 
+            dctx->stage = ZSTDds_decodeBlockHeader; 
+            return 0; 
+        } 
+    case ZSTDds_decodeBlockHeader: 
         {   blockProperties_t bp;
-            size_t const cBlockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
-            if (ZSTD_isError(cBlockSize)) return cBlockSize;
-            if (bp.blockType == bt_end) {
-                dctx->expected = 0;
-                dctx->stage = ZSTDds_getFrameHeaderSize;
-            } else {
-                dctx->expected = cBlockSize;
-                dctx->bType = bp.blockType;
-                dctx->stage = ZSTDds_decompressBlock;
-            }
-            return 0;
-        }
-    case ZSTDds_decompressBlock:
+            size_t const cBlockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp); 
+            if (ZSTD_isError(cBlockSize)) return cBlockSize; 
+            if (bp.blockType == bt_end) { 
+                dctx->expected = 0; 
+                dctx->stage = ZSTDds_getFrameHeaderSize; 
+            } else { 
+                dctx->expected = cBlockSize; 
+                dctx->bType = bp.blockType; 
+                dctx->stage = ZSTDds_decompressBlock; 
+            } 
+            return 0; 
+        } 
+    case ZSTDds_decompressBlock: 
         {   size_t rSize;
-            switch(dctx->bType)
-            {
-            case bt_compressed:
+            switch(dctx->bType) 
+            { 
+            case bt_compressed: 
                 rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
-                break;
-            case bt_raw :
+                break; 
+            case bt_raw : 
                 rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize);
-                break;
-            case bt_rle :
-                return ERROR(GENERIC);   /* not yet handled */
-                break;
-            case bt_end :   /* should never happen (filtered at phase 1) */
-                rSize = 0;
-                break;
-            default:
-                return ERROR(GENERIC);   /* impossible */
-            }
-            dctx->stage = ZSTDds_decodeBlockHeader;
-            dctx->expected = ZSTD_blockHeaderSize;
-            dctx->previousDstEnd = (char*)dst + rSize;
-            return rSize;
-        }
-    default:
-        return ERROR(GENERIC);   /* impossible */
-    }
-}
-
-
-static void ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    dctx->dictEnd = dctx->previousDstEnd;
-    dctx->vBase = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));
-    dctx->base = dict;
-    dctx->previousDstEnd = (const char*)dict + dictSize;
-}
-
-static size_t ZSTD_loadEntropy(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
-{
+                break; 
+            case bt_rle : 
+                return ERROR(GENERIC);   /* not yet handled */ 
+                break; 
+            case bt_end :   /* should never happen (filtered at phase 1) */ 
+                rSize = 0; 
+                break; 
+            default: 
+                return ERROR(GENERIC);   /* impossible */ 
+            } 
+            dctx->stage = ZSTDds_decodeBlockHeader; 
+            dctx->expected = ZSTD_blockHeaderSize; 
+            dctx->previousDstEnd = (char*)dst + rSize; 
+            return rSize; 
+        } 
+    default: 
+        return ERROR(GENERIC);   /* impossible */ 
+    } 
+} 
+ 
+ 
+static void ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
+    dctx->dictEnd = dctx->previousDstEnd; 
+    dctx->vBase = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base)); 
+    dctx->base = dict; 
+    dctx->previousDstEnd = (const char*)dict + dictSize; 
+} 
+ 
+static size_t ZSTD_loadEntropy(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
     size_t hSize, offcodeHeaderSize, matchlengthHeaderSize, litlengthHeaderSize;
-
-    hSize = HUF_readDTableX4(dctx->hufTableX4, dict, dictSize);
-    if (HUF_isError(hSize)) return ERROR(dictionary_corrupted);
-    dict = (const char*)dict + hSize;
-    dictSize -= hSize;
-
+ 
+    hSize = HUF_readDTableX4(dctx->hufTableX4, dict, dictSize); 
+    if (HUF_isError(hSize)) return ERROR(dictionary_corrupted); 
+    dict = (const char*)dict + hSize; 
+    dictSize -= hSize; 
+ 
     {   short offcodeNCount[MaxOff+1];
         U32 offcodeMaxValue=MaxOff, offcodeLog=OffFSELog;
         offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dict, dictSize);
@@ -1067,7 +1067,7 @@ static size_t ZSTD_loadEntropy(ZSTD_DCtx* dctx, const void* dict, size_t dictSiz
         dict = (const char*)dict + offcodeHeaderSize;
         dictSize -= offcodeHeaderSize;
     }
-
+ 
     {   short matchlengthNCount[MaxML+1];
         unsigned matchlengthMaxValue = MaxML, matchlengthLog = MLFSELog;
         matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dict, dictSize);
@@ -1077,7 +1077,7 @@ static size_t ZSTD_loadEntropy(ZSTD_DCtx* dctx, const void* dict, size_t dictSiz
         dict = (const char*)dict + matchlengthHeaderSize;
         dictSize -= matchlengthHeaderSize;
     }
-
+ 
     {   short litlengthNCount[MaxLL+1];
         unsigned litlengthMaxValue = MaxLL, litlengthLog = LLFSELog;
         litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dict, dictSize);
@@ -1085,45 +1085,45 @@ static size_t ZSTD_loadEntropy(ZSTD_DCtx* dctx, const void* dict, size_t dictSiz
         { size_t const errorCode = FSE_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog);
           if (FSE_isError(errorCode)) return ERROR(dictionary_corrupted); }
     }
-
-    dctx->flagRepeatTable = 1;
-    return hSize + offcodeHeaderSize + matchlengthHeaderSize + litlengthHeaderSize;
-}
-
-static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    size_t eSize;
-    U32 const magic = MEM_readLE32(dict);
-    if (magic != ZSTD_DICT_MAGIC) {
-        /* pure content mode */
-        ZSTD_refDictContent(dctx, dict, dictSize);
-        return 0;
-    }
-    /* load entropy tables */
-    dict = (const char*)dict + 4;
-    dictSize -= 4;
-    eSize = ZSTD_loadEntropy(dctx, dict, dictSize);
-    if (ZSTD_isError(eSize)) return ERROR(dictionary_corrupted);
-
-    /* reference dictionary content */
-    dict = (const char*)dict + eSize;
-    dictSize -= eSize;
-    ZSTD_refDictContent(dctx, dict, dictSize);
-
-    return 0;
-}
-
-
-size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    { size_t const errorCode = ZSTD_decompressBegin(dctx);
-      if (ZSTD_isError(errorCode)) return errorCode; }
-
-    if (dict && dictSize) {
-        size_t const errorCode = ZSTD_decompress_insertDictionary(dctx, dict, dictSize);
-        if (ZSTD_isError(errorCode)) return ERROR(dictionary_corrupted);
-    }
-
-    return 0;
-}
-
+ 
+    dctx->flagRepeatTable = 1; 
+    return hSize + offcodeHeaderSize + matchlengthHeaderSize + litlengthHeaderSize; 
+} 
+ 
+static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
+    size_t eSize; 
+    U32 const magic = MEM_readLE32(dict); 
+    if (magic != ZSTD_DICT_MAGIC) { 
+        /* pure content mode */ 
+        ZSTD_refDictContent(dctx, dict, dictSize); 
+        return 0; 
+    } 
+    /* load entropy tables */ 
+    dict = (const char*)dict + 4; 
+    dictSize -= 4; 
+    eSize = ZSTD_loadEntropy(dctx, dict, dictSize); 
+    if (ZSTD_isError(eSize)) return ERROR(dictionary_corrupted); 
+ 
+    /* reference dictionary content */ 
+    dict = (const char*)dict + eSize; 
+    dictSize -= eSize; 
+    ZSTD_refDictContent(dctx, dict, dictSize); 
+ 
+    return 0; 
+} 
+ 
+ 
+size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
+    { size_t const errorCode = ZSTD_decompressBegin(dctx); 
+      if (ZSTD_isError(errorCode)) return errorCode; } 
+ 
+    if (dict && dictSize) { 
+        size_t const errorCode = ZSTD_decompress_insertDictionary(dctx, dict, dictSize); 
+        if (ZSTD_isError(errorCode)) return ERROR(dictionary_corrupted); 
+    } 
+ 
+    return 0; 
+} 
+ 
diff --git a/contrib/libs/zstd06/dictBuilder/divsufsort.c b/contrib/libs/zstd06/dictBuilder/divsufsort.c
index 60cceb0883..17116166b4 100644
--- a/contrib/libs/zstd06/dictBuilder/divsufsort.c
+++ b/contrib/libs/zstd06/dictBuilder/divsufsort.c
@@ -1,1913 +1,1913 @@
-/*
- * divsufsort.c for libdivsufsort-lite
- * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following
- * conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/*- Compiler specifics -*/
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wshorten-64-to-32"
-#endif
-
-#if defined(_MSC_VER)
-#  pragma warning(disable : 4244)
-#  pragma warning(disable : 4127)    /* C4127 : Condition expression is constant */
-#endif
-
-
-/*- Dependencies -*/
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "divsufsort.h"
-
-/*- Constants -*/
-#if defined(INLINE)
-# undef INLINE
-#endif
-#if !defined(INLINE)
-# define INLINE __inline
-#endif
-#if defined(ALPHABET_SIZE) && (ALPHABET_SIZE < 1)
-# undef ALPHABET_SIZE
-#endif
-#if !defined(ALPHABET_SIZE)
-# define ALPHABET_SIZE (256)
-#endif
-#define BUCKET_A_SIZE (ALPHABET_SIZE)
-#define BUCKET_B_SIZE (ALPHABET_SIZE * ALPHABET_SIZE)
-#if defined(SS_INSERTIONSORT_THRESHOLD)
-# if SS_INSERTIONSORT_THRESHOLD < 1
-#  undef SS_INSERTIONSORT_THRESHOLD
-#  define SS_INSERTIONSORT_THRESHOLD (1)
-# endif
-#else
-# define SS_INSERTIONSORT_THRESHOLD (8)
-#endif
-#if defined(SS_BLOCKSIZE)
-# if SS_BLOCKSIZE < 0
-#  undef SS_BLOCKSIZE
-#  define SS_BLOCKSIZE (0)
-# elif 32768 <= SS_BLOCKSIZE
-#  undef SS_BLOCKSIZE
-#  define SS_BLOCKSIZE (32767)
-# endif
-#else
-# define SS_BLOCKSIZE (1024)
-#endif
-/* minstacksize = log(SS_BLOCKSIZE) / log(3) * 2 */
-#if SS_BLOCKSIZE == 0
-# define SS_MISORT_STACKSIZE (96)
-#elif SS_BLOCKSIZE <= 4096
-# define SS_MISORT_STACKSIZE (16)
-#else
-# define SS_MISORT_STACKSIZE (24)
-#endif
-#define SS_SMERGE_STACKSIZE (32)
-#define TR_INSERTIONSORT_THRESHOLD (8)
-#define TR_STACKSIZE (64)
-
-
-/*- Macros -*/
-#ifndef SWAP
-# define SWAP(_a, _b) do { t = (_a); (_a) = (_b); (_b) = t; } while(0)
-#endif /* SWAP */
-#ifndef MIN
-# define MIN(_a, _b) (((_a) < (_b)) ? (_a) : (_b))
-#endif /* MIN */
-#ifndef MAX
-# define MAX(_a, _b) (((_a) > (_b)) ? (_a) : (_b))
-#endif /* MAX */
-#define STACK_PUSH(_a, _b, _c, _d)\
-  do {\
-    assert(ssize < STACK_SIZE);\
-    stack[ssize].a = (_a), stack[ssize].b = (_b),\
-    stack[ssize].c = (_c), stack[ssize++].d = (_d);\
-  } while(0)
-#define STACK_PUSH5(_a, _b, _c, _d, _e)\
-  do {\
-    assert(ssize < STACK_SIZE);\
-    stack[ssize].a = (_a), stack[ssize].b = (_b),\
-    stack[ssize].c = (_c), stack[ssize].d = (_d), stack[ssize++].e = (_e);\
-  } while(0)
-#define STACK_POP(_a, _b, _c, _d)\
-  do {\
-    assert(0 <= ssize);\
-    if(ssize == 0) { return; }\
-    (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\
-    (_c) = stack[ssize].c, (_d) = stack[ssize].d;\
-  } while(0)
-#define STACK_POP5(_a, _b, _c, _d, _e)\
-  do {\
-    assert(0 <= ssize);\
-    if(ssize == 0) { return; }\
-    (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\
-    (_c) = stack[ssize].c, (_d) = stack[ssize].d, (_e) = stack[ssize].e;\
-  } while(0)
-#define BUCKET_A(_c0) bucket_A[(_c0)]
-#if ALPHABET_SIZE == 256
-#define BUCKET_B(_c0, _c1) (bucket_B[((_c1) << 8) | (_c0)])
-#define BUCKET_BSTAR(_c0, _c1) (bucket_B[((_c0) << 8) | (_c1)])
-#else
-#define BUCKET_B(_c0, _c1) (bucket_B[(_c1) * ALPHABET_SIZE + (_c0)])
-#define BUCKET_BSTAR(_c0, _c1) (bucket_B[(_c0) * ALPHABET_SIZE + (_c1)])
-#endif
-
-
-/*- Private Functions -*/
-
-static const int lg_table[256]= {
- -1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
-  5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
-};
-
-#if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE)
-
-static INLINE
-int
-ss_ilg(int n) {
-#if SS_BLOCKSIZE == 0
-  return (n & 0xffff0000) ?
-          ((n & 0xff000000) ?
-            24 + lg_table[(n >> 24) & 0xff] :
-            16 + lg_table[(n >> 16) & 0xff]) :
-          ((n & 0x0000ff00) ?
-             8 + lg_table[(n >>  8) & 0xff] :
-             0 + lg_table[(n >>  0) & 0xff]);
-#elif SS_BLOCKSIZE < 256
-  return lg_table[n];
-#else
-  return (n & 0xff00) ?
-          8 + lg_table[(n >> 8) & 0xff] :
-          0 + lg_table[(n >> 0) & 0xff];
-#endif
-}
-
-#endif /* (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) */
-
-#if SS_BLOCKSIZE != 0
-
-static const int sqq_table[256] = {
-  0,  16,  22,  27,  32,  35,  39,  42,  45,  48,  50,  53,  55,  57,  59,  61,
- 64,  65,  67,  69,  71,  73,  75,  76,  78,  80,  81,  83,  84,  86,  87,  89,
- 90,  91,  93,  94,  96,  97,  98,  99, 101, 102, 103, 104, 106, 107, 108, 109,
-110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
-128, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
-143, 144, 144, 145, 146, 147, 148, 149, 150, 150, 151, 152, 153, 154, 155, 155,
-156, 157, 158, 159, 160, 160, 161, 162, 163, 163, 164, 165, 166, 167, 167, 168,
-169, 170, 170, 171, 172, 173, 173, 174, 175, 176, 176, 177, 178, 178, 179, 180,
-181, 181, 182, 183, 183, 184, 185, 185, 186, 187, 187, 188, 189, 189, 190, 191,
-192, 192, 193, 193, 194, 195, 195, 196, 197, 197, 198, 199, 199, 200, 201, 201,
-202, 203, 203, 204, 204, 205, 206, 206, 207, 208, 208, 209, 209, 210, 211, 211,
-212, 212, 213, 214, 214, 215, 215, 216, 217, 217, 218, 218, 219, 219, 220, 221,
-221, 222, 222, 223, 224, 224, 225, 225, 226, 226, 227, 227, 228, 229, 229, 230,
-230, 231, 231, 232, 232, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238,
-239, 240, 240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247,
-247, 248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255
-};
-
-static INLINE
-int
-ss_isqrt(int x) {
-  int y, e;
-
-  if(x >= (SS_BLOCKSIZE * SS_BLOCKSIZE)) { return SS_BLOCKSIZE; }
-  e = (x & 0xffff0000) ?
-        ((x & 0xff000000) ?
-          24 + lg_table[(x >> 24) & 0xff] :
-          16 + lg_table[(x >> 16) & 0xff]) :
-        ((x & 0x0000ff00) ?
-           8 + lg_table[(x >>  8) & 0xff] :
-           0 + lg_table[(x >>  0) & 0xff]);
-
-  if(e >= 16) {
-    y = sqq_table[x >> ((e - 6) - (e & 1))] << ((e >> 1) - 7);
-    if(e >= 24) { y = (y + 1 + x / y) >> 1; }
-    y = (y + 1 + x / y) >> 1;
-  } else if(e >= 8) {
-    y = (sqq_table[x >> ((e - 6) - (e & 1))] >> (7 - (e >> 1))) + 1;
-  } else {
-    return sqq_table[x] >> 4;
-  }
-
-  return (x < (y * y)) ? y - 1 : y;
-}
-
-#endif /* SS_BLOCKSIZE != 0 */
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Compares two suffixes. */
-static INLINE
-int
-ss_compare(const unsigned char *T,
-           const int *p1, const int *p2,
-           int depth) {
-  const unsigned char *U1, *U2, *U1n, *U2n;
-
-  for(U1 = T + depth + *p1,
-      U2 = T + depth + *p2,
-      U1n = T + *(p1 + 1) + 2,
-      U2n = T + *(p2 + 1) + 2;
-      (U1 < U1n) && (U2 < U2n) && (*U1 == *U2);
-      ++U1, ++U2) {
-  }
-
-  return U1 < U1n ?
-        (U2 < U2n ? *U1 - *U2 : 1) :
-        (U2 < U2n ? -1 : 0);
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-#if (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1)
-
-/* Insertionsort for small size groups */
-static
-void
-ss_insertionsort(const unsigned char *T, const int *PA,
-                 int *first, int *last, int depth) {
-  int *i, *j;
-  int t;
-  int r;
-
-  for(i = last - 2; first <= i; --i) {
-    for(t = *i, j = i + 1; 0 < (r = ss_compare(T, PA + t, PA + *j, depth));) {
-      do { *(j - 1) = *j; } while((++j < last) && (*j < 0));
-      if(last <= j) { break; }
-    }
-    if(r == 0) { *j = ~*j; }
-    *(j - 1) = t;
-  }
-}
-
-#endif /* (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1) */
-
-
-/*---------------------------------------------------------------------------*/
-
-#if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE)
-
-static INLINE
-void
-ss_fixdown(const unsigned char *Td, const int *PA,
-           int *SA, int i, int size) {
-  int j, k;
-  int v;
-  int c, d, e;
-
-  for(v = SA[i], c = Td[PA[v]]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) {
-    d = Td[PA[SA[k = j++]]];
-    if(d < (e = Td[PA[SA[j]]])) { k = j; d = e; }
-    if(d <= c) { break; }
-  }
-  SA[i] = v;
-}
-
-/* Simple top-down heapsort. */
-static
-void
-ss_heapsort(const unsigned char *Td, const int *PA, int *SA, int size) {
-  int i, m;
-  int t;
-
-  m = size;
-  if((size % 2) == 0) {
-    m--;
-    if(Td[PA[SA[m / 2]]] < Td[PA[SA[m]]]) { SWAP(SA[m], SA[m / 2]); }
-  }
-
-  for(i = m / 2 - 1; 0 <= i; --i) { ss_fixdown(Td, PA, SA, i, m); }
-  if((size % 2) == 0) { SWAP(SA[0], SA[m]); ss_fixdown(Td, PA, SA, 0, m); }
-  for(i = m - 1; 0 < i; --i) {
-    t = SA[0], SA[0] = SA[i];
-    ss_fixdown(Td, PA, SA, 0, i);
-    SA[i] = t;
-  }
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Returns the median of three elements. */
-static INLINE
-int *
-ss_median3(const unsigned char *Td, const int *PA,
-           int *v1, int *v2, int *v3) {
-  int *t;
-  if(Td[PA[*v1]] > Td[PA[*v2]]) { SWAP(v1, v2); }
-  if(Td[PA[*v2]] > Td[PA[*v3]]) {
-    if(Td[PA[*v1]] > Td[PA[*v3]]) { return v1; }
-    else { return v3; }
-  }
-  return v2;
-}
-
-/* Returns the median of five elements. */
-static INLINE
-int *
-ss_median5(const unsigned char *Td, const int *PA,
-           int *v1, int *v2, int *v3, int *v4, int *v5) {
-  int *t;
-  if(Td[PA[*v2]] > Td[PA[*v3]]) { SWAP(v2, v3); }
-  if(Td[PA[*v4]] > Td[PA[*v5]]) { SWAP(v4, v5); }
-  if(Td[PA[*v2]] > Td[PA[*v4]]) { SWAP(v2, v4); SWAP(v3, v5); }
-  if(Td[PA[*v1]] > Td[PA[*v3]]) { SWAP(v1, v3); }
-  if(Td[PA[*v1]] > Td[PA[*v4]]) { SWAP(v1, v4); SWAP(v3, v5); }
-  if(Td[PA[*v3]] > Td[PA[*v4]]) { return v4; }
-  return v3;
-}
-
-/* Returns the pivot element. */
-static INLINE
-int *
-ss_pivot(const unsigned char *Td, const int *PA, int *first, int *last) {
-  int *middle;
-  int t;
-
-  t = last - first;
-  middle = first + t / 2;
-
-  if(t <= 512) {
-    if(t <= 32) {
-      return ss_median3(Td, PA, first, middle, last - 1);
-    } else {
-      t >>= 2;
-      return ss_median5(Td, PA, first, first + t, middle, last - 1 - t, last - 1);
-    }
-  }
-  t >>= 3;
-  first  = ss_median3(Td, PA, first, first + t, first + (t << 1));
-  middle = ss_median3(Td, PA, middle - t, middle, middle + t);
-  last   = ss_median3(Td, PA, last - 1 - (t << 1), last - 1 - t, last - 1);
-  return ss_median3(Td, PA, first, middle, last);
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Binary partition for substrings. */
-static INLINE
-int *
-ss_partition(const int *PA,
-                    int *first, int *last, int depth) {
-  int *a, *b;
-  int t;
-  for(a = first - 1, b = last;;) {
-    for(; (++a < b) && ((PA[*a] + depth) >= (PA[*a + 1] + 1));) { *a = ~*a; }
-    for(; (a < --b) && ((PA[*b] + depth) <  (PA[*b + 1] + 1));) { }
-    if(b <= a) { break; }
-    t = ~*b;
-    *b = *a;
-    *a = t;
-  }
-  if(first < a) { *first = ~*first; }
-  return a;
-}
-
-/* Multikey introsort for medium size groups. */
-static
-void
-ss_mintrosort(const unsigned char *T, const int *PA,
-              int *first, int *last,
-              int depth) {
-#define STACK_SIZE SS_MISORT_STACKSIZE
-  struct { int *a, *b, c; int d; } stack[STACK_SIZE];
-  const unsigned char *Td;
-  int *a, *b, *c, *d, *e, *f;
-  int s, t;
-  int ssize;
-  int limit;
-  int v, x = 0;
-
-  for(ssize = 0, limit = ss_ilg(last - first);;) {
-
-    if((last - first) <= SS_INSERTIONSORT_THRESHOLD) {
-#if 1 < SS_INSERTIONSORT_THRESHOLD
-      if(1 < (last - first)) { ss_insertionsort(T, PA, first, last, depth); }
-#endif
-      STACK_POP(first, last, depth, limit);
-      continue;
-    }
-
-    Td = T + depth;
-    if(limit-- == 0) { ss_heapsort(Td, PA, first, last - first); }
-    if(limit < 0) {
-      for(a = first + 1, v = Td[PA[*first]]; a < last; ++a) {
-        if((x = Td[PA[*a]]) != v) {
-          if(1 < (a - first)) { break; }
-          v = x;
-          first = a;
-        }
-      }
-      if(Td[PA[*first] - 1] < v) {
-        first = ss_partition(PA, first, a, depth);
-      }
-      if((a - first) <= (last - a)) {
-        if(1 < (a - first)) {
-          STACK_PUSH(a, last, depth, -1);
-          last = a, depth += 1, limit = ss_ilg(a - first);
-        } else {
-          first = a, limit = -1;
-        }
-      } else {
-        if(1 < (last - a)) {
-          STACK_PUSH(first, a, depth + 1, ss_ilg(a - first));
-          first = a, limit = -1;
-        } else {
-          last = a, depth += 1, limit = ss_ilg(a - first);
-        }
-      }
-      continue;
-    }
-
-    /* choose pivot */
-    a = ss_pivot(Td, PA, first, last);
-    v = Td[PA[*a]];
-    SWAP(*first, *a);
-
-    /* partition */
-    for(b = first; (++b < last) && ((x = Td[PA[*b]]) == v);) { }
-    if(((a = b) < last) && (x < v)) {
-      for(; (++b < last) && ((x = Td[PA[*b]]) <= v);) {
-        if(x == v) { SWAP(*b, *a); ++a; }
-      }
-    }
-    for(c = last; (b < --c) && ((x = Td[PA[*c]]) == v);) { }
-    if((b < (d = c)) && (x > v)) {
-      for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) {
-        if(x == v) { SWAP(*c, *d); --d; }
-      }
-    }
-    for(; b < c;) {
-      SWAP(*b, *c);
-      for(; (++b < c) && ((x = Td[PA[*b]]) <= v);) {
-        if(x == v) { SWAP(*b, *a); ++a; }
-      }
-      for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) {
-        if(x == v) { SWAP(*c, *d); --d; }
-      }
-    }
-
-    if(a <= d) {
-      c = b - 1;
-
-      if((s = a - first) > (t = b - a)) { s = t; }
-      for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
-      if((s = d - c) > (t = last - d - 1)) { s = t; }
-      for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
-
-      a = first + (b - a), c = last - (d - c);
-      b = (v <= Td[PA[*a] - 1]) ? a : ss_partition(PA, a, c, depth);
-
-      if((a - first) <= (last - c)) {
-        if((last - c) <= (c - b)) {
-          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
-          STACK_PUSH(c, last, depth, limit);
-          last = a;
-        } else if((a - first) <= (c - b)) {
-          STACK_PUSH(c, last, depth, limit);
-          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
-          last = a;
-        } else {
-          STACK_PUSH(c, last, depth, limit);
-          STACK_PUSH(first, a, depth, limit);
-          first = b, last = c, depth += 1, limit = ss_ilg(c - b);
-        }
-      } else {
-        if((a - first) <= (c - b)) {
-          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
-          STACK_PUSH(first, a, depth, limit);
-          first = c;
-        } else if((last - c) <= (c - b)) {
-          STACK_PUSH(first, a, depth, limit);
-          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
-          first = c;
-        } else {
-          STACK_PUSH(first, a, depth, limit);
-          STACK_PUSH(c, last, depth, limit);
-          first = b, last = c, depth += 1, limit = ss_ilg(c - b);
-        }
-      }
-    } else {
-      limit += 1;
-      if(Td[PA[*first] - 1] < v) {
-        first = ss_partition(PA, first, last, depth);
-        limit = ss_ilg(last - first);
-      }
-      depth += 1;
-    }
-  }
-#undef STACK_SIZE
-}
-
-#endif /* (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) */
-
-
-/*---------------------------------------------------------------------------*/
-
-#if SS_BLOCKSIZE != 0
-
-static INLINE
-void
-ss_blockswap(int *a, int *b, int n) {
-  int t;
-  for(; 0 < n; --n, ++a, ++b) {
-    t = *a, *a = *b, *b = t;
-  }
-}
-
-static INLINE
-void
-ss_rotate(int *first, int *middle, int *last) {
-  int *a, *b, t;
-  int l, r;
-  l = middle - first, r = last - middle;
-  for(; (0 < l) && (0 < r);) {
-    if(l == r) { ss_blockswap(first, middle, l); break; }
-    if(l < r) {
-      a = last - 1, b = middle - 1;
-      t = *a;
-      do {
-        *a-- = *b, *b-- = *a;
-        if(b < first) {
-          *a = t;
-          last = a;
-          if((r -= l + 1) <= l) { break; }
-          a -= 1, b = middle - 1;
-          t = *a;
-        }
-      } while(1);
-    } else {
-      a = first, b = middle;
-      t = *a;
-      do {
-        *a++ = *b, *b++ = *a;
-        if(last <= b) {
-          *a = t;
-          first = a + 1;
-          if((l -= r + 1) <= r) { break; }
-          a += 1, b = middle;
-          t = *a;
-        }
-      } while(1);
-    }
-  }
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-static
-void
-ss_inplacemerge(const unsigned char *T, const int *PA,
-                int *first, int *middle, int *last,
-                int depth) {
-  const int *p;
-  int *a, *b;
-  int len, half;
-  int q, r;
-  int x;
-
-  for(;;) {
-    if(*(last - 1) < 0) { x = 1; p = PA + ~*(last - 1); }
-    else                { x = 0; p = PA +  *(last - 1); }
-    for(a = first, len = middle - first, half = len >> 1, r = -1;
-        0 < len;
-        len = half, half >>= 1) {
-      b = a + half;
-      q = ss_compare(T, PA + ((0 <= *b) ? *b : ~*b), p, depth);
-      if(q < 0) {
-        a = b + 1;
-        half -= (len & 1) ^ 1;
-      } else {
-        r = q;
-      }
-    }
-    if(a < middle) {
-      if(r == 0) { *a = ~*a; }
-      ss_rotate(a, middle, last);
-      last -= middle - a;
-      middle = a;
-      if(first == middle) { break; }
-    }
-    --last;
-    if(x != 0) { while(*--last < 0) { } }
-    if(middle == last) { break; }
-  }
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Merge-forward with internal buffer. */
-static
-void
-ss_mergeforward(const unsigned char *T, const int *PA,
-                int *first, int *middle, int *last,
-                int *buf, int depth) {
-  int *a, *b, *c, *bufend;
-  int t;
-  int r;
-
-  bufend = buf + (middle - first) - 1;
-  ss_blockswap(buf, first, middle - first);
-
-  for(t = *(a = first), b = buf, c = middle;;) {
-    r = ss_compare(T, PA + *b, PA + *c, depth);
-    if(r < 0) {
-      do {
-        *a++ = *b;
-        if(bufend <= b) { *bufend = t; return; }
-        *b++ = *a;
-      } while(*b < 0);
-    } else if(r > 0) {
-      do {
-        *a++ = *c, *c++ = *a;
-        if(last <= c) {
-          while(b < bufend) { *a++ = *b, *b++ = *a; }
-          *a = *b, *b = t;
-          return;
-        }
-      } while(*c < 0);
-    } else {
-      *c = ~*c;
-      do {
-        *a++ = *b;
-        if(bufend <= b) { *bufend = t; return; }
-        *b++ = *a;
-      } while(*b < 0);
-
-      do {
-        *a++ = *c, *c++ = *a;
-        if(last <= c) {
-          while(b < bufend) { *a++ = *b, *b++ = *a; }
-          *a = *b, *b = t;
-          return;
-        }
-      } while(*c < 0);
-    }
-  }
-}
-
-/* Merge-backward with internal buffer. */
-static
-void
-ss_mergebackward(const unsigned char *T, const int *PA,
-                 int *first, int *middle, int *last,
-                 int *buf, int depth) {
-  const int *p1, *p2;
-  int *a, *b, *c, *bufend;
-  int t;
-  int r;
-  int x;
-
-  bufend = buf + (last - middle) - 1;
-  ss_blockswap(buf, middle, last - middle);
-
-  x = 0;
-  if(*bufend < 0)       { p1 = PA + ~*bufend; x |= 1; }
-  else                  { p1 = PA +  *bufend; }
-  if(*(middle - 1) < 0) { p2 = PA + ~*(middle - 1); x |= 2; }
-  else                  { p2 = PA +  *(middle - 1); }
-  for(t = *(a = last - 1), b = bufend, c = middle - 1;;) {
-    r = ss_compare(T, p1, p2, depth);
-    if(0 < r) {
-      if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; }
-      *a-- = *b;
-      if(b <= buf) { *buf = t; break; }
-      *b-- = *a;
-      if(*b < 0) { p1 = PA + ~*b; x |= 1; }
-      else       { p1 = PA +  *b; }
-    } else if(r < 0) {
-      if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; }
-      *a-- = *c, *c-- = *a;
-      if(c < first) {
-        while(buf < b) { *a-- = *b, *b-- = *a; }
-        *a = *b, *b = t;
-        break;
-      }
-      if(*c < 0) { p2 = PA + ~*c; x |= 2; }
-      else       { p2 = PA +  *c; }
-    } else {
-      if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; }
-      *a-- = ~*b;
-      if(b <= buf) { *buf = t; break; }
-      *b-- = *a;
-      if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; }
-      *a-- = *c, *c-- = *a;
-      if(c < first) {
-        while(buf < b) { *a-- = *b, *b-- = *a; }
-        *a = *b, *b = t;
-        break;
-      }
-      if(*b < 0) { p1 = PA + ~*b; x |= 1; }
-      else       { p1 = PA +  *b; }
-      if(*c < 0) { p2 = PA + ~*c; x |= 2; }
-      else       { p2 = PA +  *c; }
-    }
-  }
-}
-
-/* D&C based merge. */
-static
-void
-ss_swapmerge(const unsigned char *T, const int *PA,
-             int *first, int *middle, int *last,
-             int *buf, int bufsize, int depth) {
-#define STACK_SIZE SS_SMERGE_STACKSIZE
-#define GETIDX(a) ((0 <= (a)) ? (a) : (~(a)))
-#define MERGE_CHECK(a, b, c)\
-  do {\
-    if(((c) & 1) ||\
-       (((c) & 2) && (ss_compare(T, PA + GETIDX(*((a) - 1)), PA + *(a), depth) == 0))) {\
-      *(a) = ~*(a);\
-    }\
-    if(((c) & 4) && ((ss_compare(T, PA + GETIDX(*((b) - 1)), PA + *(b), depth) == 0))) {\
-      *(b) = ~*(b);\
-    }\
-  } while(0)
-  struct { int *a, *b, *c; int d; } stack[STACK_SIZE];
-  int *l, *r, *lm, *rm;
-  int m, len, half;
-  int ssize;
-  int check, next;
-
-  for(check = 0, ssize = 0;;) {
-    if((last - middle) <= bufsize) {
-      if((first < middle) && (middle < last)) {
-        ss_mergebackward(T, PA, first, middle, last, buf, depth);
-      }
-      MERGE_CHECK(first, last, check);
-      STACK_POP(first, middle, last, check);
-      continue;
-    }
-
-    if((middle - first) <= bufsize) {
-      if(first < middle) {
-        ss_mergeforward(T, PA, first, middle, last, buf, depth);
-      }
-      MERGE_CHECK(first, last, check);
-      STACK_POP(first, middle, last, check);
-      continue;
-    }
-
-    for(m = 0, len = MIN(middle - first, last - middle), half = len >> 1;
-        0 < len;
-        len = half, half >>= 1) {
-      if(ss_compare(T, PA + GETIDX(*(middle + m + half)),
-                       PA + GETIDX(*(middle - m - half - 1)), depth) < 0) {
-        m += half + 1;
-        half -= (len & 1) ^ 1;
-      }
-    }
-
-    if(0 < m) {
-      lm = middle - m, rm = middle + m;
-      ss_blockswap(lm, middle, m);
-      l = r = middle, next = 0;
-      if(rm < last) {
-        if(*rm < 0) {
-          *rm = ~*rm;
-          if(first < lm) { for(; *--l < 0;) { } next |= 4; }
-          next |= 1;
-        } else if(first < lm) {
-          for(; *r < 0; ++r) { }
-          next |= 2;
-        }
-      }
-
-      if((l - first) <= (last - r)) {
-        STACK_PUSH(r, rm, last, (next & 3) | (check & 4));
-        middle = lm, last = l, check = (check & 3) | (next & 4);
-      } else {
-        if((next & 2) && (r == middle)) { next ^= 6; }
-        STACK_PUSH(first, lm, l, (check & 3) | (next & 4));
-        first = r, middle = rm, check = (next & 3) | (check & 4);
-      }
-    } else {
-      if(ss_compare(T, PA + GETIDX(*(middle - 1)), PA + *middle, depth) == 0) {
-        *middle = ~*middle;
-      }
-      MERGE_CHECK(first, last, check);
-      STACK_POP(first, middle, last, check);
-    }
-  }
-#undef STACK_SIZE
-}
-
-#endif /* SS_BLOCKSIZE != 0 */
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Substring sort */
-static
-void
-sssort(const unsigned char *T, const int *PA,
-       int *first, int *last,
-       int *buf, int bufsize,
-       int depth, int n, int lastsuffix) {
-  int *a;
-#if SS_BLOCKSIZE != 0
-  int *b, *middle, *curbuf;
-  int j, k, curbufsize, limit;
-#endif
-  int i;
-
-  if(lastsuffix != 0) { ++first; }
-
-#if SS_BLOCKSIZE == 0
-  ss_mintrosort(T, PA, first, last, depth);
-#else
-  if((bufsize < SS_BLOCKSIZE) &&
-      (bufsize < (last - first)) &&
-      (bufsize < (limit = ss_isqrt(last - first)))) {
-    if(SS_BLOCKSIZE < limit) { limit = SS_BLOCKSIZE; }
-    buf = middle = last - limit, bufsize = limit;
-  } else {
-    middle = last, limit = 0;
-  }
-  for(a = first, i = 0; SS_BLOCKSIZE < (middle - a); a += SS_BLOCKSIZE, ++i) {
-#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
-    ss_mintrosort(T, PA, a, a + SS_BLOCKSIZE, depth);
-#elif 1 < SS_BLOCKSIZE
-    ss_insertionsort(T, PA, a, a + SS_BLOCKSIZE, depth);
-#endif
-    curbufsize = last - (a + SS_BLOCKSIZE);
-    curbuf = a + SS_BLOCKSIZE;
-    if(curbufsize <= bufsize) { curbufsize = bufsize, curbuf = buf; }
-    for(b = a, k = SS_BLOCKSIZE, j = i; j & 1; b -= k, k <<= 1, j >>= 1) {
-      ss_swapmerge(T, PA, b - k, b, b + k, curbuf, curbufsize, depth);
-    }
-  }
-#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
-  ss_mintrosort(T, PA, a, middle, depth);
-#elif 1 < SS_BLOCKSIZE
-  ss_insertionsort(T, PA, a, middle, depth);
-#endif
-  for(k = SS_BLOCKSIZE; i != 0; k <<= 1, i >>= 1) {
-    if(i & 1) {
-      ss_swapmerge(T, PA, a - k, a, middle, buf, bufsize, depth);
-      a -= k;
-    }
-  }
-  if(limit != 0) {
-#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
-    ss_mintrosort(T, PA, middle, last, depth);
-#elif 1 < SS_BLOCKSIZE
-    ss_insertionsort(T, PA, middle, last, depth);
-#endif
-    ss_inplacemerge(T, PA, first, middle, last, depth);
-  }
-#endif
-
-  if(lastsuffix != 0) {
-    /* Insert last type B* suffix. */
-    int PAi[2]; PAi[0] = PA[*(first - 1)], PAi[1] = n - 2;
-    for(a = first, i = *(first - 1);
-        (a < last) && ((*a < 0) || (0 < ss_compare(T, &(PAi[0]), PA + *a, depth)));
-        ++a) {
-      *(a - 1) = *a;
-    }
-    *(a - 1) = i;
-  }
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-static INLINE
-int
-tr_ilg(int n) {
-  return (n & 0xffff0000) ?
-          ((n & 0xff000000) ?
-            24 + lg_table[(n >> 24) & 0xff] :
-            16 + lg_table[(n >> 16) & 0xff]) :
-          ((n & 0x0000ff00) ?
-             8 + lg_table[(n >>  8) & 0xff] :
-             0 + lg_table[(n >>  0) & 0xff]);
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Simple insertionsort for small size groups. */
-static
-void
-tr_insertionsort(const int *ISAd, int *first, int *last) {
-  int *a, *b;
-  int t, r;
-
-  for(a = first + 1; a < last; ++a) {
-    for(t = *a, b = a - 1; 0 > (r = ISAd[t] - ISAd[*b]);) {
-      do { *(b + 1) = *b; } while((first <= --b) && (*b < 0));
-      if(b < first) { break; }
-    }
-    if(r == 0) { *b = ~*b; }
-    *(b + 1) = t;
-  }
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-static INLINE
-void
-tr_fixdown(const int *ISAd, int *SA, int i, int size) {
-  int j, k;
-  int v;
-  int c, d, e;
-
-  for(v = SA[i], c = ISAd[v]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) {
-    d = ISAd[SA[k = j++]];
-    if(d < (e = ISAd[SA[j]])) { k = j; d = e; }
-    if(d <= c) { break; }
-  }
-  SA[i] = v;
-}
-
-/* Simple top-down heapsort. */
-static
-void
-tr_heapsort(const int *ISAd, int *SA, int size) {
-  int i, m;
-  int t;
-
-  m = size;
-  if((size % 2) == 0) {
-    m--;
-    if(ISAd[SA[m / 2]] < ISAd[SA[m]]) { SWAP(SA[m], SA[m / 2]); }
-  }
-
-  for(i = m / 2 - 1; 0 <= i; --i) { tr_fixdown(ISAd, SA, i, m); }
-  if((size % 2) == 0) { SWAP(SA[0], SA[m]); tr_fixdown(ISAd, SA, 0, m); }
-  for(i = m - 1; 0 < i; --i) {
-    t = SA[0], SA[0] = SA[i];
-    tr_fixdown(ISAd, SA, 0, i);
-    SA[i] = t;
-  }
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Returns the median of three elements. */
-static INLINE
-int *
-tr_median3(const int *ISAd, int *v1, int *v2, int *v3) {
-  int *t;
-  if(ISAd[*v1] > ISAd[*v2]) { SWAP(v1, v2); }
-  if(ISAd[*v2] > ISAd[*v3]) {
-    if(ISAd[*v1] > ISAd[*v3]) { return v1; }
-    else { return v3; }
-  }
-  return v2;
-}
-
-/* Returns the median of five elements. */
-static INLINE
-int *
-tr_median5(const int *ISAd,
-           int *v1, int *v2, int *v3, int *v4, int *v5) {
-  int *t;
-  if(ISAd[*v2] > ISAd[*v3]) { SWAP(v2, v3); }
-  if(ISAd[*v4] > ISAd[*v5]) { SWAP(v4, v5); }
-  if(ISAd[*v2] > ISAd[*v4]) { SWAP(v2, v4); SWAP(v3, v5); }
-  if(ISAd[*v1] > ISAd[*v3]) { SWAP(v1, v3); }
-  if(ISAd[*v1] > ISAd[*v4]) { SWAP(v1, v4); SWAP(v3, v5); }
-  if(ISAd[*v3] > ISAd[*v4]) { return v4; }
-  return v3;
-}
-
-/* Returns the pivot element. */
-static INLINE
-int *
-tr_pivot(const int *ISAd, int *first, int *last) {
-  int *middle;
-  int t;
-
-  t = last - first;
-  middle = first + t / 2;
-
-  if(t <= 512) {
-    if(t <= 32) {
-      return tr_median3(ISAd, first, middle, last - 1);
-    } else {
-      t >>= 2;
-      return tr_median5(ISAd, first, first + t, middle, last - 1 - t, last - 1);
-    }
-  }
-  t >>= 3;
-  first  = tr_median3(ISAd, first, first + t, first + (t << 1));
-  middle = tr_median3(ISAd, middle - t, middle, middle + t);
-  last   = tr_median3(ISAd, last - 1 - (t << 1), last - 1 - t, last - 1);
-  return tr_median3(ISAd, first, middle, last);
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-typedef struct _trbudget_t trbudget_t;
-struct _trbudget_t {
-  int chance;
-  int remain;
-  int incval;
-  int count;
-};
-
-static INLINE
-void
-trbudget_init(trbudget_t *budget, int chance, int incval) {
-  budget->chance = chance;
-  budget->remain = budget->incval = incval;
-}
-
-static INLINE
-int
-trbudget_check(trbudget_t *budget, int size) {
-  if(size <= budget->remain) { budget->remain -= size; return 1; }
-  if(budget->chance == 0) { budget->count += size; return 0; }
-  budget->remain += budget->incval - size;
-  budget->chance -= 1;
-  return 1;
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-static INLINE
-void
-tr_partition(const int *ISAd,
-             int *first, int *middle, int *last,
-             int **pa, int **pb, int v) {
-  int *a, *b, *c, *d, *e, *f;
-  int t, s;
-  int x = 0;
-
-  for(b = middle - 1; (++b < last) && ((x = ISAd[*b]) == v);) { }
-  if(((a = b) < last) && (x < v)) {
-    for(; (++b < last) && ((x = ISAd[*b]) <= v);) {
-      if(x == v) { SWAP(*b, *a); ++a; }
-    }
-  }
-  for(c = last; (b < --c) && ((x = ISAd[*c]) == v);) { }
-  if((b < (d = c)) && (x > v)) {
-    for(; (b < --c) && ((x = ISAd[*c]) >= v);) {
-      if(x == v) { SWAP(*c, *d); --d; }
-    }
-  }
-  for(; b < c;) {
-    SWAP(*b, *c);
-    for(; (++b < c) && ((x = ISAd[*b]) <= v);) {
-      if(x == v) { SWAP(*b, *a); ++a; }
-    }
-    for(; (b < --c) && ((x = ISAd[*c]) >= v);) {
-      if(x == v) { SWAP(*c, *d); --d; }
-    }
-  }
-
-  if(a <= d) {
-    c = b - 1;
-    if((s = a - first) > (t = b - a)) { s = t; }
-    for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
-    if((s = d - c) > (t = last - d - 1)) { s = t; }
-    for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
-    first += (b - a), last -= (d - c);
-  }
-  *pa = first, *pb = last;
-}
-
-static
-void
-tr_copy(int *ISA, const int *SA,
-        int *first, int *a, int *b, int *last,
-        int depth) {
-  /* sort suffixes of middle partition
-     by using sorted order of suffixes of left and right partition. */
-  int *c, *d, *e;
-  int s, v;
-
-  v = b - SA - 1;
-  for(c = first, d = a - 1; c <= d; ++c) {
-    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
-      *++d = s;
-      ISA[s] = d - SA;
-    }
-  }
-  for(c = last - 1, e = d + 1, d = b; e < d; --c) {
-    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
-      *--d = s;
-      ISA[s] = d - SA;
-    }
-  }
-}
-
-static
-void
-tr_partialcopy(int *ISA, const int *SA,
-               int *first, int *a, int *b, int *last,
-               int depth) {
-  int *c, *d, *e;
-  int s, v;
-  int rank, lastrank, newrank = -1;
-
-  v = b - SA - 1;
-  lastrank = -1;
-  for(c = first, d = a - 1; c <= d; ++c) {
-    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
-      *++d = s;
-      rank = ISA[s + depth];
-      if(lastrank != rank) { lastrank = rank; newrank = d - SA; }
-      ISA[s] = newrank;
-    }
-  }
-
-  lastrank = -1;
-  for(e = d; first <= e; --e) {
-    rank = ISA[*e];
-    if(lastrank != rank) { lastrank = rank; newrank = e - SA; }
-    if(newrank != rank) { ISA[*e] = newrank; }
-  }
-
-  lastrank = -1;
-  for(c = last - 1, e = d + 1, d = b; e < d; --c) {
-    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
-      *--d = s;
-      rank = ISA[s + depth];
-      if(lastrank != rank) { lastrank = rank; newrank = d - SA; }
-      ISA[s] = newrank;
-    }
-  }
-}
-
-static
-void
-tr_introsort(int *ISA, const int *ISAd,
-             int *SA, int *first, int *last,
-             trbudget_t *budget) {
-#define STACK_SIZE TR_STACKSIZE
-  struct { const int *a; int *b, *c; int d, e; }stack[STACK_SIZE];
-  int *a, *b, *c;
-  int t;
-  int v, x = 0;
-  int incr = ISAd - ISA;
-  int limit, next;
-  int ssize, trlink = -1;
-
-  for(ssize = 0, limit = tr_ilg(last - first);;) {
-
-    if(limit < 0) {
-      if(limit == -1) {
-        /* tandem repeat partition */
-        tr_partition(ISAd - incr, first, first, last, &a, &b, last - SA - 1);
-
-        /* update ranks */
-        if(a < last) {
-          for(c = first, v = a - SA - 1; c < a; ++c) { ISA[*c] = v; }
-        }
-        if(b < last) {
-          for(c = a, v = b - SA - 1; c < b; ++c) { ISA[*c] = v; }
-        }
-
-        /* push */
-        if(1 < (b - a)) {
-          STACK_PUSH5(NULL, a, b, 0, 0);
-          STACK_PUSH5(ISAd - incr, first, last, -2, trlink);
-          trlink = ssize - 2;
-        }
-        if((a - first) <= (last - b)) {
-          if(1 < (a - first)) {
-            STACK_PUSH5(ISAd, b, last, tr_ilg(last - b), trlink);
-            last = a, limit = tr_ilg(a - first);
-          } else if(1 < (last - b)) {
-            first = b, limit = tr_ilg(last - b);
-          } else {
-            STACK_POP5(ISAd, first, last, limit, trlink);
-          }
-        } else {
-          if(1 < (last - b)) {
-            STACK_PUSH5(ISAd, first, a, tr_ilg(a - first), trlink);
-            first = b, limit = tr_ilg(last - b);
-          } else if(1 < (a - first)) {
-            last = a, limit = tr_ilg(a - first);
-          } else {
-            STACK_POP5(ISAd, first, last, limit, trlink);
-          }
-        }
-      } else if(limit == -2) {
-        /* tandem repeat copy */
-        a = stack[--ssize].b, b = stack[ssize].c;
-        if(stack[ssize].d == 0) {
-          tr_copy(ISA, SA, first, a, b, last, ISAd - ISA);
-        } else {
-          if(0 <= trlink) { stack[trlink].d = -1; }
-          tr_partialcopy(ISA, SA, first, a, b, last, ISAd - ISA);
-        }
-        STACK_POP5(ISAd, first, last, limit, trlink);
-      } else {
-        /* sorted partition */
-        if(0 <= *first) {
-          a = first;
-          do { ISA[*a] = a - SA; } while((++a < last) && (0 <= *a));
-          first = a;
-        }
-        if(first < last) {
-          a = first; do { *a = ~*a; } while(*++a < 0);
-          next = (ISA[*a] != ISAd[*a]) ? tr_ilg(a - first + 1) : -1;
-          if(++a < last) { for(b = first, v = a - SA - 1; b < a; ++b) { ISA[*b] = v; } }
-
-          /* push */
-          if(trbudget_check(budget, a - first)) {
-            if((a - first) <= (last - a)) {
-              STACK_PUSH5(ISAd, a, last, -3, trlink);
-              ISAd += incr, last = a, limit = next;
-            } else {
-              if(1 < (last - a)) {
-                STACK_PUSH5(ISAd + incr, first, a, next, trlink);
-                first = a, limit = -3;
-              } else {
-                ISAd += incr, last = a, limit = next;
-              }
-            }
-          } else {
-            if(0 <= trlink) { stack[trlink].d = -1; }
-            if(1 < (last - a)) {
-              first = a, limit = -3;
-            } else {
-              STACK_POP5(ISAd, first, last, limit, trlink);
-            }
-          }
-        } else {
-          STACK_POP5(ISAd, first, last, limit, trlink);
-        }
-      }
-      continue;
-    }
-
-    if((last - first) <= TR_INSERTIONSORT_THRESHOLD) {
-      tr_insertionsort(ISAd, first, last);
-      limit = -3;
-      continue;
-    }
-
-    if(limit-- == 0) {
-      tr_heapsort(ISAd, first, last - first);
-      for(a = last - 1; first < a; a = b) {
-        for(x = ISAd[*a], b = a - 1; (first <= b) && (ISAd[*b] == x); --b) { *b = ~*b; }
-      }
-      limit = -3;
-      continue;
-    }
-
-    /* choose pivot */
-    a = tr_pivot(ISAd, first, last);
-    SWAP(*first, *a);
-    v = ISAd[*first];
-
-    /* partition */
-    tr_partition(ISAd, first, first + 1, last, &a, &b, v);
-    if((last - first) != (b - a)) {
-      next = (ISA[*a] != v) ? tr_ilg(b - a) : -1;
-
-      /* update ranks */
-      for(c = first, v = a - SA - 1; c < a; ++c) { ISA[*c] = v; }
-      if(b < last) { for(c = a, v = b - SA - 1; c < b; ++c) { ISA[*c] = v; } }
-
-      /* push */
-      if((1 < (b - a)) && (trbudget_check(budget, b - a))) {
-        if((a - first) <= (last - b)) {
-          if((last - b) <= (b - a)) {
-            if(1 < (a - first)) {
-              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
-              STACK_PUSH5(ISAd, b, last, limit, trlink);
-              last = a;
-            } else if(1 < (last - b)) {
-              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
-              first = b;
-            } else {
-              ISAd += incr, first = a, last = b, limit = next;
-            }
-          } else if((a - first) <= (b - a)) {
-            if(1 < (a - first)) {
-              STACK_PUSH5(ISAd, b, last, limit, trlink);
-              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
-              last = a;
-            } else {
-              STACK_PUSH5(ISAd, b, last, limit, trlink);
-              ISAd += incr, first = a, last = b, limit = next;
-            }
-          } else {
-            STACK_PUSH5(ISAd, b, last, limit, trlink);
-            STACK_PUSH5(ISAd, first, a, limit, trlink);
-            ISAd += incr, first = a, last = b, limit = next;
-          }
-        } else {
-          if((a - first) <= (b - a)) {
-            if(1 < (last - b)) {
-              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
-              STACK_PUSH5(ISAd, first, a, limit, trlink);
-              first = b;
-            } else if(1 < (a - first)) {
-              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
-              last = a;
-            } else {
-              ISAd += incr, first = a, last = b, limit = next;
-            }
-          } else if((last - b) <= (b - a)) {
-            if(1 < (last - b)) {
-              STACK_PUSH5(ISAd, first, a, limit, trlink);
-              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
-              first = b;
-            } else {
-              STACK_PUSH5(ISAd, first, a, limit, trlink);
-              ISAd += incr, first = a, last = b, limit = next;
-            }
-          } else {
-            STACK_PUSH5(ISAd, first, a, limit, trlink);
-            STACK_PUSH5(ISAd, b, last, limit, trlink);
-            ISAd += incr, first = a, last = b, limit = next;
-          }
-        }
-      } else {
-        if((1 < (b - a)) && (0 <= trlink)) { stack[trlink].d = -1; }
-        if((a - first) <= (last - b)) {
-          if(1 < (a - first)) {
-            STACK_PUSH5(ISAd, b, last, limit, trlink);
-            last = a;
-          } else if(1 < (last - b)) {
-            first = b;
-          } else {
-            STACK_POP5(ISAd, first, last, limit, trlink);
-          }
-        } else {
-          if(1 < (last - b)) {
-            STACK_PUSH5(ISAd, first, a, limit, trlink);
-            first = b;
-          } else if(1 < (a - first)) {
-            last = a;
-          } else {
-            STACK_POP5(ISAd, first, last, limit, trlink);
-          }
-        }
-      }
-    } else {
-      if(trbudget_check(budget, last - first)) {
-        limit = tr_ilg(last - first), ISAd += incr;
-      } else {
-        if(0 <= trlink) { stack[trlink].d = -1; }
-        STACK_POP5(ISAd, first, last, limit, trlink);
-      }
-    }
-  }
-#undef STACK_SIZE
-}
-
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Tandem repeat sort */
-static
-void
-trsort(int *ISA, int *SA, int n, int depth) {
-  int *ISAd;
-  int *first, *last;
-  trbudget_t budget;
-  int t, skip, unsorted;
-
-  trbudget_init(&budget, tr_ilg(n) * 2 / 3, n);
-/*  trbudget_init(&budget, tr_ilg(n) * 3 / 4, n); */
-  for(ISAd = ISA + depth; -n < *SA; ISAd += ISAd - ISA) {
-    first = SA;
-    skip = 0;
-    unsorted = 0;
-    do {
-      if((t = *first) < 0) { first -= t; skip += t; }
-      else {
-        if(skip != 0) { *(first + skip) = skip; skip = 0; }
-        last = SA + ISA[t] + 1;
-        if(1 < (last - first)) {
-          budget.count = 0;
-          tr_introsort(ISA, ISAd, SA, first, last, &budget);
-          if(budget.count != 0) { unsorted += budget.count; }
-          else { skip = first - last; }
-        } else if((last - first) == 1) {
-          skip = -1;
-        }
-        first = last;
-      }
-    } while(first < (SA + n));
-    if(skip != 0) { *(first + skip) = skip; }
-    if(unsorted == 0) { break; }
-  }
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-/* Sorts suffixes of type B*. */
-static
-int
-sort_typeBstar(const unsigned char *T, int *SA,
-               int *bucket_A, int *bucket_B,
-               int n, int openMP) {
-  int *PAb, *ISAb, *buf;
-#ifdef LIBBSC_OPENMP
-  int *curbuf;
-  int l;
-#endif
-  int i, j, k, t, m, bufsize;
-  int c0, c1;
-#ifdef LIBBSC_OPENMP
-  int d0, d1;
-#endif
-  (void)openMP;
-
-  /* Initialize bucket arrays. */
-  for(i = 0; i < BUCKET_A_SIZE; ++i) { bucket_A[i] = 0; }
-  for(i = 0; i < BUCKET_B_SIZE; ++i) { bucket_B[i] = 0; }
-
-  /* Count the number of occurrences of the first one or two characters of each
-     type A, B and B* suffix. Moreover, store the beginning position of all
-     type B* suffixes into the array SA. */
-  for(i = n - 1, m = n, c0 = T[n - 1]; 0 <= i;) {
-    /* type A suffix. */
-    do { ++BUCKET_A(c1 = c0); } while((0 <= --i) && ((c0 = T[i]) >= c1));
-    if(0 <= i) {
-      /* type B* suffix. */
-      ++BUCKET_BSTAR(c0, c1);
-      SA[--m] = i;
-      /* type B suffix. */
-      for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) {
-        ++BUCKET_B(c0, c1);
-      }
-    }
-  }
-  m = n - m;
-/*
-note:
-  A type B* suffix is lexicographically smaller than a type B suffix that
-  begins with the same first two characters.
-*/
-
-  /* Calculate the index of start/end point of each bucket. */
-  for(c0 = 0, i = 0, j = 0; c0 < ALPHABET_SIZE; ++c0) {
-    t = i + BUCKET_A(c0);
-    BUCKET_A(c0) = i + j; /* start point */
-    i = t + BUCKET_B(c0, c0);
-    for(c1 = c0 + 1; c1 < ALPHABET_SIZE; ++c1) {
-      j += BUCKET_BSTAR(c0, c1);
-      BUCKET_BSTAR(c0, c1) = j; /* end point */
-      i += BUCKET_B(c0, c1);
-    }
-  }
-
-  if(0 < m) {
-    /* Sort the type B* suffixes by their first two characters. */
-    PAb = SA + n - m; ISAb = SA + m;
-    for(i = m - 2; 0 <= i; --i) {
-      t = PAb[i], c0 = T[t], c1 = T[t + 1];
-      SA[--BUCKET_BSTAR(c0, c1)] = i;
-    }
-    t = PAb[m - 1], c0 = T[t], c1 = T[t + 1];
-    SA[--BUCKET_BSTAR(c0, c1)] = m - 1;
-
-    /* Sort the type B* substrings using sssort. */
-#ifdef LIBBSC_OPENMP
-    if (openMP)
-    {
-        buf = SA + m;
-        c0 = ALPHABET_SIZE - 2, c1 = ALPHABET_SIZE - 1, j = m;
-#pragma omp parallel default(shared) private(bufsize, curbuf, k, l, d0, d1)
-        {
-          bufsize = (n - (2 * m)) / omp_get_num_threads();
-          curbuf = buf + omp_get_thread_num() * bufsize;
-          k = 0;
-          for(;;) {
-            #pragma omp critical(sssort_lock)
-            {
-              if(0 < (l = j)) {
-                d0 = c0, d1 = c1;
-                do {
-                  k = BUCKET_BSTAR(d0, d1);
-                  if(--d1 <= d0) {
-                    d1 = ALPHABET_SIZE - 1;
-                    if(--d0 < 0) { break; }
-                  }
-                } while(((l - k) <= 1) && (0 < (l = k)));
-                c0 = d0, c1 = d1, j = k;
-              }
-            }
-            if(l == 0) { break; }
-            sssort(T, PAb, SA + k, SA + l,
-                   curbuf, bufsize, 2, n, *(SA + k) == (m - 1));
-          }
-        }
-    }
-    else
-    {
-        buf = SA + m, bufsize = n - (2 * m);
-        for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) {
-          for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) {
-            i = BUCKET_BSTAR(c0, c1);
-            if(1 < (j - i)) {
-              sssort(T, PAb, SA + i, SA + j,
-                     buf, bufsize, 2, n, *(SA + i) == (m - 1));
-            }
-          }
-        }
-    }
-#else
-    buf = SA + m, bufsize = n - (2 * m);
-    for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) {
-      for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) {
-        i = BUCKET_BSTAR(c0, c1);
-        if(1 < (j - i)) {
-          sssort(T, PAb, SA + i, SA + j,
-                 buf, bufsize, 2, n, *(SA + i) == (m - 1));
-        }
-      }
-    }
-#endif
-
-    /* Compute ranks of type B* substrings. */
-    for(i = m - 1; 0 <= i; --i) {
-      if(0 <= SA[i]) {
-        j = i;
-        do { ISAb[SA[i]] = i; } while((0 <= --i) && (0 <= SA[i]));
-        SA[i + 1] = i - j;
-        if(i <= 0) { break; }
-      }
-      j = i;
-      do { ISAb[SA[i] = ~SA[i]] = j; } while(SA[--i] < 0);
-      ISAb[SA[i]] = j;
-    }
-
-    /* Construct the inverse suffix array of type B* suffixes using trsort. */
-    trsort(ISAb, SA, m, 1);
-
-    /* Set the sorted order of tyoe B* suffixes. */
-    for(i = n - 1, j = m, c0 = T[n - 1]; 0 <= i;) {
-      for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) >= c1); --i, c1 = c0) { }
-      if(0 <= i) {
-        t = i;
-        for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) { }
-        SA[ISAb[--j]] = ((t == 0) || (1 < (t - i))) ? t : ~t;
-      }
-    }
-
-    /* Calculate the index of start/end point of each bucket. */
-    BUCKET_B(ALPHABET_SIZE - 1, ALPHABET_SIZE - 1) = n; /* end point */
-    for(c0 = ALPHABET_SIZE - 2, k = m - 1; 0 <= c0; --c0) {
-      i = BUCKET_A(c0 + 1) - 1;
-      for(c1 = ALPHABET_SIZE - 1; c0 < c1; --c1) {
-        t = i - BUCKET_B(c0, c1);
-        BUCKET_B(c0, c1) = i; /* end point */
-
-        /* Move all type B* suffixes to the correct position. */
-        for(i = t, j = BUCKET_BSTAR(c0, c1);
-            j <= k;
-            --i, --k) { SA[i] = SA[k]; }
-      }
-      BUCKET_BSTAR(c0, c0 + 1) = i - BUCKET_B(c0, c0) + 1; /* start point */
-      BUCKET_B(c0, c0) = i; /* end point */
-    }
-  }
-
-  return m;
-}
-
-/* Constructs the suffix array by using the sorted order of type B* suffixes. */
-static
-void
-construct_SA(const unsigned char *T, int *SA,
-             int *bucket_A, int *bucket_B,
-             int n, int m) {
-  int *i, *j, *k;
-  int s;
-  int c0, c1, c2;
-
-  if(0 < m) {
-    /* Construct the sorted order of type B suffixes by using
-       the sorted order of type B* suffixes. */
-    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
-      /* Scan the suffix array from right to left. */
-      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),
-          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;
-          i <= j;
-          --j) {
-        if(0 < (s = *j)) {
-          assert(T[s] == c1);
-          assert(((s + 1) < n) && (T[s] <= T[s + 1]));
-          assert(T[s - 1] <= T[s]);
-          *j = ~s;
-          c0 = T[--s];
-          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }
-          if(c0 != c2) {
-            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; }
-            k = SA + BUCKET_B(c2 = c0, c1);
-          }
-          assert(k < j);
-          *k-- = s;
-        } else {
-          assert(((s == 0) && (T[s] == c1)) || (s < 0));
-          *j = ~s;
-        }
-      }
-    }
-  }
-
-  /* Construct the suffix array by using
-     the sorted order of type B suffixes. */
-  k = SA + BUCKET_A(c2 = T[n - 1]);
-  *k++ = (T[n - 2] < c2) ? ~(n - 1) : (n - 1);
-  /* Scan the suffix array from left to right. */
-  for(i = SA, j = SA + n; i < j; ++i) {
-    if(0 < (s = *i)) {
-      assert(T[s - 1] >= T[s]);
-      c0 = T[--s];
-      if((s == 0) || (T[s - 1] < c0)) { s = ~s; }
-      if(c0 != c2) {
-        BUCKET_A(c2) = k - SA;
-        k = SA + BUCKET_A(c2 = c0);
-      }
-      assert(i < k);
-      *k++ = s;
-    } else {
-      assert(s < 0);
-      *i = ~s;
-    }
-  }
-}
-
-/* Constructs the burrows-wheeler transformed string directly
-   by using the sorted order of type B* suffixes. */
-static
-int
-construct_BWT(const unsigned char *T, int *SA,
-              int *bucket_A, int *bucket_B,
-              int n, int m) {
-  int *i, *j, *k, *orig;
-  int s;
-  int c0, c1, c2;
-
-  if(0 < m) {
-    /* Construct the sorted order of type B suffixes by using
-       the sorted order of type B* suffixes. */
-    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
-      /* Scan the suffix array from right to left. */
-      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),
-          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;
-          i <= j;
-          --j) {
-        if(0 < (s = *j)) {
-          assert(T[s] == c1);
-          assert(((s + 1) < n) && (T[s] <= T[s + 1]));
-          assert(T[s - 1] <= T[s]);
-          c0 = T[--s];
-          *j = ~((int)c0);
-          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }
-          if(c0 != c2) {
-            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; }
-            k = SA + BUCKET_B(c2 = c0, c1);
-          }
-          assert(k < j);
-          *k-- = s;
-        } else if(s != 0) {
-          *j = ~s;
-#ifndef NDEBUG
-        } else {
-          assert(T[s] == c1);
-#endif
-        }
-      }
-    }
-  }
-
-  /* Construct the BWTed string by using
-     the sorted order of type B suffixes. */
-  k = SA + BUCKET_A(c2 = T[n - 1]);
-  *k++ = (T[n - 2] < c2) ? ~((int)T[n - 2]) : (n - 1);
-  /* Scan the suffix array from left to right. */
-  for(i = SA, j = SA + n, orig = SA; i < j; ++i) {
-    if(0 < (s = *i)) {
-      assert(T[s - 1] >= T[s]);
-      c0 = T[--s];
-      *i = c0;
-      if((0 < s) && (T[s - 1] < c0)) { s = ~((int)T[s - 1]); }
-      if(c0 != c2) {
-        BUCKET_A(c2) = k - SA;
-        k = SA + BUCKET_A(c2 = c0);
-      }
-      assert(i < k);
-      *k++ = s;
-    } else if(s != 0) {
-      *i = ~s;
-    } else {
-      orig = i;
-    }
-  }
-
-  return orig - SA;
-}
-
-/* Constructs the burrows-wheeler transformed string directly
-   by using the sorted order of type B* suffixes. */
-static
-int
-construct_BWT_indexes(const unsigned char *T, int *SA,
-                      int *bucket_A, int *bucket_B,
-                      int n, int m,
-                      unsigned char * num_indexes, int * indexes) {
-  int *i, *j, *k, *orig;
-  int s;
-  int c0, c1, c2;
-
-  int mod = n / 8;
-  {
-      mod |= mod >> 1;  mod |= mod >> 2;
-      mod |= mod >> 4;  mod |= mod >> 8;
-      mod |= mod >> 16; mod >>= 1;
-
-      *num_indexes = (unsigned char)((n - 1) / (mod + 1));
-  }
-
-  if(0 < m) {
-    /* Construct the sorted order of type B suffixes by using
-       the sorted order of type B* suffixes. */
-    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
-      /* Scan the suffix array from right to left. */
-      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),
-          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;
-          i <= j;
-          --j) {
-        if(0 < (s = *j)) {
-          assert(T[s] == c1);
-          assert(((s + 1) < n) && (T[s] <= T[s + 1]));
-          assert(T[s - 1] <= T[s]);
-
-          if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = j - SA;
-
-          c0 = T[--s];
-          *j = ~((int)c0);
-          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }
-          if(c0 != c2) {
-            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; }
-            k = SA + BUCKET_B(c2 = c0, c1);
-          }
-          assert(k < j);
-          *k-- = s;
-        } else if(s != 0) {
-          *j = ~s;
-#ifndef NDEBUG
-        } else {
-          assert(T[s] == c1);
-#endif
-        }
-      }
-    }
-  }
-
-  /* Construct the BWTed string by using
-     the sorted order of type B suffixes. */
-  k = SA + BUCKET_A(c2 = T[n - 1]);
-  if (T[n - 2] < c2) {
-    if (((n - 1) & mod) == 0) indexes[(n - 1) / (mod + 1) - 1] = k - SA;
-    *k++ = ~((int)T[n - 2]);
-  }
-  else {
-    *k++ = n - 1;
-  }
-
-  /* Scan the suffix array from left to right. */
-  for(i = SA, j = SA + n, orig = SA; i < j; ++i) {
-    if(0 < (s = *i)) {
-      assert(T[s - 1] >= T[s]);
-
-      if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = i - SA;
-
-      c0 = T[--s];
-      *i = c0;
-      if(c0 != c2) {
-        BUCKET_A(c2) = k - SA;
-        k = SA + BUCKET_A(c2 = c0);
-      }
-      assert(i < k);
-      if((0 < s) && (T[s - 1] < c0)) {
-          if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = k - SA;
-          *k++ = ~((int)T[s - 1]);
-      } else
-        *k++ = s;
-    } else if(s != 0) {
-      *i = ~s;
-    } else {
-      orig = i;
-    }
-  }
-
-  return orig - SA;
-}
-
-
-/*---------------------------------------------------------------------------*/
-
-/*- Function -*/
-
-int
-divsufsort(const unsigned char *T, int *SA, int n, int openMP) {
-  int *bucket_A, *bucket_B;
-  int m;
-  int err = 0;
-
-  /* Check arguments. */
-  if((T == NULL) || (SA == NULL) || (n < 0)) { return -1; }
-  else if(n == 0) { return 0; }
-  else if(n == 1) { SA[0] = 0; return 0; }
-  else if(n == 2) { m = (T[0] < T[1]); SA[m ^ 1] = 0, SA[m] = 1; return 0; }
-
-  bucket_A = (int *)malloc(BUCKET_A_SIZE * sizeof(int));
-  bucket_B = (int *)malloc(BUCKET_B_SIZE * sizeof(int));
-
-  /* Suffixsort. */
-  if((bucket_A != NULL) && (bucket_B != NULL)) {
-    m = sort_typeBstar(T, SA, bucket_A, bucket_B, n, openMP);
-    construct_SA(T, SA, bucket_A, bucket_B, n, m);
-  } else {
-    err = -2;
-  }
-
-  free(bucket_B);
-  free(bucket_A);
-
-  return err;
-}
-
-int
-divbwt(const unsigned char *T, unsigned char *U, int *A, int n, unsigned char * num_indexes, int * indexes, int openMP) {
-  int *B;
-  int *bucket_A, *bucket_B;
-  int m, pidx, i;
-
-  /* Check arguments. */
-  if((T == NULL) || (U == NULL) || (n < 0)) { return -1; }
-  else if(n <= 1) { if(n == 1) { U[0] = T[0]; } return n; }
-
-  if((B = A) == NULL) { B = (int *)malloc((size_t)(n + 1) * sizeof(int)); }
-  bucket_A = (int *)malloc(BUCKET_A_SIZE * sizeof(int));
-  bucket_B = (int *)malloc(BUCKET_B_SIZE * sizeof(int));
-
-  /* Burrows-Wheeler Transform. */
-  if((B != NULL) && (bucket_A != NULL) && (bucket_B != NULL)) {
-    m = sort_typeBstar(T, B, bucket_A, bucket_B, n, openMP);
-
-    if (num_indexes == NULL || indexes == NULL) {
-        pidx = construct_BWT(T, B, bucket_A, bucket_B, n, m);
-    } else {
-        pidx = construct_BWT_indexes(T, B, bucket_A, bucket_B, n, m, num_indexes, indexes);
-    }
-
-    /* Copy to output string. */
-    U[0] = T[n - 1];
-    for(i = 0; i < pidx; ++i) { U[i + 1] = (unsigned char)B[i]; }
-    for(i += 1; i < n; ++i) { U[i] = (unsigned char)B[i]; }
-    pidx += 1;
-  } else {
-    pidx = -2;
-  }
-
-  free(bucket_B);
-  free(bucket_A);
-  if(A == NULL) { free(B); }
-
-  return pidx;
-}
+/* 
+ * divsufsort.c for libdivsufsort-lite 
+ * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved. 
+ * 
+ * Permission is hereby granted, free of charge, to any person 
+ * obtaining a copy of this software and associated documentation 
+ * files (the "Software"), to deal in the Software without 
+ * restriction, including without limitation the rights to use, 
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ * copies of the Software, and to permit persons to whom the 
+ * Software is furnished to do so, subject to the following 
+ * conditions: 
+ * 
+ * The above copyright notice and this permission notice shall be 
+ * included in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
+ * OTHER DEALINGS IN THE SOFTWARE. 
+ */ 
+ 
+/*- Compiler specifics -*/ 
+#ifdef __clang__ 
+#pragma clang diagnostic ignored "-Wshorten-64-to-32" 
+#endif 
+ 
+#if defined(_MSC_VER) 
+#  pragma warning(disable : 4244) 
+#  pragma warning(disable : 4127)    /* C4127 : Condition expression is constant */ 
+#endif 
+ 
+ 
+/*- Dependencies -*/ 
+#include <assert.h> 
+#include <stdio.h> 
+#include <stdlib.h> 
+ 
+#include "divsufsort.h" 
+ 
+/*- Constants -*/ 
+#if defined(INLINE) 
+# undef INLINE 
+#endif 
+#if !defined(INLINE) 
+# define INLINE __inline 
+#endif 
+#if defined(ALPHABET_SIZE) && (ALPHABET_SIZE < 1) 
+# undef ALPHABET_SIZE 
+#endif 
+#if !defined(ALPHABET_SIZE) 
+# define ALPHABET_SIZE (256) 
+#endif 
+#define BUCKET_A_SIZE (ALPHABET_SIZE) 
+#define BUCKET_B_SIZE (ALPHABET_SIZE * ALPHABET_SIZE) 
+#if defined(SS_INSERTIONSORT_THRESHOLD) 
+# if SS_INSERTIONSORT_THRESHOLD < 1 
+#  undef SS_INSERTIONSORT_THRESHOLD 
+#  define SS_INSERTIONSORT_THRESHOLD (1) 
+# endif 
+#else 
+# define SS_INSERTIONSORT_THRESHOLD (8) 
+#endif 
+#if defined(SS_BLOCKSIZE) 
+# if SS_BLOCKSIZE < 0 
+#  undef SS_BLOCKSIZE 
+#  define SS_BLOCKSIZE (0) 
+# elif 32768 <= SS_BLOCKSIZE 
+#  undef SS_BLOCKSIZE 
+#  define SS_BLOCKSIZE (32767) 
+# endif 
+#else 
+# define SS_BLOCKSIZE (1024) 
+#endif 
+/* minstacksize = log(SS_BLOCKSIZE) / log(3) * 2 */ 
+#if SS_BLOCKSIZE == 0 
+# define SS_MISORT_STACKSIZE (96) 
+#elif SS_BLOCKSIZE <= 4096 
+# define SS_MISORT_STACKSIZE (16) 
+#else 
+# define SS_MISORT_STACKSIZE (24) 
+#endif 
+#define SS_SMERGE_STACKSIZE (32) 
+#define TR_INSERTIONSORT_THRESHOLD (8) 
+#define TR_STACKSIZE (64) 
+ 
+ 
+/*- Macros -*/ 
+#ifndef SWAP 
+# define SWAP(_a, _b) do { t = (_a); (_a) = (_b); (_b) = t; } while(0) 
+#endif /* SWAP */ 
+#ifndef MIN 
+# define MIN(_a, _b) (((_a) < (_b)) ? (_a) : (_b)) 
+#endif /* MIN */ 
+#ifndef MAX 
+# define MAX(_a, _b) (((_a) > (_b)) ? (_a) : (_b)) 
+#endif /* MAX */ 
+#define STACK_PUSH(_a, _b, _c, _d)\ 
+  do {\ 
+    assert(ssize < STACK_SIZE);\ 
+    stack[ssize].a = (_a), stack[ssize].b = (_b),\ 
+    stack[ssize].c = (_c), stack[ssize++].d = (_d);\ 
+  } while(0) 
+#define STACK_PUSH5(_a, _b, _c, _d, _e)\ 
+  do {\ 
+    assert(ssize < STACK_SIZE);\ 
+    stack[ssize].a = (_a), stack[ssize].b = (_b),\ 
+    stack[ssize].c = (_c), stack[ssize].d = (_d), stack[ssize++].e = (_e);\ 
+  } while(0) 
+#define STACK_POP(_a, _b, _c, _d)\ 
+  do {\ 
+    assert(0 <= ssize);\ 
+    if(ssize == 0) { return; }\ 
+    (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\ 
+    (_c) = stack[ssize].c, (_d) = stack[ssize].d;\ 
+  } while(0) 
+#define STACK_POP5(_a, _b, _c, _d, _e)\ 
+  do {\ 
+    assert(0 <= ssize);\ 
+    if(ssize == 0) { return; }\ 
+    (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\ 
+    (_c) = stack[ssize].c, (_d) = stack[ssize].d, (_e) = stack[ssize].e;\ 
+  } while(0) 
+#define BUCKET_A(_c0) bucket_A[(_c0)] 
+#if ALPHABET_SIZE == 256 
+#define BUCKET_B(_c0, _c1) (bucket_B[((_c1) << 8) | (_c0)]) 
+#define BUCKET_BSTAR(_c0, _c1) (bucket_B[((_c0) << 8) | (_c1)]) 
+#else 
+#define BUCKET_B(_c0, _c1) (bucket_B[(_c1) * ALPHABET_SIZE + (_c0)]) 
+#define BUCKET_BSTAR(_c0, _c1) (bucket_B[(_c0) * ALPHABET_SIZE + (_c1)]) 
+#endif 
+ 
+ 
+/*- Private Functions -*/ 
+ 
+static const int lg_table[256]= { 
+ -1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, 
+  5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, 
+  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, 
+  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, 
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7 
+}; 
+ 
+#if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) 
+ 
+static INLINE 
+int 
+ss_ilg(int n) { 
+#if SS_BLOCKSIZE == 0 
+  return (n & 0xffff0000) ? 
+          ((n & 0xff000000) ? 
+            24 + lg_table[(n >> 24) & 0xff] : 
+            16 + lg_table[(n >> 16) & 0xff]) : 
+          ((n & 0x0000ff00) ? 
+             8 + lg_table[(n >>  8) & 0xff] : 
+             0 + lg_table[(n >>  0) & 0xff]); 
+#elif SS_BLOCKSIZE < 256 
+  return lg_table[n]; 
+#else 
+  return (n & 0xff00) ? 
+          8 + lg_table[(n >> 8) & 0xff] : 
+          0 + lg_table[(n >> 0) & 0xff]; 
+#endif 
+} 
+ 
+#endif /* (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) */ 
+ 
+#if SS_BLOCKSIZE != 0 
+ 
+static const int sqq_table[256] = { 
+  0,  16,  22,  27,  32,  35,  39,  42,  45,  48,  50,  53,  55,  57,  59,  61, 
+ 64,  65,  67,  69,  71,  73,  75,  76,  78,  80,  81,  83,  84,  86,  87,  89, 
+ 90,  91,  93,  94,  96,  97,  98,  99, 101, 102, 103, 104, 106, 107, 108, 109, 
+110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 
+128, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 
+143, 144, 144, 145, 146, 147, 148, 149, 150, 150, 151, 152, 153, 154, 155, 155, 
+156, 157, 158, 159, 160, 160, 161, 162, 163, 163, 164, 165, 166, 167, 167, 168, 
+169, 170, 170, 171, 172, 173, 173, 174, 175, 176, 176, 177, 178, 178, 179, 180, 
+181, 181, 182, 183, 183, 184, 185, 185, 186, 187, 187, 188, 189, 189, 190, 191, 
+192, 192, 193, 193, 194, 195, 195, 196, 197, 197, 198, 199, 199, 200, 201, 201, 
+202, 203, 203, 204, 204, 205, 206, 206, 207, 208, 208, 209, 209, 210, 211, 211, 
+212, 212, 213, 214, 214, 215, 215, 216, 217, 217, 218, 218, 219, 219, 220, 221, 
+221, 222, 222, 223, 224, 224, 225, 225, 226, 226, 227, 227, 228, 229, 229, 230, 
+230, 231, 231, 232, 232, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, 
+239, 240, 240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247, 
+247, 248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255 
+}; 
+ 
+static INLINE 
+int 
+ss_isqrt(int x) { 
+  int y, e; 
+ 
+  if(x >= (SS_BLOCKSIZE * SS_BLOCKSIZE)) { return SS_BLOCKSIZE; } 
+  e = (x & 0xffff0000) ? 
+        ((x & 0xff000000) ? 
+          24 + lg_table[(x >> 24) & 0xff] : 
+          16 + lg_table[(x >> 16) & 0xff]) : 
+        ((x & 0x0000ff00) ? 
+           8 + lg_table[(x >>  8) & 0xff] : 
+           0 + lg_table[(x >>  0) & 0xff]); 
+ 
+  if(e >= 16) { 
+    y = sqq_table[x >> ((e - 6) - (e & 1))] << ((e >> 1) - 7); 
+    if(e >= 24) { y = (y + 1 + x / y) >> 1; } 
+    y = (y + 1 + x / y) >> 1; 
+  } else if(e >= 8) { 
+    y = (sqq_table[x >> ((e - 6) - (e & 1))] >> (7 - (e >> 1))) + 1; 
+  } else { 
+    return sqq_table[x] >> 4; 
+  } 
+ 
+  return (x < (y * y)) ? y - 1 : y; 
+} 
+ 
+#endif /* SS_BLOCKSIZE != 0 */ 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+/* Compares two suffixes. */ 
+static INLINE 
+int 
+ss_compare(const unsigned char *T, 
+           const int *p1, const int *p2, 
+           int depth) { 
+  const unsigned char *U1, *U2, *U1n, *U2n; 
+ 
+  for(U1 = T + depth + *p1, 
+      U2 = T + depth + *p2, 
+      U1n = T + *(p1 + 1) + 2, 
+      U2n = T + *(p2 + 1) + 2; 
+      (U1 < U1n) && (U2 < U2n) && (*U1 == *U2); 
+      ++U1, ++U2) { 
+  } 
+ 
+  return U1 < U1n ? 
+        (U2 < U2n ? *U1 - *U2 : 1) : 
+        (U2 < U2n ? -1 : 0); 
+} 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+#if (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1) 
+ 
+/* Insertionsort for small size groups */ 
+static 
+void 
+ss_insertionsort(const unsigned char *T, const int *PA, 
+                 int *first, int *last, int depth) { 
+  int *i, *j; 
+  int t; 
+  int r; 
+ 
+  for(i = last - 2; first <= i; --i) { 
+    for(t = *i, j = i + 1; 0 < (r = ss_compare(T, PA + t, PA + *j, depth));) { 
+      do { *(j - 1) = *j; } while((++j < last) && (*j < 0)); 
+      if(last <= j) { break; } 
+    } 
+    if(r == 0) { *j = ~*j; } 
+    *(j - 1) = t; 
+  } 
+} 
+ 
+#endif /* (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1) */ 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+#if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) 
+ 
+static INLINE 
+void 
+ss_fixdown(const unsigned char *Td, const int *PA, 
+           int *SA, int i, int size) { 
+  int j, k; 
+  int v; 
+  int c, d, e; 
+ 
+  for(v = SA[i], c = Td[PA[v]]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) { 
+    d = Td[PA[SA[k = j++]]]; 
+    if(d < (e = Td[PA[SA[j]]])) { k = j; d = e; } 
+    if(d <= c) { break; } 
+  } 
+  SA[i] = v; 
+} 
+ 
+/* Simple top-down heapsort. */ 
+static 
+void 
+ss_heapsort(const unsigned char *Td, const int *PA, int *SA, int size) { 
+  int i, m; 
+  int t; 
+ 
+  m = size; 
+  if((size % 2) == 0) { 
+    m--; 
+    if(Td[PA[SA[m / 2]]] < Td[PA[SA[m]]]) { SWAP(SA[m], SA[m / 2]); } 
+  } 
+ 
+  for(i = m / 2 - 1; 0 <= i; --i) { ss_fixdown(Td, PA, SA, i, m); } 
+  if((size % 2) == 0) { SWAP(SA[0], SA[m]); ss_fixdown(Td, PA, SA, 0, m); } 
+  for(i = m - 1; 0 < i; --i) { 
+    t = SA[0], SA[0] = SA[i]; 
+    ss_fixdown(Td, PA, SA, 0, i); 
+    SA[i] = t; 
+  } 
+} 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+/* Returns the median of three elements. */ 
+static INLINE 
+int * 
+ss_median3(const unsigned char *Td, const int *PA, 
+           int *v1, int *v2, int *v3) { 
+  int *t; 
+  if(Td[PA[*v1]] > Td[PA[*v2]]) { SWAP(v1, v2); } 
+  if(Td[PA[*v2]] > Td[PA[*v3]]) { 
+    if(Td[PA[*v1]] > Td[PA[*v3]]) { return v1; } 
+    else { return v3; } 
+  } 
+  return v2; 
+} 
+ 
+/* Returns the median of five elements. */ 
+static INLINE 
+int * 
+ss_median5(const unsigned char *Td, const int *PA, 
+           int *v1, int *v2, int *v3, int *v4, int *v5) { 
+  int *t; 
+  if(Td[PA[*v2]] > Td[PA[*v3]]) { SWAP(v2, v3); } 
+  if(Td[PA[*v4]] > Td[PA[*v5]]) { SWAP(v4, v5); } 
+  if(Td[PA[*v2]] > Td[PA[*v4]]) { SWAP(v2, v4); SWAP(v3, v5); } 
+  if(Td[PA[*v1]] > Td[PA[*v3]]) { SWAP(v1, v3); } 
+  if(Td[PA[*v1]] > Td[PA[*v4]]) { SWAP(v1, v4); SWAP(v3, v5); } 
+  if(Td[PA[*v3]] > Td[PA[*v4]]) { return v4; } 
+  return v3; 
+} 
+ 
+/* Returns the pivot element. */ 
+static INLINE 
+int * 
+ss_pivot(const unsigned char *Td, const int *PA, int *first, int *last) { 
+  int *middle; 
+  int t; 
+ 
+  t = last - first; 
+  middle = first + t / 2; 
+ 
+  if(t <= 512) { 
+    if(t <= 32) { 
+      return ss_median3(Td, PA, first, middle, last - 1); 
+    } else { 
+      t >>= 2; 
+      return ss_median5(Td, PA, first, first + t, middle, last - 1 - t, last - 1); 
+    } 
+  } 
+  t >>= 3; 
+  first  = ss_median3(Td, PA, first, first + t, first + (t << 1)); 
+  middle = ss_median3(Td, PA, middle - t, middle, middle + t); 
+  last   = ss_median3(Td, PA, last - 1 - (t << 1), last - 1 - t, last - 1); 
+  return ss_median3(Td, PA, first, middle, last); 
+} 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+/* Binary partition for substrings. */ 
+static INLINE 
+int * 
+ss_partition(const int *PA, 
+                    int *first, int *last, int depth) { 
+  int *a, *b; 
+  int t; 
+  for(a = first - 1, b = last;;) { 
+    for(; (++a < b) && ((PA[*a] + depth) >= (PA[*a + 1] + 1));) { *a = ~*a; } 
+    for(; (a < --b) && ((PA[*b] + depth) <  (PA[*b + 1] + 1));) { } 
+    if(b <= a) { break; } 
+    t = ~*b; 
+    *b = *a; 
+    *a = t; 
+  } 
+  if(first < a) { *first = ~*first; } 
+  return a; 
+} 
+ 
+/* Multikey introsort for medium size groups. */ 
+static 
+void 
+ss_mintrosort(const unsigned char *T, const int *PA, 
+              int *first, int *last, 
+              int depth) { 
+#define STACK_SIZE SS_MISORT_STACKSIZE 
+  struct { int *a, *b, c; int d; } stack[STACK_SIZE]; 
+  const unsigned char *Td; 
+  int *a, *b, *c, *d, *e, *f; 
+  int s, t; 
+  int ssize; 
+  int limit; 
+  int v, x = 0; 
+ 
+  for(ssize = 0, limit = ss_ilg(last - first);;) { 
+ 
+    if((last - first) <= SS_INSERTIONSORT_THRESHOLD) { 
+#if 1 < SS_INSERTIONSORT_THRESHOLD 
+      if(1 < (last - first)) { ss_insertionsort(T, PA, first, last, depth); } 
+#endif 
+      STACK_POP(first, last, depth, limit); 
+      continue; 
+    } 
+ 
+    Td = T + depth; 
+    if(limit-- == 0) { ss_heapsort(Td, PA, first, last - first); } 
+    if(limit < 0) { 
+      for(a = first + 1, v = Td[PA[*first]]; a < last; ++a) { 
+        if((x = Td[PA[*a]]) != v) { 
+          if(1 < (a - first)) { break; } 
+          v = x; 
+          first = a; 
+        } 
+      } 
+      if(Td[PA[*first] - 1] < v) { 
+        first = ss_partition(PA, first, a, depth); 
+      } 
+      if((a - first) <= (last - a)) { 
+        if(1 < (a - first)) { 
+          STACK_PUSH(a, last, depth, -1); 
+          last = a, depth += 1, limit = ss_ilg(a - first); 
+        } else { 
+          first = a, limit = -1; 
+        } 
+      } else { 
+        if(1 < (last - a)) { 
+          STACK_PUSH(first, a, depth + 1, ss_ilg(a - first)); 
+          first = a, limit = -1; 
+        } else { 
+          last = a, depth += 1, limit = ss_ilg(a - first); 
+        } 
+      } 
+      continue; 
+    } 
+ 
+    /* choose pivot */ 
+    a = ss_pivot(Td, PA, first, last); 
+    v = Td[PA[*a]]; 
+    SWAP(*first, *a); 
+ 
+    /* partition */ 
+    for(b = first; (++b < last) && ((x = Td[PA[*b]]) == v);) { } 
+    if(((a = b) < last) && (x < v)) { 
+      for(; (++b < last) && ((x = Td[PA[*b]]) <= v);) { 
+        if(x == v) { SWAP(*b, *a); ++a; } 
+      } 
+    } 
+    for(c = last; (b < --c) && ((x = Td[PA[*c]]) == v);) { } 
+    if((b < (d = c)) && (x > v)) { 
+      for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) { 
+        if(x == v) { SWAP(*c, *d); --d; } 
+      } 
+    } 
+    for(; b < c;) { 
+      SWAP(*b, *c); 
+      for(; (++b < c) && ((x = Td[PA[*b]]) <= v);) { 
+        if(x == v) { SWAP(*b, *a); ++a; } 
+      } 
+      for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) { 
+        if(x == v) { SWAP(*c, *d); --d; } 
+      } 
+    } 
+ 
+    if(a <= d) { 
+      c = b - 1; 
+ 
+      if((s = a - first) > (t = b - a)) { s = t; } 
+      for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); } 
+      if((s = d - c) > (t = last - d - 1)) { s = t; } 
+      for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); } 
+ 
+      a = first + (b - a), c = last - (d - c); 
+      b = (v <= Td[PA[*a] - 1]) ? a : ss_partition(PA, a, c, depth); 
+ 
+      if((a - first) <= (last - c)) { 
+        if((last - c) <= (c - b)) { 
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b)); 
+          STACK_PUSH(c, last, depth, limit); 
+          last = a; 
+        } else if((a - first) <= (c - b)) { 
+          STACK_PUSH(c, last, depth, limit); 
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b)); 
+          last = a; 
+        } else { 
+          STACK_PUSH(c, last, depth, limit); 
+          STACK_PUSH(first, a, depth, limit); 
+          first = b, last = c, depth += 1, limit = ss_ilg(c - b); 
+        } 
+      } else { 
+        if((a - first) <= (c - b)) { 
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b)); 
+          STACK_PUSH(first, a, depth, limit); 
+          first = c; 
+        } else if((last - c) <= (c - b)) { 
+          STACK_PUSH(first, a, depth, limit); 
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b)); 
+          first = c; 
+        } else { 
+          STACK_PUSH(first, a, depth, limit); 
+          STACK_PUSH(c, last, depth, limit); 
+          first = b, last = c, depth += 1, limit = ss_ilg(c - b); 
+        } 
+      } 
+    } else { 
+      limit += 1; 
+      if(Td[PA[*first] - 1] < v) { 
+        first = ss_partition(PA, first, last, depth); 
+        limit = ss_ilg(last - first); 
+      } 
+      depth += 1; 
+    } 
+  } 
+#undef STACK_SIZE 
+} 
+ 
+#endif /* (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) */ 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+#if SS_BLOCKSIZE != 0 
+ 
+static INLINE 
+void 
+ss_blockswap(int *a, int *b, int n) { 
+  int t; 
+  for(; 0 < n; --n, ++a, ++b) { 
+    t = *a, *a = *b, *b = t; 
+  } 
+} 
+ 
+static INLINE 
+void 
+ss_rotate(int *first, int *middle, int *last) { 
+  int *a, *b, t; 
+  int l, r; 
+  l = middle - first, r = last - middle; 
+  for(; (0 < l) && (0 < r);) { 
+    if(l == r) { ss_blockswap(first, middle, l); break; } 
+    if(l < r) { 
+      a = last - 1, b = middle - 1; 
+      t = *a; 
+      do { 
+        *a-- = *b, *b-- = *a; 
+        if(b < first) { 
+          *a = t; 
+          last = a; 
+          if((r -= l + 1) <= l) { break; } 
+          a -= 1, b = middle - 1; 
+          t = *a; 
+        } 
+      } while(1); 
+    } else { 
+      a = first, b = middle; 
+      t = *a; 
+      do { 
+        *a++ = *b, *b++ = *a; 
+        if(last <= b) { 
+          *a = t; 
+          first = a + 1; 
+          if((l -= r + 1) <= r) { break; } 
+          a += 1, b = middle; 
+          t = *a; 
+        } 
+      } while(1); 
+    } 
+  } 
+} 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+static 
+void 
+ss_inplacemerge(const unsigned char *T, const int *PA, 
+                int *first, int *middle, int *last, 
+                int depth) { 
+  const int *p; 
+  int *a, *b; 
+  int len, half; 
+  int q, r; 
+  int x; 
+ 
+  for(;;) { 
+    if(*(last - 1) < 0) { x = 1; p = PA + ~*(last - 1); } 
+    else                { x = 0; p = PA +  *(last - 1); } 
+    for(a = first, len = middle - first, half = len >> 1, r = -1; 
+        0 < len; 
+        len = half, half >>= 1) { 
+      b = a + half; 
+      q = ss_compare(T, PA + ((0 <= *b) ? *b : ~*b), p, depth); 
+      if(q < 0) { 
+        a = b + 1; 
+        half -= (len & 1) ^ 1; 
+      } else { 
+        r = q; 
+      } 
+    } 
+    if(a < middle) { 
+      if(r == 0) { *a = ~*a; } 
+      ss_rotate(a, middle, last); 
+      last -= middle - a; 
+      middle = a; 
+      if(first == middle) { break; } 
+    } 
+    --last; 
+    if(x != 0) { while(*--last < 0) { } } 
+    if(middle == last) { break; } 
+  } 
+} 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+/* Merge-forward with internal buffer. */ 
+static 
+void 
+ss_mergeforward(const unsigned char *T, const int *PA, 
+                int *first, int *middle, int *last, 
+                int *buf, int depth) { 
+  int *a, *b, *c, *bufend; 
+  int t; 
+  int r; 
+ 
+  bufend = buf + (middle - first) - 1; 
+  ss_blockswap(buf, first, middle - first); 
+ 
+  for(t = *(a = first), b = buf, c = middle;;) { 
+    r = ss_compare(T, PA + *b, PA + *c, depth); 
+    if(r < 0) { 
+      do { 
+        *a++ = *b; 
+        if(bufend <= b) { *bufend = t; return; } 
+        *b++ = *a; 
+      } while(*b < 0); 
+    } else if(r > 0) { 
+      do { 
+        *a++ = *c, *c++ = *a; 
+        if(last <= c) { 
+          while(b < bufend) { *a++ = *b, *b++ = *a; } 
+          *a = *b, *b = t; 
+          return; 
+        } 
+      } while(*c < 0); 
+    } else { 
+      *c = ~*c; 
+      do { 
+        *a++ = *b; 
+        if(bufend <= b) { *bufend = t; return; } 
+        *b++ = *a; 
+      } while(*b < 0); 
+ 
+      do { 
+        *a++ = *c, *c++ = *a; 
+        if(last <= c) { 
+          while(b < bufend) { *a++ = *b, *b++ = *a; } 
+          *a = *b, *b = t; 
+          return; 
+        } 
+      } while(*c < 0); 
+    } 
+  } 
+} 
+ 
+/* Merge-backward with internal buffer. */ 
+static 
+void 
+ss_mergebackward(const unsigned char *T, const int *PA, 
+                 int *first, int *middle, int *last, 
+                 int *buf, int depth) { 
+  const int *p1, *p2; 
+  int *a, *b, *c, *bufend; 
+  int t; 
+  int r; 
+  int x; 
+ 
+  bufend = buf + (last - middle) - 1; 
+  ss_blockswap(buf, middle, last - middle); 
+ 
+  x = 0; 
+  if(*bufend < 0)       { p1 = PA + ~*bufend; x |= 1; } 
+  else                  { p1 = PA +  *bufend; } 
+  if(*(middle - 1) < 0) { p2 = PA + ~*(middle - 1); x |= 2; } 
+  else                  { p2 = PA +  *(middle - 1); } 
+  for(t = *(a = last - 1), b = bufend, c = middle - 1;;) { 
+    r = ss_compare(T, p1, p2, depth); 
+    if(0 < r) { 
+      if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; } 
+      *a-- = *b; 
+      if(b <= buf) { *buf = t; break; } 
+      *b-- = *a; 
+      if(*b < 0) { p1 = PA + ~*b; x |= 1; } 
+      else       { p1 = PA +  *b; } 
+    } else if(r < 0) { 
+      if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; } 
+      *a-- = *c, *c-- = *a; 
+      if(c < first) { 
+        while(buf < b) { *a-- = *b, *b-- = *a; } 
+        *a = *b, *b = t; 
+        break; 
+      } 
+      if(*c < 0) { p2 = PA + ~*c; x |= 2; } 
+      else       { p2 = PA +  *c; } 
+    } else { 
+      if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; } 
+      *a-- = ~*b; 
+      if(b <= buf) { *buf = t; break; } 
+      *b-- = *a; 
+      if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; } 
+      *a-- = *c, *c-- = *a; 
+      if(c < first) { 
+        while(buf < b) { *a-- = *b, *b-- = *a; } 
+        *a = *b, *b = t; 
+        break; 
+      } 
+      if(*b < 0) { p1 = PA + ~*b; x |= 1; } 
+      else       { p1 = PA +  *b; } 
+      if(*c < 0) { p2 = PA + ~*c; x |= 2; } 
+      else       { p2 = PA +  *c; } 
+    } 
+  } 
+} 
+ 
+/* D&C based merge. */ 
+static 
+void 
+ss_swapmerge(const unsigned char *T, const int *PA, 
+             int *first, int *middle, int *last, 
+             int *buf, int bufsize, int depth) { 
+#define STACK_SIZE SS_SMERGE_STACKSIZE 
+#define GETIDX(a) ((0 <= (a)) ? (a) : (~(a))) 
+#define MERGE_CHECK(a, b, c)\ 
+  do {\ 
+    if(((c) & 1) ||\ 
+       (((c) & 2) && (ss_compare(T, PA + GETIDX(*((a) - 1)), PA + *(a), depth) == 0))) {\ 
+      *(a) = ~*(a);\ 
+    }\ 
+    if(((c) & 4) && ((ss_compare(T, PA + GETIDX(*((b) - 1)), PA + *(b), depth) == 0))) {\ 
+      *(b) = ~*(b);\ 
+    }\ 
+  } while(0) 
+  struct { int *a, *b, *c; int d; } stack[STACK_SIZE]; 
+  int *l, *r, *lm, *rm; 
+  int m, len, half; 
+  int ssize; 
+  int check, next; 
+ 
+  for(check = 0, ssize = 0;;) { 
+    if((last - middle) <= bufsize) { 
+      if((first < middle) && (middle < last)) { 
+        ss_mergebackward(T, PA, first, middle, last, buf, depth); 
+      } 
+      MERGE_CHECK(first, last, check); 
+      STACK_POP(first, middle, last, check); 
+      continue; 
+    } 
+ 
+    if((middle - first) <= bufsize) { 
+      if(first < middle) { 
+        ss_mergeforward(T, PA, first, middle, last, buf, depth); 
+      } 
+      MERGE_CHECK(first, last, check); 
+      STACK_POP(first, middle, last, check); 
+      continue; 
+    } 
+ 
+    for(m = 0, len = MIN(middle - first, last - middle), half = len >> 1; 
+        0 < len; 
+        len = half, half >>= 1) { 
+      if(ss_compare(T, PA + GETIDX(*(middle + m + half)), 
+                       PA + GETIDX(*(middle - m - half - 1)), depth) < 0) { 
+        m += half + 1; 
+        half -= (len & 1) ^ 1; 
+      } 
+    } 
+ 
+    if(0 < m) { 
+      lm = middle - m, rm = middle + m; 
+      ss_blockswap(lm, middle, m); 
+      l = r = middle, next = 0; 
+      if(rm < last) { 
+        if(*rm < 0) { 
+          *rm = ~*rm; 
+          if(first < lm) { for(; *--l < 0;) { } next |= 4; } 
+          next |= 1; 
+        } else if(first < lm) { 
+          for(; *r < 0; ++r) { } 
+          next |= 2; 
+        } 
+      } 
+ 
+      if((l - first) <= (last - r)) { 
+        STACK_PUSH(r, rm, last, (next & 3) | (check & 4)); 
+        middle = lm, last = l, check = (check & 3) | (next & 4); 
+      } else { 
+        if((next & 2) && (r == middle)) { next ^= 6; } 
+        STACK_PUSH(first, lm, l, (check & 3) | (next & 4)); 
+        first = r, middle = rm, check = (next & 3) | (check & 4); 
+      } 
+    } else { 
+      if(ss_compare(T, PA + GETIDX(*(middle - 1)), PA + *middle, depth) == 0) { 
+        *middle = ~*middle; 
+      } 
+      MERGE_CHECK(first, last, check); 
+      STACK_POP(first, middle, last, check); 
+    } 
+  } 
+#undef STACK_SIZE 
+} 
+ 
+#endif /* SS_BLOCKSIZE != 0 */ 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+/* Substring sort */ 
+static 
+void 
+sssort(const unsigned char *T, const int *PA, 
+       int *first, int *last, 
+       int *buf, int bufsize, 
+       int depth, int n, int lastsuffix) { 
+  int *a; 
+#if SS_BLOCKSIZE != 0 
+  int *b, *middle, *curbuf; 
+  int j, k, curbufsize, limit; 
+#endif 
+  int i; 
+ 
+  if(lastsuffix != 0) { ++first; } 
+ 
+#if SS_BLOCKSIZE == 0 
+  ss_mintrosort(T, PA, first, last, depth); 
+#else 
+  if((bufsize < SS_BLOCKSIZE) && 
+      (bufsize < (last - first)) && 
+      (bufsize < (limit = ss_isqrt(last - first)))) { 
+    if(SS_BLOCKSIZE < limit) { limit = SS_BLOCKSIZE; } 
+    buf = middle = last - limit, bufsize = limit; 
+  } else { 
+    middle = last, limit = 0; 
+  } 
+  for(a = first, i = 0; SS_BLOCKSIZE < (middle - a); a += SS_BLOCKSIZE, ++i) { 
+#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE 
+    ss_mintrosort(T, PA, a, a + SS_BLOCKSIZE, depth); 
+#elif 1 < SS_BLOCKSIZE 
+    ss_insertionsort(T, PA, a, a + SS_BLOCKSIZE, depth); 
+#endif 
+    curbufsize = last - (a + SS_BLOCKSIZE); 
+    curbuf = a + SS_BLOCKSIZE; 
+    if(curbufsize <= bufsize) { curbufsize = bufsize, curbuf = buf; } 
+    for(b = a, k = SS_BLOCKSIZE, j = i; j & 1; b -= k, k <<= 1, j >>= 1) { 
+      ss_swapmerge(T, PA, b - k, b, b + k, curbuf, curbufsize, depth); 
+    } 
+  } 
+#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE 
+  ss_mintrosort(T, PA, a, middle, depth); 
+#elif 1 < SS_BLOCKSIZE 
+  ss_insertionsort(T, PA, a, middle, depth); 
+#endif 
+  for(k = SS_BLOCKSIZE; i != 0; k <<= 1, i >>= 1) { 
+    if(i & 1) { 
+      ss_swapmerge(T, PA, a - k, a, middle, buf, bufsize, depth); 
+      a -= k; 
+    } 
+  } 
+  if(limit != 0) { 
+#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE 
+    ss_mintrosort(T, PA, middle, last, depth); 
+#elif 1 < SS_BLOCKSIZE 
+    ss_insertionsort(T, PA, middle, last, depth); 
+#endif 
+    ss_inplacemerge(T, PA, first, middle, last, depth); 
+  } 
+#endif 
+ 
+  if(lastsuffix != 0) { 
+    /* Insert last type B* suffix. */ 
+    int PAi[2]; PAi[0] = PA[*(first - 1)], PAi[1] = n - 2; 
+    for(a = first, i = *(first - 1); 
+        (a < last) && ((*a < 0) || (0 < ss_compare(T, &(PAi[0]), PA + *a, depth))); 
+        ++a) { 
+      *(a - 1) = *a; 
+    } 
+    *(a - 1) = i; 
+  } 
+} 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+static INLINE 
+int 
+tr_ilg(int n) { 
+  return (n & 0xffff0000) ? 
+          ((n & 0xff000000) ? 
+            24 + lg_table[(n >> 24) & 0xff] : 
+            16 + lg_table[(n >> 16) & 0xff]) : 
+          ((n & 0x0000ff00) ? 
+             8 + lg_table[(n >>  8) & 0xff] : 
+             0 + lg_table[(n >>  0) & 0xff]); 
+} 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+/* Simple insertionsort for small size groups. */ 
+static 
+void 
+tr_insertionsort(const int *ISAd, int *first, int *last) { 
+  int *a, *b; 
+  int t, r; 
+ 
+  for(a = first + 1; a < last; ++a) { 
+    for(t = *a, b = a - 1; 0 > (r = ISAd[t] - ISAd[*b]);) { 
+      do { *(b + 1) = *b; } while((first <= --b) && (*b < 0)); 
+      if(b < first) { break; } 
+    } 
+    if(r == 0) { *b = ~*b; } 
+    *(b + 1) = t; 
+  } 
+} 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+static INLINE 
+void 
+tr_fixdown(const int *ISAd, int *SA, int i, int size) { 
+  int j, k; 
+  int v; 
+  int c, d, e; 
+ 
+  for(v = SA[i], c = ISAd[v]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) { 
+    d = ISAd[SA[k = j++]]; 
+    if(d < (e = ISAd[SA[j]])) { k = j; d = e; } 
+    if(d <= c) { break; } 
+  } 
+  SA[i] = v; 
+} 
+ 
+/* Simple top-down heapsort. */ 
+static 
+void 
+tr_heapsort(const int *ISAd, int *SA, int size) { 
+  int i, m; 
+  int t; 
+ 
+  m = size; 
+  if((size % 2) == 0) { 
+    m--; 
+    if(ISAd[SA[m / 2]] < ISAd[SA[m]]) { SWAP(SA[m], SA[m / 2]); } 
+  } 
+ 
+  for(i = m / 2 - 1; 0 <= i; --i) { tr_fixdown(ISAd, SA, i, m); } 
+  if((size % 2) == 0) { SWAP(SA[0], SA[m]); tr_fixdown(ISAd, SA, 0, m); } 
+  for(i = m - 1; 0 < i; --i) { 
+    t = SA[0], SA[0] = SA[i]; 
+    tr_fixdown(ISAd, SA, 0, i); 
+    SA[i] = t; 
+  } 
+} 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+/* Returns the median of three elements. */ 
+static INLINE 
+int * 
+tr_median3(const int *ISAd, int *v1, int *v2, int *v3) { 
+  int *t; 
+  if(ISAd[*v1] > ISAd[*v2]) { SWAP(v1, v2); } 
+  if(ISAd[*v2] > ISAd[*v3]) { 
+    if(ISAd[*v1] > ISAd[*v3]) { return v1; } 
+    else { return v3; } 
+  } 
+  return v2; 
+} 
+ 
+/* Returns the median of five elements. */ 
+static INLINE 
+int * 
+tr_median5(const int *ISAd, 
+           int *v1, int *v2, int *v3, int *v4, int *v5) { 
+  int *t; 
+  if(ISAd[*v2] > ISAd[*v3]) { SWAP(v2, v3); } 
+  if(ISAd[*v4] > ISAd[*v5]) { SWAP(v4, v5); } 
+  if(ISAd[*v2] > ISAd[*v4]) { SWAP(v2, v4); SWAP(v3, v5); } 
+  if(ISAd[*v1] > ISAd[*v3]) { SWAP(v1, v3); } 
+  if(ISAd[*v1] > ISAd[*v4]) { SWAP(v1, v4); SWAP(v3, v5); } 
+  if(ISAd[*v3] > ISAd[*v4]) { return v4; } 
+  return v3; 
+} 
+ 
+/* Returns the pivot element. */ 
+static INLINE 
+int * 
+tr_pivot(const int *ISAd, int *first, int *last) { 
+  int *middle; 
+  int t; 
+ 
+  t = last - first; 
+  middle = first + t / 2; 
+ 
+  if(t <= 512) { 
+    if(t <= 32) { 
+      return tr_median3(ISAd, first, middle, last - 1); 
+    } else { 
+      t >>= 2; 
+      return tr_median5(ISAd, first, first + t, middle, last - 1 - t, last - 1); 
+    } 
+  } 
+  t >>= 3; 
+  first  = tr_median3(ISAd, first, first + t, first + (t << 1)); 
+  middle = tr_median3(ISAd, middle - t, middle, middle + t); 
+  last   = tr_median3(ISAd, last - 1 - (t << 1), last - 1 - t, last - 1); 
+  return tr_median3(ISAd, first, middle, last); 
+} 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+typedef struct _trbudget_t trbudget_t; 
+struct _trbudget_t { 
+  int chance; 
+  int remain; 
+  int incval; 
+  int count; 
+}; 
+ 
+static INLINE 
+void 
+trbudget_init(trbudget_t *budget, int chance, int incval) { 
+  budget->chance = chance; 
+  budget->remain = budget->incval = incval; 
+} 
+ 
+static INLINE 
+int 
+trbudget_check(trbudget_t *budget, int size) { 
+  if(size <= budget->remain) { budget->remain -= size; return 1; } 
+  if(budget->chance == 0) { budget->count += size; return 0; } 
+  budget->remain += budget->incval - size; 
+  budget->chance -= 1; 
+  return 1; 
+} 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+static INLINE 
+void 
+tr_partition(const int *ISAd, 
+             int *first, int *middle, int *last, 
+             int **pa, int **pb, int v) { 
+  int *a, *b, *c, *d, *e, *f; 
+  int t, s; 
+  int x = 0; 
+ 
+  for(b = middle - 1; (++b < last) && ((x = ISAd[*b]) == v);) { } 
+  if(((a = b) < last) && (x < v)) { 
+    for(; (++b < last) && ((x = ISAd[*b]) <= v);) { 
+      if(x == v) { SWAP(*b, *a); ++a; } 
+    } 
+  } 
+  for(c = last; (b < --c) && ((x = ISAd[*c]) == v);) { } 
+  if((b < (d = c)) && (x > v)) { 
+    for(; (b < --c) && ((x = ISAd[*c]) >= v);) { 
+      if(x == v) { SWAP(*c, *d); --d; } 
+    } 
+  } 
+  for(; b < c;) { 
+    SWAP(*b, *c); 
+    for(; (++b < c) && ((x = ISAd[*b]) <= v);) { 
+      if(x == v) { SWAP(*b, *a); ++a; } 
+    } 
+    for(; (b < --c) && ((x = ISAd[*c]) >= v);) { 
+      if(x == v) { SWAP(*c, *d); --d; } 
+    } 
+  } 
+ 
+  if(a <= d) { 
+    c = b - 1; 
+    if((s = a - first) > (t = b - a)) { s = t; } 
+    for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); } 
+    if((s = d - c) > (t = last - d - 1)) { s = t; } 
+    for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); } 
+    first += (b - a), last -= (d - c); 
+  } 
+  *pa = first, *pb = last; 
+} 
+ 
+static 
+void 
+tr_copy(int *ISA, const int *SA, 
+        int *first, int *a, int *b, int *last, 
+        int depth) { 
+  /* sort suffixes of middle partition 
+     by using sorted order of suffixes of left and right partition. */ 
+  int *c, *d, *e; 
+  int s, v; 
+ 
+  v = b - SA - 1; 
+  for(c = first, d = a - 1; c <= d; ++c) { 
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) { 
+      *++d = s; 
+      ISA[s] = d - SA; 
+    } 
+  } 
+  for(c = last - 1, e = d + 1, d = b; e < d; --c) { 
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) { 
+      *--d = s; 
+      ISA[s] = d - SA; 
+    } 
+  } 
+} 
+ 
+static 
+void 
+tr_partialcopy(int *ISA, const int *SA, 
+               int *first, int *a, int *b, int *last, 
+               int depth) { 
+  int *c, *d, *e; 
+  int s, v; 
+  int rank, lastrank, newrank = -1; 
+ 
+  v = b - SA - 1; 
+  lastrank = -1; 
+  for(c = first, d = a - 1; c <= d; ++c) { 
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) { 
+      *++d = s; 
+      rank = ISA[s + depth]; 
+      if(lastrank != rank) { lastrank = rank; newrank = d - SA; } 
+      ISA[s] = newrank; 
+    } 
+  } 
+ 
+  lastrank = -1; 
+  for(e = d; first <= e; --e) { 
+    rank = ISA[*e]; 
+    if(lastrank != rank) { lastrank = rank; newrank = e - SA; } 
+    if(newrank != rank) { ISA[*e] = newrank; } 
+  } 
+ 
+  lastrank = -1; 
+  for(c = last - 1, e = d + 1, d = b; e < d; --c) { 
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) { 
+      *--d = s; 
+      rank = ISA[s + depth]; 
+      if(lastrank != rank) { lastrank = rank; newrank = d - SA; } 
+      ISA[s] = newrank; 
+    } 
+  } 
+} 
+ 
+static 
+void 
+tr_introsort(int *ISA, const int *ISAd, 
+             int *SA, int *first, int *last, 
+             trbudget_t *budget) { 
+#define STACK_SIZE TR_STACKSIZE 
+  struct { const int *a; int *b, *c; int d, e; }stack[STACK_SIZE]; 
+  int *a, *b, *c; 
+  int t; 
+  int v, x = 0; 
+  int incr = ISAd - ISA; 
+  int limit, next; 
+  int ssize, trlink = -1; 
+ 
+  for(ssize = 0, limit = tr_ilg(last - first);;) { 
+ 
+    if(limit < 0) { 
+      if(limit == -1) { 
+        /* tandem repeat partition */ 
+        tr_partition(ISAd - incr, first, first, last, &a, &b, last - SA - 1); 
+ 
+        /* update ranks */ 
+        if(a < last) { 
+          for(c = first, v = a - SA - 1; c < a; ++c) { ISA[*c] = v; } 
+        } 
+        if(b < last) { 
+          for(c = a, v = b - SA - 1; c < b; ++c) { ISA[*c] = v; } 
+        } 
+ 
+        /* push */ 
+        if(1 < (b - a)) { 
+          STACK_PUSH5(NULL, a, b, 0, 0); 
+          STACK_PUSH5(ISAd - incr, first, last, -2, trlink); 
+          trlink = ssize - 2; 
+        } 
+        if((a - first) <= (last - b)) { 
+          if(1 < (a - first)) { 
+            STACK_PUSH5(ISAd, b, last, tr_ilg(last - b), trlink); 
+            last = a, limit = tr_ilg(a - first); 
+          } else if(1 < (last - b)) { 
+            first = b, limit = tr_ilg(last - b); 
+          } else { 
+            STACK_POP5(ISAd, first, last, limit, trlink); 
+          } 
+        } else { 
+          if(1 < (last - b)) { 
+            STACK_PUSH5(ISAd, first, a, tr_ilg(a - first), trlink); 
+            first = b, limit = tr_ilg(last - b); 
+          } else if(1 < (a - first)) { 
+            last = a, limit = tr_ilg(a - first); 
+          } else { 
+            STACK_POP5(ISAd, first, last, limit, trlink); 
+          } 
+        } 
+      } else if(limit == -2) { 
+        /* tandem repeat copy */ 
+        a = stack[--ssize].b, b = stack[ssize].c; 
+        if(stack[ssize].d == 0) { 
+          tr_copy(ISA, SA, first, a, b, last, ISAd - ISA); 
+        } else { 
+          if(0 <= trlink) { stack[trlink].d = -1; } 
+          tr_partialcopy(ISA, SA, first, a, b, last, ISAd - ISA); 
+        } 
+        STACK_POP5(ISAd, first, last, limit, trlink); 
+      } else { 
+        /* sorted partition */ 
+        if(0 <= *first) { 
+          a = first; 
+          do { ISA[*a] = a - SA; } while((++a < last) && (0 <= *a)); 
+          first = a; 
+        } 
+        if(first < last) { 
+          a = first; do { *a = ~*a; } while(*++a < 0); 
+          next = (ISA[*a] != ISAd[*a]) ? tr_ilg(a - first + 1) : -1; 
+          if(++a < last) { for(b = first, v = a - SA - 1; b < a; ++b) { ISA[*b] = v; } } 
+ 
+          /* push */ 
+          if(trbudget_check(budget, a - first)) { 
+            if((a - first) <= (last - a)) { 
+              STACK_PUSH5(ISAd, a, last, -3, trlink); 
+              ISAd += incr, last = a, limit = next; 
+            } else { 
+              if(1 < (last - a)) { 
+                STACK_PUSH5(ISAd + incr, first, a, next, trlink); 
+                first = a, limit = -3; 
+              } else { 
+                ISAd += incr, last = a, limit = next; 
+              } 
+            } 
+          } else { 
+            if(0 <= trlink) { stack[trlink].d = -1; } 
+            if(1 < (last - a)) { 
+              first = a, limit = -3; 
+            } else { 
+              STACK_POP5(ISAd, first, last, limit, trlink); 
+            } 
+          } 
+        } else { 
+          STACK_POP5(ISAd, first, last, limit, trlink); 
+        } 
+      } 
+      continue; 
+    } 
+ 
+    if((last - first) <= TR_INSERTIONSORT_THRESHOLD) { 
+      tr_insertionsort(ISAd, first, last); 
+      limit = -3; 
+      continue; 
+    } 
+ 
+    if(limit-- == 0) { 
+      tr_heapsort(ISAd, first, last - first); 
+      for(a = last - 1; first < a; a = b) { 
+        for(x = ISAd[*a], b = a - 1; (first <= b) && (ISAd[*b] == x); --b) { *b = ~*b; } 
+      } 
+      limit = -3; 
+      continue; 
+    } 
+ 
+    /* choose pivot */ 
+    a = tr_pivot(ISAd, first, last); 
+    SWAP(*first, *a); 
+    v = ISAd[*first]; 
+ 
+    /* partition */ 
+    tr_partition(ISAd, first, first + 1, last, &a, &b, v); 
+    if((last - first) != (b - a)) { 
+      next = (ISA[*a] != v) ? tr_ilg(b - a) : -1; 
+ 
+      /* update ranks */ 
+      for(c = first, v = a - SA - 1; c < a; ++c) { ISA[*c] = v; } 
+      if(b < last) { for(c = a, v = b - SA - 1; c < b; ++c) { ISA[*c] = v; } } 
+ 
+      /* push */ 
+      if((1 < (b - a)) && (trbudget_check(budget, b - a))) { 
+        if((a - first) <= (last - b)) { 
+          if((last - b) <= (b - a)) { 
+            if(1 < (a - first)) { 
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink); 
+              STACK_PUSH5(ISAd, b, last, limit, trlink); 
+              last = a; 
+            } else if(1 < (last - b)) { 
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink); 
+              first = b; 
+            } else { 
+              ISAd += incr, first = a, last = b, limit = next; 
+            } 
+          } else if((a - first) <= (b - a)) { 
+            if(1 < (a - first)) { 
+              STACK_PUSH5(ISAd, b, last, limit, trlink); 
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink); 
+              last = a; 
+            } else { 
+              STACK_PUSH5(ISAd, b, last, limit, trlink); 
+              ISAd += incr, first = a, last = b, limit = next; 
+            } 
+          } else { 
+            STACK_PUSH5(ISAd, b, last, limit, trlink); 
+            STACK_PUSH5(ISAd, first, a, limit, trlink); 
+            ISAd += incr, first = a, last = b, limit = next; 
+          } 
+        } else { 
+          if((a - first) <= (b - a)) { 
+            if(1 < (last - b)) { 
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink); 
+              STACK_PUSH5(ISAd, first, a, limit, trlink); 
+              first = b; 
+            } else if(1 < (a - first)) { 
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink); 
+              last = a; 
+            } else { 
+              ISAd += incr, first = a, last = b, limit = next; 
+            } 
+          } else if((last - b) <= (b - a)) { 
+            if(1 < (last - b)) { 
+              STACK_PUSH5(ISAd, first, a, limit, trlink); 
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink); 
+              first = b; 
+            } else { 
+              STACK_PUSH5(ISAd, first, a, limit, trlink); 
+              ISAd += incr, first = a, last = b, limit = next; 
+            } 
+          } else { 
+            STACK_PUSH5(ISAd, first, a, limit, trlink); 
+            STACK_PUSH5(ISAd, b, last, limit, trlink); 
+            ISAd += incr, first = a, last = b, limit = next; 
+          } 
+        } 
+      } else { 
+        if((1 < (b - a)) && (0 <= trlink)) { stack[trlink].d = -1; } 
+        if((a - first) <= (last - b)) { 
+          if(1 < (a - first)) { 
+            STACK_PUSH5(ISAd, b, last, limit, trlink); 
+            last = a; 
+          } else if(1 < (last - b)) { 
+            first = b; 
+          } else { 
+            STACK_POP5(ISAd, first, last, limit, trlink); 
+          } 
+        } else { 
+          if(1 < (last - b)) { 
+            STACK_PUSH5(ISAd, first, a, limit, trlink); 
+            first = b; 
+          } else if(1 < (a - first)) { 
+            last = a; 
+          } else { 
+            STACK_POP5(ISAd, first, last, limit, trlink); 
+          } 
+        } 
+      } 
+    } else { 
+      if(trbudget_check(budget, last - first)) { 
+        limit = tr_ilg(last - first), ISAd += incr; 
+      } else { 
+        if(0 <= trlink) { stack[trlink].d = -1; } 
+        STACK_POP5(ISAd, first, last, limit, trlink); 
+      } 
+    } 
+  } 
+#undef STACK_SIZE 
+} 
+ 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+/* Tandem repeat sort */ 
+static 
+void 
+trsort(int *ISA, int *SA, int n, int depth) { 
+  int *ISAd; 
+  int *first, *last; 
+  trbudget_t budget; 
+  int t, skip, unsorted; 
+ 
+  trbudget_init(&budget, tr_ilg(n) * 2 / 3, n); 
+/*  trbudget_init(&budget, tr_ilg(n) * 3 / 4, n); */ 
+  for(ISAd = ISA + depth; -n < *SA; ISAd += ISAd - ISA) { 
+    first = SA; 
+    skip = 0; 
+    unsorted = 0; 
+    do { 
+      if((t = *first) < 0) { first -= t; skip += t; } 
+      else { 
+        if(skip != 0) { *(first + skip) = skip; skip = 0; } 
+        last = SA + ISA[t] + 1; 
+        if(1 < (last - first)) { 
+          budget.count = 0; 
+          tr_introsort(ISA, ISAd, SA, first, last, &budget); 
+          if(budget.count != 0) { unsorted += budget.count; } 
+          else { skip = first - last; } 
+        } else if((last - first) == 1) { 
+          skip = -1; 
+        } 
+        first = last; 
+      } 
+    } while(first < (SA + n)); 
+    if(skip != 0) { *(first + skip) = skip; } 
+    if(unsorted == 0) { break; } 
+  } 
+} 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+/* Sorts suffixes of type B*. */ 
+static 
+int 
+sort_typeBstar(const unsigned char *T, int *SA, 
+               int *bucket_A, int *bucket_B, 
+               int n, int openMP) { 
+  int *PAb, *ISAb, *buf; 
+#ifdef LIBBSC_OPENMP 
+  int *curbuf; 
+  int l; 
+#endif 
+  int i, j, k, t, m, bufsize; 
+  int c0, c1; 
+#ifdef LIBBSC_OPENMP 
+  int d0, d1; 
+#endif 
+  (void)openMP; 
+ 
+  /* Initialize bucket arrays. */ 
+  for(i = 0; i < BUCKET_A_SIZE; ++i) { bucket_A[i] = 0; } 
+  for(i = 0; i < BUCKET_B_SIZE; ++i) { bucket_B[i] = 0; } 
+ 
+  /* Count the number of occurrences of the first one or two characters of each 
+     type A, B and B* suffix. Moreover, store the beginning position of all 
+     type B* suffixes into the array SA. */ 
+  for(i = n - 1, m = n, c0 = T[n - 1]; 0 <= i;) { 
+    /* type A suffix. */ 
+    do { ++BUCKET_A(c1 = c0); } while((0 <= --i) && ((c0 = T[i]) >= c1)); 
+    if(0 <= i) { 
+      /* type B* suffix. */ 
+      ++BUCKET_BSTAR(c0, c1); 
+      SA[--m] = i; 
+      /* type B suffix. */ 
+      for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) { 
+        ++BUCKET_B(c0, c1); 
+      } 
+    } 
+  } 
+  m = n - m; 
+/* 
+note: 
+  A type B* suffix is lexicographically smaller than a type B suffix that 
+  begins with the same first two characters. 
+*/ 
+ 
+  /* Calculate the index of start/end point of each bucket. */ 
+  for(c0 = 0, i = 0, j = 0; c0 < ALPHABET_SIZE; ++c0) { 
+    t = i + BUCKET_A(c0); 
+    BUCKET_A(c0) = i + j; /* start point */ 
+    i = t + BUCKET_B(c0, c0); 
+    for(c1 = c0 + 1; c1 < ALPHABET_SIZE; ++c1) { 
+      j += BUCKET_BSTAR(c0, c1); 
+      BUCKET_BSTAR(c0, c1) = j; /* end point */ 
+      i += BUCKET_B(c0, c1); 
+    } 
+  } 
+ 
+  if(0 < m) { 
+    /* Sort the type B* suffixes by their first two characters. */ 
+    PAb = SA + n - m; ISAb = SA + m; 
+    for(i = m - 2; 0 <= i; --i) { 
+      t = PAb[i], c0 = T[t], c1 = T[t + 1]; 
+      SA[--BUCKET_BSTAR(c0, c1)] = i; 
+    } 
+    t = PAb[m - 1], c0 = T[t], c1 = T[t + 1]; 
+    SA[--BUCKET_BSTAR(c0, c1)] = m - 1; 
+ 
+    /* Sort the type B* substrings using sssort. */ 
+#ifdef LIBBSC_OPENMP 
+    if (openMP) 
+    { 
+        buf = SA + m; 
+        c0 = ALPHABET_SIZE - 2, c1 = ALPHABET_SIZE - 1, j = m; 
+#pragma omp parallel default(shared) private(bufsize, curbuf, k, l, d0, d1) 
+        { 
+          bufsize = (n - (2 * m)) / omp_get_num_threads(); 
+          curbuf = buf + omp_get_thread_num() * bufsize; 
+          k = 0; 
+          for(;;) { 
+            #pragma omp critical(sssort_lock) 
+            { 
+              if(0 < (l = j)) { 
+                d0 = c0, d1 = c1; 
+                do { 
+                  k = BUCKET_BSTAR(d0, d1); 
+                  if(--d1 <= d0) { 
+                    d1 = ALPHABET_SIZE - 1; 
+                    if(--d0 < 0) { break; } 
+                  } 
+                } while(((l - k) <= 1) && (0 < (l = k))); 
+                c0 = d0, c1 = d1, j = k; 
+              } 
+            } 
+            if(l == 0) { break; } 
+            sssort(T, PAb, SA + k, SA + l, 
+                   curbuf, bufsize, 2, n, *(SA + k) == (m - 1)); 
+          } 
+        } 
+    } 
+    else 
+    { 
+        buf = SA + m, bufsize = n - (2 * m); 
+        for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) { 
+          for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) { 
+            i = BUCKET_BSTAR(c0, c1); 
+            if(1 < (j - i)) { 
+              sssort(T, PAb, SA + i, SA + j, 
+                     buf, bufsize, 2, n, *(SA + i) == (m - 1)); 
+            } 
+          } 
+        } 
+    } 
+#else 
+    buf = SA + m, bufsize = n - (2 * m); 
+    for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) { 
+      for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) { 
+        i = BUCKET_BSTAR(c0, c1); 
+        if(1 < (j - i)) { 
+          sssort(T, PAb, SA + i, SA + j, 
+                 buf, bufsize, 2, n, *(SA + i) == (m - 1)); 
+        } 
+      } 
+    } 
+#endif 
+ 
+    /* Compute ranks of type B* substrings. */ 
+    for(i = m - 1; 0 <= i; --i) { 
+      if(0 <= SA[i]) { 
+        j = i; 
+        do { ISAb[SA[i]] = i; } while((0 <= --i) && (0 <= SA[i])); 
+        SA[i + 1] = i - j; 
+        if(i <= 0) { break; } 
+      } 
+      j = i; 
+      do { ISAb[SA[i] = ~SA[i]] = j; } while(SA[--i] < 0); 
+      ISAb[SA[i]] = j; 
+    } 
+ 
+    /* Construct the inverse suffix array of type B* suffixes using trsort. */ 
+    trsort(ISAb, SA, m, 1); 
+ 
+    /* Set the sorted order of tyoe B* suffixes. */ 
+    for(i = n - 1, j = m, c0 = T[n - 1]; 0 <= i;) { 
+      for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) >= c1); --i, c1 = c0) { } 
+      if(0 <= i) { 
+        t = i; 
+        for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) { } 
+        SA[ISAb[--j]] = ((t == 0) || (1 < (t - i))) ? t : ~t; 
+      } 
+    } 
+ 
+    /* Calculate the index of start/end point of each bucket. */ 
+    BUCKET_B(ALPHABET_SIZE - 1, ALPHABET_SIZE - 1) = n; /* end point */ 
+    for(c0 = ALPHABET_SIZE - 2, k = m - 1; 0 <= c0; --c0) { 
+      i = BUCKET_A(c0 + 1) - 1; 
+      for(c1 = ALPHABET_SIZE - 1; c0 < c1; --c1) { 
+        t = i - BUCKET_B(c0, c1); 
+        BUCKET_B(c0, c1) = i; /* end point */ 
+ 
+        /* Move all type B* suffixes to the correct position. */ 
+        for(i = t, j = BUCKET_BSTAR(c0, c1); 
+            j <= k; 
+            --i, --k) { SA[i] = SA[k]; } 
+      } 
+      BUCKET_BSTAR(c0, c0 + 1) = i - BUCKET_B(c0, c0) + 1; /* start point */ 
+      BUCKET_B(c0, c0) = i; /* end point */ 
+    } 
+  } 
+ 
+  return m; 
+} 
+ 
+/* Constructs the suffix array by using the sorted order of type B* suffixes. */ 
+static 
+void 
+construct_SA(const unsigned char *T, int *SA, 
+             int *bucket_A, int *bucket_B, 
+             int n, int m) { 
+  int *i, *j, *k; 
+  int s; 
+  int c0, c1, c2; 
+ 
+  if(0 < m) { 
+    /* Construct the sorted order of type B suffixes by using 
+       the sorted order of type B* suffixes. */ 
+    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) { 
+      /* Scan the suffix array from right to left. */ 
+      for(i = SA + BUCKET_BSTAR(c1, c1 + 1), 
+          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1; 
+          i <= j; 
+          --j) { 
+        if(0 < (s = *j)) { 
+          assert(T[s] == c1); 
+          assert(((s + 1) < n) && (T[s] <= T[s + 1])); 
+          assert(T[s - 1] <= T[s]); 
+          *j = ~s; 
+          c0 = T[--s]; 
+          if((0 < s) && (T[s - 1] > c0)) { s = ~s; } 
+          if(c0 != c2) { 
+            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; } 
+            k = SA + BUCKET_B(c2 = c0, c1); 
+          } 
+          assert(k < j); 
+          *k-- = s; 
+        } else { 
+          assert(((s == 0) && (T[s] == c1)) || (s < 0)); 
+          *j = ~s; 
+        } 
+      } 
+    } 
+  } 
+ 
+  /* Construct the suffix array by using 
+     the sorted order of type B suffixes. */ 
+  k = SA + BUCKET_A(c2 = T[n - 1]); 
+  *k++ = (T[n - 2] < c2) ? ~(n - 1) : (n - 1); 
+  /* Scan the suffix array from left to right. */ 
+  for(i = SA, j = SA + n; i < j; ++i) { 
+    if(0 < (s = *i)) { 
+      assert(T[s - 1] >= T[s]); 
+      c0 = T[--s]; 
+      if((s == 0) || (T[s - 1] < c0)) { s = ~s; } 
+      if(c0 != c2) { 
+        BUCKET_A(c2) = k - SA; 
+        k = SA + BUCKET_A(c2 = c0); 
+      } 
+      assert(i < k); 
+      *k++ = s; 
+    } else { 
+      assert(s < 0); 
+      *i = ~s; 
+    } 
+  } 
+} 
+ 
+/* Constructs the burrows-wheeler transformed string directly 
+   by using the sorted order of type B* suffixes. */ 
+static 
+int 
+construct_BWT(const unsigned char *T, int *SA, 
+              int *bucket_A, int *bucket_B, 
+              int n, int m) { 
+  int *i, *j, *k, *orig; 
+  int s; 
+  int c0, c1, c2; 
+ 
+  if(0 < m) { 
+    /* Construct the sorted order of type B suffixes by using 
+       the sorted order of type B* suffixes. */ 
+    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) { 
+      /* Scan the suffix array from right to left. */ 
+      for(i = SA + BUCKET_BSTAR(c1, c1 + 1), 
+          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1; 
+          i <= j; 
+          --j) { 
+        if(0 < (s = *j)) { 
+          assert(T[s] == c1); 
+          assert(((s + 1) < n) && (T[s] <= T[s + 1])); 
+          assert(T[s - 1] <= T[s]); 
+          c0 = T[--s]; 
+          *j = ~((int)c0); 
+          if((0 < s) && (T[s - 1] > c0)) { s = ~s; } 
+          if(c0 != c2) { 
+            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; } 
+            k = SA + BUCKET_B(c2 = c0, c1); 
+          } 
+          assert(k < j); 
+          *k-- = s; 
+        } else if(s != 0) { 
+          *j = ~s; 
+#ifndef NDEBUG 
+        } else { 
+          assert(T[s] == c1); 
+#endif 
+        } 
+      } 
+    } 
+  } 
+ 
+  /* Construct the BWTed string by using 
+     the sorted order of type B suffixes. */ 
+  k = SA + BUCKET_A(c2 = T[n - 1]); 
+  *k++ = (T[n - 2] < c2) ? ~((int)T[n - 2]) : (n - 1); 
+  /* Scan the suffix array from left to right. */ 
+  for(i = SA, j = SA + n, orig = SA; i < j; ++i) { 
+    if(0 < (s = *i)) { 
+      assert(T[s - 1] >= T[s]); 
+      c0 = T[--s]; 
+      *i = c0; 
+      if((0 < s) && (T[s - 1] < c0)) { s = ~((int)T[s - 1]); } 
+      if(c0 != c2) { 
+        BUCKET_A(c2) = k - SA; 
+        k = SA + BUCKET_A(c2 = c0); 
+      } 
+      assert(i < k); 
+      *k++ = s; 
+    } else if(s != 0) { 
+      *i = ~s; 
+    } else { 
+      orig = i; 
+    } 
+  } 
+ 
+  return orig - SA; 
+} 
+ 
+/* Constructs the burrows-wheeler transformed string directly 
+   by using the sorted order of type B* suffixes. */ 
+static 
+int 
+construct_BWT_indexes(const unsigned char *T, int *SA, 
+                      int *bucket_A, int *bucket_B, 
+                      int n, int m, 
+                      unsigned char * num_indexes, int * indexes) { 
+  int *i, *j, *k, *orig; 
+  int s; 
+  int c0, c1, c2; 
+ 
+  int mod = n / 8; 
+  { 
+      mod |= mod >> 1;  mod |= mod >> 2; 
+      mod |= mod >> 4;  mod |= mod >> 8; 
+      mod |= mod >> 16; mod >>= 1; 
+ 
+      *num_indexes = (unsigned char)((n - 1) / (mod + 1)); 
+  } 
+ 
+  if(0 < m) { 
+    /* Construct the sorted order of type B suffixes by using 
+       the sorted order of type B* suffixes. */ 
+    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) { 
+      /* Scan the suffix array from right to left. */ 
+      for(i = SA + BUCKET_BSTAR(c1, c1 + 1), 
+          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1; 
+          i <= j; 
+          --j) { 
+        if(0 < (s = *j)) { 
+          assert(T[s] == c1); 
+          assert(((s + 1) < n) && (T[s] <= T[s + 1])); 
+          assert(T[s - 1] <= T[s]); 
+ 
+          if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = j - SA; 
+ 
+          c0 = T[--s]; 
+          *j = ~((int)c0); 
+          if((0 < s) && (T[s - 1] > c0)) { s = ~s; } 
+          if(c0 != c2) { 
+            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; } 
+            k = SA + BUCKET_B(c2 = c0, c1); 
+          } 
+          assert(k < j); 
+          *k-- = s; 
+        } else if(s != 0) { 
+          *j = ~s; 
+#ifndef NDEBUG 
+        } else { 
+          assert(T[s] == c1); 
+#endif 
+        } 
+      } 
+    } 
+  } 
+ 
+  /* Construct the BWTed string by using 
+     the sorted order of type B suffixes. */ 
+  k = SA + BUCKET_A(c2 = T[n - 1]); 
+  if (T[n - 2] < c2) { 
+    if (((n - 1) & mod) == 0) indexes[(n - 1) / (mod + 1) - 1] = k - SA; 
+    *k++ = ~((int)T[n - 2]); 
+  } 
+  else { 
+    *k++ = n - 1; 
+  } 
+ 
+  /* Scan the suffix array from left to right. */ 
+  for(i = SA, j = SA + n, orig = SA; i < j; ++i) { 
+    if(0 < (s = *i)) { 
+      assert(T[s - 1] >= T[s]); 
+ 
+      if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = i - SA; 
+ 
+      c0 = T[--s]; 
+      *i = c0; 
+      if(c0 != c2) { 
+        BUCKET_A(c2) = k - SA; 
+        k = SA + BUCKET_A(c2 = c0); 
+      } 
+      assert(i < k); 
+      if((0 < s) && (T[s - 1] < c0)) { 
+          if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = k - SA; 
+          *k++ = ~((int)T[s - 1]); 
+      } else 
+        *k++ = s; 
+    } else if(s != 0) { 
+      *i = ~s; 
+    } else { 
+      orig = i; 
+    } 
+  } 
+ 
+  return orig - SA; 
+} 
+ 
+ 
+/*---------------------------------------------------------------------------*/ 
+ 
+/*- Function -*/ 
+ 
+int 
+divsufsort(const unsigned char *T, int *SA, int n, int openMP) { 
+  int *bucket_A, *bucket_B; 
+  int m; 
+  int err = 0; 
+ 
+  /* Check arguments. */ 
+  if((T == NULL) || (SA == NULL) || (n < 0)) { return -1; } 
+  else if(n == 0) { return 0; } 
+  else if(n == 1) { SA[0] = 0; return 0; } 
+  else if(n == 2) { m = (T[0] < T[1]); SA[m ^ 1] = 0, SA[m] = 1; return 0; } 
+ 
+  bucket_A = (int *)malloc(BUCKET_A_SIZE * sizeof(int)); 
+  bucket_B = (int *)malloc(BUCKET_B_SIZE * sizeof(int)); 
+ 
+  /* Suffixsort. */ 
+  if((bucket_A != NULL) && (bucket_B != NULL)) { 
+    m = sort_typeBstar(T, SA, bucket_A, bucket_B, n, openMP); 
+    construct_SA(T, SA, bucket_A, bucket_B, n, m); 
+  } else { 
+    err = -2; 
+  } 
+ 
+  free(bucket_B); 
+  free(bucket_A); 
+ 
+  return err; 
+} 
+ 
+int 
+divbwt(const unsigned char *T, unsigned char *U, int *A, int n, unsigned char * num_indexes, int * indexes, int openMP) { 
+  int *B; 
+  int *bucket_A, *bucket_B; 
+  int m, pidx, i; 
+ 
+  /* Check arguments. */ 
+  if((T == NULL) || (U == NULL) || (n < 0)) { return -1; } 
+  else if(n <= 1) { if(n == 1) { U[0] = T[0]; } return n; } 
+ 
+  if((B = A) == NULL) { B = (int *)malloc((size_t)(n + 1) * sizeof(int)); } 
+  bucket_A = (int *)malloc(BUCKET_A_SIZE * sizeof(int)); 
+  bucket_B = (int *)malloc(BUCKET_B_SIZE * sizeof(int)); 
+ 
+  /* Burrows-Wheeler Transform. */ 
+  if((B != NULL) && (bucket_A != NULL) && (bucket_B != NULL)) { 
+    m = sort_typeBstar(T, B, bucket_A, bucket_B, n, openMP); 
+ 
+    if (num_indexes == NULL || indexes == NULL) { 
+        pidx = construct_BWT(T, B, bucket_A, bucket_B, n, m); 
+    } else { 
+        pidx = construct_BWT_indexes(T, B, bucket_A, bucket_B, n, m, num_indexes, indexes); 
+    } 
+ 
+    /* Copy to output string. */ 
+    U[0] = T[n - 1]; 
+    for(i = 0; i < pidx; ++i) { U[i + 1] = (unsigned char)B[i]; } 
+    for(i += 1; i < n; ++i) { U[i] = (unsigned char)B[i]; } 
+    pidx += 1; 
+  } else { 
+    pidx = -2; 
+  } 
+ 
+  free(bucket_B); 
+  free(bucket_A); 
+  if(A == NULL) { free(B); } 
+ 
+  return pidx; 
+} 
diff --git a/contrib/libs/zstd06/dictBuilder/divsufsort.h b/contrib/libs/zstd06/dictBuilder/divsufsort.h
index 84686157ab..546c302cb4 100644
--- a/contrib/libs/zstd06/dictBuilder/divsufsort.h
+++ b/contrib/libs/zstd06/dictBuilder/divsufsort.h
@@ -1,68 +1,68 @@
 #include <contrib/libs/zstd06/renames.h>
-/*
- * divsufsort.h for libdivsufsort-lite
- * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following
- * conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#ifndef _DIVSUFSORT_H
-#define _DIVSUFSORT_H 1
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-
-/*- Prototypes -*/
-
-/**
- * Constructs the suffix array of a given string.
- * @param T[0..n-1] The input string.
- * @param SA[0..n-1] The output array of suffixes.
- * @param n The length of the given string.
- * @param openMP enables OpenMP optimization.
- * @return 0 if no error occurred, -1 or -2 otherwise.
- */
-int
-divsufsort(const unsigned char *T, int *SA, int n, int openMP);
-
-/**
- * Constructs the burrows-wheeler transformed string of a given string.
- * @param T[0..n-1] The input string.
- * @param U[0..n-1] The output string. (can be T)
- * @param A[0..n-1] The temporary array. (can be NULL)
- * @param n The length of the given string.
- * @param num_indexes The length of secondary indexes array. (can be NULL)
- * @param indexes The secondary indexes array. (can be NULL)
- * @param openMP enables OpenMP optimization.
- * @return The primary index if no error occurred, -1 or -2 otherwise.
- */
-int
-divbwt(const unsigned char *T, unsigned char *U, int *A, int n, unsigned char * num_indexes, int * indexes, int openMP);
-
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif /* __cplusplus */
-
-#endif /* _DIVSUFSORT_H */
+/* 
+ * divsufsort.h for libdivsufsort-lite 
+ * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved. 
+ * 
+ * Permission is hereby granted, free of charge, to any person 
+ * obtaining a copy of this software and associated documentation 
+ * files (the "Software"), to deal in the Software without 
+ * restriction, including without limitation the rights to use, 
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell 
+ * copies of the Software, and to permit persons to whom the 
+ * Software is furnished to do so, subject to the following 
+ * conditions: 
+ * 
+ * The above copyright notice and this permission notice shall be 
+ * included in all copies or substantial portions of the Software. 
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
+ * OTHER DEALINGS IN THE SOFTWARE. 
+ */ 
+ 
+#ifndef _DIVSUFSORT_H 
+#define _DIVSUFSORT_H 1 
+ 
+#ifdef __cplusplus 
+extern "C" { 
+#endif /* __cplusplus */ 
+ 
+ 
+/*- Prototypes -*/ 
+ 
+/** 
+ * Constructs the suffix array of a given string. 
+ * @param T[0..n-1] The input string. 
+ * @param SA[0..n-1] The output array of suffixes. 
+ * @param n The length of the given string. 
+ * @param openMP enables OpenMP optimization. 
+ * @return 0 if no error occurred, -1 or -2 otherwise. 
+ */ 
+int 
+divsufsort(const unsigned char *T, int *SA, int n, int openMP); 
+ 
+/** 
+ * Constructs the burrows-wheeler transformed string of a given string. 
+ * @param T[0..n-1] The input string. 
+ * @param U[0..n-1] The output string. (can be T) 
+ * @param A[0..n-1] The temporary array. (can be NULL) 
+ * @param n The length of the given string. 
+ * @param num_indexes The length of secondary indexes array. (can be NULL) 
+ * @param indexes The secondary indexes array. (can be NULL) 
+ * @param openMP enables OpenMP optimization. 
+ * @return The primary index if no error occurred, -1 or -2 otherwise. 
+ */ 
+int 
+divbwt(const unsigned char *T, unsigned char *U, int *A, int n, unsigned char * num_indexes, int * indexes, int openMP); 
+ 
+ 
+#ifdef __cplusplus 
+} /* extern "C" */ 
+#endif /* __cplusplus */ 
+ 
+#endif /* _DIVSUFSORT_H */ 
diff --git a/contrib/libs/zstd06/dictBuilder/zdict.c b/contrib/libs/zstd06/dictBuilder/zdict.c
index 95d291f409..4b19394073 100644
--- a/contrib/libs/zstd06/dictBuilder/zdict.c
+++ b/contrib/libs/zstd06/dictBuilder/zdict.c
@@ -1,949 +1,949 @@
-/*
-    dictBuilder - dictionary builder for zstd
-    Copyright (C) Yann Collet 2016
-
-    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 : https://www.zstd.net
-*/
-
-/*-**************************************
-*  Compiler Options
-****************************************/
-/* Disable some Visual warning messages */
-#ifdef _MSC_VER
-#  pragma warning(disable : 4127)                /* disable: C4127: conditional expression is constant */
-#endif
-
-/* Unix Large Files support (>4GB) */
-#define _FILE_OFFSET_BITS 64
-#if (defined(__sun__) && (!defined(__LP64__)))   /* Sun Solaris 32-bits requires specific definitions */
-#  define _LARGEFILE_SOURCE
-#elif ! defined(__LP64__)                        /* No point defining Large file for 64 bit */
-#  define _LARGEFILE64_SOURCE
-#endif
-
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include <stdlib.h>        /* malloc, free */
-#include <string.h>        /* memset */
-#include <stdio.h>         /* fprintf, fopen, ftello64 */
-#include <time.h>          /* clock */
-
-#include "mem.h"           /* read */
-#include "error_private.h"
-#include "fse.h"
+/* 
+    dictBuilder - dictionary builder for zstd 
+    Copyright (C) Yann Collet 2016 
+ 
+    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 : https://www.zstd.net 
+*/ 
+ 
+/*-************************************** 
+*  Compiler Options 
+****************************************/ 
+/* Disable some Visual warning messages */ 
+#ifdef _MSC_VER 
+#  pragma warning(disable : 4127)                /* disable: C4127: conditional expression is constant */ 
+#endif 
+ 
+/* Unix Large Files support (>4GB) */ 
+#define _FILE_OFFSET_BITS 64 
+#if (defined(__sun__) && (!defined(__LP64__)))   /* Sun Solaris 32-bits requires specific definitions */ 
+#  define _LARGEFILE_SOURCE 
+#elif ! defined(__LP64__)                        /* No point defining Large file for 64 bit */ 
+#  define _LARGEFILE64_SOURCE 
+#endif 
+ 
+ 
+/*-************************************* 
+*  Dependencies 
+***************************************/ 
+#include <stdlib.h>        /* malloc, free */ 
+#include <string.h>        /* memset */ 
+#include <stdio.h>         /* fprintf, fopen, ftello64 */ 
+#include <time.h>          /* clock */ 
+ 
+#include "mem.h"           /* read */ 
+#include "error_private.h" 
+#include "fse.h" 
 #include "huf_static.h"
-#include "zstd_internal.h"
-#include "divsufsort.h"
-#include "zdict_static.h"
-
-
-
-/*-*************************************
-*  Constants
-***************************************/
-#define KB *(1 <<10)
-#define MB *(1 <<20)
-#define GB *(1U<<30)
-
-#define DICTLISTSIZE 10000
-
-#define NOISELENGTH 32
-#define PRIME1   2654435761U
-#define PRIME2   2246822519U
-
-#define MINRATIO 4
-static const U32 g_compressionLevel_default = 5;
-static const U32 g_selectivity_default = 9;
-static const size_t g_provision_entropySize = 200;
-static const size_t g_min_fast_dictContent = 192;
-
-
-/*-*************************************
-*  Console display
-***************************************/
-#define DISPLAY(...)         fprintf(stderr, __VA_ARGS__)
-#define DISPLAYLEVEL(l, ...) if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); }
-static unsigned g_displayLevel = 0;   /* 0 : no display;   1: errors;   2: default;  4: full information */
-
-#define DISPLAYUPDATE(l, ...) if (g_displayLevel>=l) { \
-            if (ZDICT_GetMilliSpan(g_time) > refreshRate)  \
-            { g_time = clock(); DISPLAY(__VA_ARGS__); \
-            if (g_displayLevel>=4) fflush(stdout); } }
-static const unsigned refreshRate = 300;
-static clock_t g_time = 0;
-
-static void ZDICT_printHex(U32 dlevel, const void* ptr, size_t length)
-{
-    const BYTE* const b = (const BYTE*)ptr;
-    size_t u;
-    for (u=0; u<length; u++)
-    {
-        BYTE c = b[u];
-        if (c<32 || c>126) c = '.';   /* non-printable char */
-        DISPLAYLEVEL(dlevel, "%c", c);
-    }
-}
-
-
-/*-********************************************************
-*  Helper functions
-**********************************************************/
-static unsigned ZDICT_GetMilliSpan(clock_t nPrevious)
-{
-    clock_t nCurrent = clock();
-    unsigned nSpan = (unsigned)(((nCurrent - nPrevious) * 1000) / CLOCKS_PER_SEC);
-    return nSpan;
-}
-
-unsigned ZDICT_isError(size_t errorCode) { return ERR_isError(errorCode); }
-
-const char* ZDICT_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
-
-
-/*-********************************************************
-*  Dictionary training functions
-**********************************************************/
-static unsigned ZDICT_NbCommonBytes (register size_t val)
-{
-    if (MEM_isLittleEndian()) {
-        if (MEM_64bits()) {
-#       if defined(_MSC_VER) && defined(_WIN64)
-            unsigned long r = 0;
-            _BitScanForward64( &r, (U64)val );
-            return (unsigned)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3)
-            return (__builtin_ctzll((U64)val) >> 3);
-#       else
-            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 };
-            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];
-#       endif
-        } else { /* 32 bits */
-#       if defined(_MSC_VER)
-            unsigned long r=0;
-            _BitScanForward( &r, (U32)val );
-            return (unsigned)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3)
-            return (__builtin_ctz((U32)val) >> 3);
-#       else
-            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 };
-            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
-#       endif
-        }
-    } else {  /* Big Endian CPU */
-        if (MEM_64bits()) {
-#       if defined(_MSC_VER) && defined(_WIN64)
-            unsigned long r = 0;
-            _BitScanReverse64( &r, val );
-            return (unsigned)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3)
-            return (__builtin_clzll(val) >> 3);
-#       else
-            unsigned r;
-            const unsigned n32 = sizeof(size_t)*4;   /* calculate this way due to compiler complaining in 32-bits mode */
-            if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; }
-            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
-            r += (!val);
-            return r;
-#       endif
-        } else { /* 32 bits */
-#       if defined(_MSC_VER)
-            unsigned long r = 0;
-            _BitScanReverse( &r, (unsigned long)val );
-            return (unsigned)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3)
-            return (__builtin_clz((U32)val) >> 3);
-#       else
-            unsigned r;
-            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
-            r += (!val);
-            return r;
-#       endif
-    }   }
-}
-
-
-/*! ZDICT_count() :
-    Count the nb of common bytes between 2 pointers.
-    Note : this function presumes end of buffer followed by noisy guard band.
-*/
-static size_t ZDICT_count(const void* pIn, const void* pMatch)
-{
-    const char* const pStart = (const char*)pIn;
-    for (;;) {
-        size_t diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
-        if (!diff) { pIn = (const char*)pIn+sizeof(size_t); pMatch = (const char*)pMatch+sizeof(size_t); continue; }
-        pIn = (const char*)pIn+ZDICT_NbCommonBytes(diff);
-        return (size_t)((const char*)pIn - pStart);
-    }
-}
-
-
-typedef struct {
-    U32 pos;
-    U32 length;
-    U32 savings;
-} dictItem;
-
-static void ZDICT_initDictItem(dictItem* d)
-{
-    d->pos = 1;
-    d->length = 0;
-    d->savings = (U32)(-1);
-}
-
-
-#define LLIMIT 64          /* heuristic determined experimentally */
-#define MINMATCHLENGTH 7   /* heuristic determined experimentally */
-static dictItem ZDICT_analyzePos(
-                       BYTE* doneMarks,
-                       const int* suffix, U32 start,
-                       const void* buffer, U32 minRatio)
-{
-    U32 lengthList[LLIMIT] = {0};
-    U32 cumulLength[LLIMIT] = {0};
-    U32 savings[LLIMIT] = {0};
-    const BYTE* b = (const BYTE*)buffer;
-    size_t length;
-    size_t maxLength = LLIMIT;
-    size_t pos = suffix[start];
-    U32 end = start;
-    dictItem solution;
-
-    /* init */
-    memset(&solution, 0, sizeof(solution));
-    doneMarks[pos] = 1;
-
-    /* trivial repetition cases */
-    if ( (MEM_read16(b+pos+0) == MEM_read16(b+pos+2))
-       ||(MEM_read16(b+pos+1) == MEM_read16(b+pos+3))
-       ||(MEM_read16(b+pos+2) == MEM_read16(b+pos+4)) ) {
-        /* skip and mark segment */
-        U16 u16 = MEM_read16(b+pos+4);
-        U32 u, e = 6;
-        while (MEM_read16(b+pos+e) == u16) e+=2 ;
-        if (b[pos+e] == b[pos+e-1]) e++;
-        for (u=1; u<e; u++)
-            doneMarks[pos+u] = 1;
-        return solution;
-    }
-
-    /* look forward */
-    do {
-        end++;
-        length = ZDICT_count(b + pos, b + suffix[end]);
-    } while (length >=MINMATCHLENGTH);
-
-    /* look backward */
-    do {
-        length = ZDICT_count(b + pos, b + *(suffix+start-1));
-        if (length >=MINMATCHLENGTH) start--;
-    } while(length >= MINMATCHLENGTH);
-
-    /* exit if not found a minimum nb of repetitions */
-    if (end-start < minRatio) {
-        U32 idx;
-        for(idx=start; idx<end; idx++)
-            doneMarks[suffix[idx]] = 1;
-        return solution;
-    }
-
-    {   int i;
-        U32 searchLength;
-        U32 refinedStart = start;
-        U32 refinedEnd = end;
-
-        DISPLAYLEVEL(4, "\n");
-        DISPLAYLEVEL(4, "found %3u matches of length >= %u at pos %7u  ", (U32)(end-start), MINMATCHLENGTH, (U32)pos);
-        DISPLAYLEVEL(4, "\n");
-
-        for (searchLength = MINMATCHLENGTH ; ; searchLength++) {
-            BYTE currentChar = 0;
-            U32 currentCount = 0;
-            U32 currentID = refinedStart;
-            U32 id;
-            U32 selectedCount = 0;
-            U32 selectedID = currentID;
-            for (id =refinedStart; id < refinedEnd; id++) {
-                if (b[ suffix[id] + searchLength] != currentChar) {
-                    if (currentCount > selectedCount) {
-                        selectedCount = currentCount;
-                        selectedID = currentID;
-                    }
-                    currentID = id;
-                    currentChar = b[ suffix[id] + searchLength];
-                    currentCount = 0;
-                }
-                currentCount ++;
-            }
-            if (currentCount > selectedCount) {  /* for last */
-                selectedCount = currentCount;
-                selectedID = currentID;
-            }
-
-            if (selectedCount < minRatio)
-                break;
-            refinedStart = selectedID;
-            refinedEnd = refinedStart + selectedCount;
-        }
-
-        /* evaluate gain based on new ref */
-        start = refinedStart;
-        pos = suffix[refinedStart];
-        end = start;
-        memset(lengthList, 0, sizeof(lengthList));
-
-        /* look forward */
-        do {
-            end++;
-            length = ZDICT_count(b + pos, b + suffix[end]);
-            if (length >= LLIMIT) length = LLIMIT-1;
-            lengthList[length]++;
-        } while (length >=MINMATCHLENGTH);
-
-        /* look backward */
-        do {
-            length = ZDICT_count(b + pos, b + suffix[start-1]);
-            if (length >= LLIMIT) length = LLIMIT-1;
-            lengthList[length]++;
-            if (length >=MINMATCHLENGTH) start--;
-        } while(length >= MINMATCHLENGTH);
-
-        /* largest useful length */
-        memset(cumulLength, 0, sizeof(cumulLength));
-        cumulLength[maxLength-1] = lengthList[maxLength-1];
-        for (i=(int)(maxLength-2); i>=0; i--)
-            cumulLength[i] = cumulLength[i+1] + lengthList[i];
-
-        for (i=LLIMIT-1; i>=MINMATCHLENGTH; i--) if (cumulLength[i]>=minRatio) break;
-        maxLength = i;
-
-        /* reduce maxLength in case of final into repetitive data */
-        {
-            U32 l = (U32)maxLength;
-            BYTE c = b[pos + maxLength-1];
-            while (b[pos+l-2]==c) l--;
-            maxLength = l;
-        }
-        if (maxLength < MINMATCHLENGTH) return solution;   /* skip : no long-enough solution */
-
-        /* calculate savings */
-        savings[5] = 0;
-        for (i=MINMATCHLENGTH; i<=(int)maxLength; i++)
-            savings[i] = savings[i-1] + (lengthList[i] * (i-3));
-
-        DISPLAYLEVEL(4, "Selected ref at position %u, of length %u : saves %u (ratio: %.2f)  \n",
-                     (U32)pos, (U32)maxLength, savings[maxLength], (double)savings[maxLength] / maxLength);
-
-        solution.pos = (U32)pos;
-        solution.length = (U32)maxLength;
-        solution.savings = savings[maxLength];
-
-        /* mark positions done */
-        {
-            U32 id;
-            U32 testedPos;
-            for (id=start; id<end; id++) {
-                U32 p, pEnd;
-                testedPos = suffix[id];
-                if (testedPos == pos)
-                    length = solution.length;
-                else {
-                    length = ZDICT_count(b+pos, b+testedPos);
-                    if (length > solution.length) length = solution.length;
-                }
-                pEnd = (U32)(testedPos + length);
-                for (p=testedPos; p<pEnd; p++)
-                    doneMarks[p] = 1;
-    }   }   }
-
-    return solution;
-}
-
-
-/*! ZDICT_checkMerge
-    check if dictItem can be merged, do it if possible
-    @return : id of destination elt, 0 if not merged
-*/
-static U32 ZDICT_checkMerge(dictItem* table, dictItem elt, U32 eltNbToSkip)
-{
-    const U32 tableSize = table->pos;
-    const U32 max = elt.pos + (elt.length-1);
-
-    /* tail overlap */
-    U32 u; for (u=1; u<tableSize; u++) {
-        if (u==eltNbToSkip) continue;
-        if ((table[u].pos > elt.pos) && (table[u].pos < max)) {  /* overlap */
-            /* append */
-            U32 addedLength = table[u].pos - elt.pos;
-            table[u].length += addedLength;
-            table[u].pos = elt.pos;
-            table[u].savings += elt.savings * addedLength / elt.length;   /* rough approx */
-            table[u].savings += elt.length / 8;    /* rough approx */
-            elt = table[u];
-            while ((u>1) && (table[u-1].savings < elt.savings))
-                table[u] = table[u-1], u--;
-            table[u] = elt;
-            return u;
-    }   }
-
-    /* front overlap */
-    for (u=1; u<tableSize; u++) {
-        if (u==eltNbToSkip) continue;
-        if ((table[u].pos + table[u].length > elt.pos) && (table[u].pos < elt.pos)) {  /* overlap */
-            /* append */
-            int addedLength = (elt.pos + elt.length) - (table[u].pos + table[u].length);
-            table[u].savings += elt.length / 8;    /* rough approx */
-            if (addedLength > 0) {   /* otherwise, already included */
-                table[u].length += addedLength;
-                table[u].savings += elt.savings * addedLength / elt.length;   /* rough approx */
-            }
-            elt = table[u];
-            while ((u>1) && (table[u-1].savings < elt.savings))
-                table[u] = table[u-1], u--;
-            table[u] = elt;
-            return u;
-    }   }
-
-    return 0;
-}
-
-
-static void ZDICT_removeDictItem(dictItem* table, U32 id)
-{
-    /* convention : first element is nb of elts */
-    U32 max = table->pos;
-    U32 u;
-    if (!id) return;   /* protection, should never happen */
-    for (u=id; u<max-1; u++)
-        table[u] = table[u+1];
-    table->pos--;
-}
-
-
-static void ZDICT_insertDictItem(dictItem* table, U32 maxSize, dictItem elt)
-{
-    /* merge if possible */
-    U32 mergeId = ZDICT_checkMerge(table, elt, 0);
-    if (mergeId) {
-        U32 newMerge = 1;
-        while (newMerge) {
-            newMerge = ZDICT_checkMerge(table, table[mergeId], mergeId);
-            if (newMerge) ZDICT_removeDictItem(table, mergeId);
-            mergeId = newMerge;
-        }
-        return;
-    }
-
-    /* insert */
-    {
-        U32 current;
-        U32 nextElt = table->pos;
-        if (nextElt >= maxSize) nextElt = maxSize-1;
-        current = nextElt-1;
-        while (table[current].savings < elt.savings) {
-            table[current+1] = table[current];
-            current--;
-        }
-        table[current+1] = elt;
-        table->pos = nextElt+1;
-    }
-}
-
-
-static U32 ZDICT_dictSize(const dictItem* dictList)
-{
-    U32 u, dictSize = 0;
-    for (u=1; u<dictList[0].pos; u++)
-        dictSize += dictList[u].length;
-    return dictSize;
-}
-
-
-static size_t ZDICT_trainBuffer(dictItem* dictList, U32 dictListSize,
-                            const void* const buffer, const size_t bufferSize,   /* buffer must end with noisy guard band */
-                            const size_t* fileSizes, unsigned nbFiles,
-                            U32 shiftRatio, unsigned maxDictSize)
-{
-    int* const suffix0 = (int*)malloc((bufferSize+2)*sizeof(*suffix0));
-    int* const suffix = suffix0+1;
-    U32* reverseSuffix = (U32*)malloc((bufferSize)*sizeof(*reverseSuffix));
-    BYTE* doneMarks = (BYTE*)malloc((bufferSize+16)*sizeof(*doneMarks));   /* +16 for overflow security */
-    U32* filePos = (U32*)malloc(nbFiles * sizeof(*filePos));
-    U32 minRatio = nbFiles >> shiftRatio;
-    int divSuftSortResult;
-    size_t result = 0;
-
-    /* init */
-    DISPLAYLEVEL(2, "\r%70s\r", "");   /* clean display line */
-    if (!suffix0 || !reverseSuffix || !doneMarks || !filePos) {
-        result = ERROR(memory_allocation);
-        goto _cleanup;
-    }
-    if (minRatio < MINRATIO) minRatio = MINRATIO;
-    memset(doneMarks, 0, bufferSize+16);
-
-    /* sort */
-    DISPLAYLEVEL(2, "sorting %u files of total size %u MB ...\n", nbFiles, (U32)(bufferSize>>20));
-    divSuftSortResult = divsufsort((const unsigned char*)buffer, suffix, (int)bufferSize, 0);
-    if (divSuftSortResult != 0) { result = ERROR(GENERIC); goto _cleanup; }
-    suffix[bufferSize] = (int)bufferSize;   /* leads into noise */
-    suffix0[0] = (int)bufferSize;           /* leads into noise */
-    {
-        /* build reverse suffix sort */
-        size_t pos;
-        for (pos=0; pos < bufferSize; pos++)
-            reverseSuffix[suffix[pos]] = (U32)pos;
-        /* build file pos */
-        filePos[0] = 0;
-        for (pos=1; pos<nbFiles; pos++)
-            filePos[pos] = (U32)(filePos[pos-1] + fileSizes[pos-1]);
-    }
-
-    DISPLAYLEVEL(2, "finding patterns ... \n");
-    DISPLAYLEVEL(3, "minimum ratio : %u \n", minRatio);
-
-    {
-        U32 cursor; for (cursor=0; cursor < bufferSize; ) {
-            dictItem solution;
-            if (doneMarks[cursor]) { cursor++; continue; }
-            solution = ZDICT_analyzePos(doneMarks, suffix, reverseSuffix[cursor], buffer, minRatio);
-            if (solution.length==0) { cursor++; continue; }
-            ZDICT_insertDictItem(dictList, dictListSize, solution);
-            cursor += solution.length;
-            DISPLAYUPDATE(2, "\r%4.2f %% \r", (double)cursor / bufferSize * 100);
-    }   }
-
-    /* limit dictionary size */
-    {
-        U32 max = dictList->pos;   /* convention : nb of useful elts within dictList */
-        U32 currentSize = 0;
-        U32 n; for (n=1; n<max; n++) {
-            currentSize += dictList[n].length;
-            if (currentSize > maxDictSize) break;
-        }
-        dictList->pos = n;
-    }
-
-_cleanup:
-    free(suffix0);
-    free(reverseSuffix);
-    free(doneMarks);
-    free(filePos);
-    return result;
-}
-
-
-static void ZDICT_fillNoise(void* buffer, size_t length)
-{
-    unsigned acc = PRIME1;
-    size_t p=0;;
-    for (p=0; p<length; p++) {
-        acc *= PRIME2;
-        ((unsigned char*)buffer)[p] = (unsigned char)(acc >> 21);
-    }
-}
-
-
-typedef struct
-{
-    ZSTD_CCtx* ref;
-    ZSTD_CCtx* zc;
-    void* workPlace;   /* must be ZSTD_BLOCKSIZE_MAX allocated */
-} EStats_ress_t;
-
-
-static void ZDICT_countEStats(EStats_ress_t esr,
-                            U32* countLit, U32* offsetcodeCount, U32* matchlengthCount, U32* litlengthCount,
-                            const void* src, size_t srcSize)
-{
-    const seqStore_t* seqStorePtr;
-
-    if (srcSize > ZSTD_BLOCKSIZE_MAX) srcSize = ZSTD_BLOCKSIZE_MAX;   /* protection vs large samples */
-    ZSTD_copyCCtx(esr.zc, esr.ref);
-    ZSTD_compressBlock(esr.zc, esr.workPlace, ZSTD_BLOCKSIZE_MAX, src, srcSize);
-    seqStorePtr = ZSTD_getSeqStore(esr.zc);
-
-    /* literals stats */
-    {   const BYTE* bytePtr;
-        for(bytePtr = seqStorePtr->litStart; bytePtr < seqStorePtr->lit; bytePtr++)
-            countLit[*bytePtr]++;
-    }
-
-    /* seqStats */
-    {   size_t const nbSeq = (size_t)(seqStorePtr->offset - seqStorePtr->offsetStart);
-        ZSTD_seqToCodes(seqStorePtr, nbSeq);
-
-        {   const BYTE* codePtr = seqStorePtr->offCodeStart;
-            size_t u;
-            for (u=0; u<nbSeq; u++) offsetcodeCount[codePtr[u]]++;
-        }
-
-        {   const BYTE* codePtr = seqStorePtr->mlCodeStart;
-            size_t u;
-            for (u=0; u<nbSeq; u++) matchlengthCount[codePtr[u]]++;
-        }
-
-        {   const BYTE* codePtr = seqStorePtr->llCodeStart;
-            size_t u;
-            for (u=0; u<nbSeq; u++) litlengthCount[codePtr[u]]++;
-    }   }
-}
-
-/*
-static size_t ZDICT_maxSampleSize(const size_t* fileSizes, unsigned nbFiles)
-{
-    unsigned u;
-    size_t max=0;
-    for (u=0; u<nbFiles; u++)
-        if (max < fileSizes[u]) max = fileSizes[u];
-    return max;
-}
-*/
-
-static size_t ZDICT_totalSampleSize(const size_t* fileSizes, unsigned nbFiles)
-{
-    size_t total;
-    unsigned u;
-    for (u=0, total=0; u<nbFiles; u++) total += fileSizes[u];
-    return total;
-}
-
-#define OFFCODE_MAX 18  /* only applicable to first block */
-static size_t ZDICT_analyzeEntropy(void*  dstBuffer, size_t maxDstSize,
-                                 unsigned compressionLevel,
-                           const void*  srcBuffer, const size_t* fileSizes, unsigned nbFiles,
-                           const void* dictBuffer, size_t  dictBufferSize)
-{
-    U32 countLit[256];
-    HUF_CREATE_STATIC_CTABLE(hufTable, 255);
-    U32 offcodeCount[OFFCODE_MAX+1];
-    short offcodeNCount[OFFCODE_MAX+1];
-    U32 matchLengthCount[MaxML+1];
-    short matchLengthNCount[MaxML+1];
-    U32 litLengthCount[MaxLL+1];
-    short litLengthNCount[MaxLL+1];
-    EStats_ress_t esr;
-    ZSTD_parameters params;
-    U32 u, huffLog = 12, Offlog = OffFSELog, mlLog = MLFSELog, llLog = LLFSELog, total;
-    size_t pos = 0, errorCode;
-    size_t eSize = 0;
-    size_t const totalSrcSize = ZDICT_totalSampleSize(fileSizes, nbFiles);
-    size_t const averageSampleSize = totalSrcSize / nbFiles;
-
-    /* init */
-    for (u=0; u<256; u++) countLit[u]=1;   /* any character must be described */
-    for (u=0; u<=OFFCODE_MAX; u++) offcodeCount[u]=1;
-    for (u=0; u<=MaxML; u++) matchLengthCount[u]=1;
-    for (u=0; u<=MaxLL; u++) litLengthCount[u]=1;
-    esr.ref = ZSTD_createCCtx();
-    esr.zc = ZSTD_createCCtx();
-    esr.workPlace = malloc(ZSTD_BLOCKSIZE_MAX);
-    if (!esr.ref || !esr.zc || !esr.workPlace) {
-            eSize = ERROR(memory_allocation);
-            DISPLAYLEVEL(1, "Not enough memory");
-            goto _cleanup;
-    }
-    if (compressionLevel==0) compressionLevel=g_compressionLevel_default;
-    params.cParams = ZSTD_getCParams(compressionLevel, averageSampleSize, dictBufferSize);
-    params.cParams.strategy = ZSTD_greedy;
-    params.fParams.contentSizeFlag = 0;
-    ZSTD_compressBegin_advanced(esr.ref, dictBuffer, dictBufferSize, params, 0);
-
-    /* collect stats on all files */
-    for (u=0; u<nbFiles; u++) {
-        ZDICT_countEStats(esr,
-                        countLit, offcodeCount, matchLengthCount, litLengthCount,
-           (const char*)srcBuffer + pos, fileSizes[u]);
-        pos += fileSizes[u];
-    }
-
-    /* analyze */
-    errorCode = HUF_buildCTable (hufTable, countLit, 255, huffLog);
-    if (HUF_isError(errorCode)) {
-        eSize = ERROR(GENERIC);
-        DISPLAYLEVEL(1, "HUF_buildCTable error");
-        goto _cleanup;
-    }
-    huffLog = (U32)errorCode;
-
-    total=0; for (u=0; u<=OFFCODE_MAX; u++) total+=offcodeCount[u];
-    errorCode = FSE_normalizeCount(offcodeNCount, Offlog, offcodeCount, total, OFFCODE_MAX);
-    if (FSE_isError(errorCode)) {
-        eSize = ERROR(GENERIC);
-        DISPLAYLEVEL(1, "FSE_normalizeCount error with offcodeCount");
-        goto _cleanup;
-    }
-    Offlog = (U32)errorCode;
-
-    total=0; for (u=0; u<=MaxML; u++) total+=matchLengthCount[u];
-    errorCode = FSE_normalizeCount(matchLengthNCount, mlLog, matchLengthCount, total, MaxML);
-    if (FSE_isError(errorCode)) {
-        eSize = ERROR(GENERIC);
-        DISPLAYLEVEL(1, "FSE_normalizeCount error with matchLengthCount");
-        goto _cleanup;
-    }
-    mlLog = (U32)errorCode;
-
-    total=0; for (u=0; u<=MaxLL; u++) total+=litLengthCount[u];
-    errorCode = FSE_normalizeCount(litLengthNCount, llLog, litLengthCount, total, MaxLL);
-    if (FSE_isError(errorCode)) {
-        eSize = ERROR(GENERIC);
-        DISPLAYLEVEL(1, "FSE_normalizeCount error with litLengthCount");
-        goto _cleanup;
-    }
-    llLog = (U32)errorCode;
-
-    /* write result to buffer */
-    errorCode = HUF_writeCTable(dstBuffer, maxDstSize, hufTable, 255, huffLog);
-    if (HUF_isError(errorCode)) {
-        eSize = ERROR(GENERIC);
-        DISPLAYLEVEL(1, "HUF_writeCTable error");
-        goto _cleanup;
-    }
-    dstBuffer = (char*)dstBuffer + errorCode;
-    maxDstSize -= errorCode;
-    eSize += errorCode;
-
-    errorCode = FSE_writeNCount(dstBuffer, maxDstSize, offcodeNCount, OFFCODE_MAX, Offlog);
-    if (FSE_isError(errorCode)) {
-        eSize = ERROR(GENERIC);
-        DISPLAYLEVEL(1, "FSE_writeNCount error with offcodeNCount");
-        goto _cleanup;
-    }
-    dstBuffer = (char*)dstBuffer + errorCode;
-    maxDstSize -= errorCode;
-    eSize += errorCode;
-
-    errorCode = FSE_writeNCount(dstBuffer, maxDstSize, matchLengthNCount, MaxML, mlLog);
-    if (FSE_isError(errorCode)) {
-        eSize = ERROR(GENERIC);
-        DISPLAYLEVEL(1, "FSE_writeNCount error with matchLengthNCount");
-        goto _cleanup;
-    }
-    dstBuffer = (char*)dstBuffer + errorCode;
-    maxDstSize -= errorCode;
-    eSize += errorCode;
-
-    errorCode = FSE_writeNCount(dstBuffer, maxDstSize, litLengthNCount, MaxLL, llLog);
-    if (FSE_isError(errorCode)) {
-        eSize = ERROR(GENERIC);
-        DISPLAYLEVEL(1, "FSE_writeNCount error with litlengthNCount");
-        goto _cleanup;
-    }
-    dstBuffer = (char*)dstBuffer + errorCode;
-    maxDstSize -= errorCode;
-    eSize += errorCode;
-
-_cleanup:
-    ZSTD_freeCCtx(esr.ref);
-    ZSTD_freeCCtx(esr.zc);
-    free(esr.workPlace);
-
-    return eSize;
-}
-
-
-#define DIB_FASTSEGMENTSIZE 64
-/*! ZDICT_fastSampling()  (based on an idea proposed by Giuseppe Ottaviano) :
-    Fill `dictBuffer` with stripes of size DIB_FASTSEGMENTSIZE from `samplesBuffer`,
-    up to `dictSize`.
-    Filling starts from the end of `dictBuffer`, down to maximum possible.
-    if `dictSize` is not a multiply of DIB_FASTSEGMENTSIZE, some bytes at beginning of `dictBuffer` won't be used.
-    @return : amount of data written into `dictBuffer`,
-              or an error code
-*/
-static size_t ZDICT_fastSampling(void* dictBuffer, size_t dictSize,
-                         const void* samplesBuffer, size_t samplesSize)
-{
-    char* dstPtr = (char*)dictBuffer + dictSize;
-    const char* srcPtr = (const char*)samplesBuffer;
-    size_t nbSegments = dictSize / DIB_FASTSEGMENTSIZE;
-    size_t segNb, interSize;
-
-    if (nbSegments <= 2) return ERROR(srcSize_wrong);
-    if (samplesSize < dictSize) return ERROR(srcSize_wrong);
-
-    /* first and last segments are part of dictionary, in case they contain interesting header/footer */
-    dstPtr -= DIB_FASTSEGMENTSIZE;
-    memcpy(dstPtr, srcPtr, DIB_FASTSEGMENTSIZE);
-    dstPtr -= DIB_FASTSEGMENTSIZE;
-    memcpy(dstPtr, srcPtr+samplesSize-DIB_FASTSEGMENTSIZE, DIB_FASTSEGMENTSIZE);
-
-    /* regularly copy a segment */
-    interSize = (samplesSize - nbSegments*DIB_FASTSEGMENTSIZE) / (nbSegments-1);
-    srcPtr += DIB_FASTSEGMENTSIZE;
-    for (segNb=2; segNb < nbSegments; segNb++) {
-        srcPtr += interSize;
-        dstPtr -= DIB_FASTSEGMENTSIZE;
-        memcpy(dstPtr, srcPtr, DIB_FASTSEGMENTSIZE);
-        srcPtr += DIB_FASTSEGMENTSIZE;
-    }
-
-    return nbSegments * DIB_FASTSEGMENTSIZE;
-}
-
-
-#define DIB_MINSAMPLESSIZE (DIB_FASTSEGMENTSIZE*3)
-/*! ZDICT_trainFromBuffer_unsafe() :
-*   `samplesBuffer` must be followed by noisy guard band.
-*   @return : size of dictionary.
-*/
-size_t ZDICT_trainFromBuffer_unsafe(
-                            void* dictBuffer, size_t maxDictSize,
-                            const void* samplesBuffer, const size_t* sampleSizes, unsigned nbSamples,
-                            ZDICT_params_t params)
-{
-    U32 const dictListSize = MAX( MAX(DICTLISTSIZE, nbSamples), (U32)(maxDictSize/16));
-    dictItem* dictList = (dictItem*)malloc(dictListSize * sizeof(*dictList));
-    unsigned selectivity = params.selectivityLevel;
-    unsigned compressionLevel = params.compressionLevel;
-    size_t targetDictSize = maxDictSize;
-    size_t sBuffSize;
-    size_t dictSize = 0;
-
-    /* checks */
+#include "zstd_internal.h" 
+#include "divsufsort.h" 
+#include "zdict_static.h" 
+ 
+ 
+ 
+/*-************************************* 
+*  Constants 
+***************************************/ 
+#define KB *(1 <<10) 
+#define MB *(1 <<20) 
+#define GB *(1U<<30) 
+ 
+#define DICTLISTSIZE 10000 
+ 
+#define NOISELENGTH 32 
+#define PRIME1   2654435761U 
+#define PRIME2   2246822519U 
+ 
+#define MINRATIO 4 
+static const U32 g_compressionLevel_default = 5; 
+static const U32 g_selectivity_default = 9; 
+static const size_t g_provision_entropySize = 200; 
+static const size_t g_min_fast_dictContent = 192; 
+ 
+ 
+/*-************************************* 
+*  Console display 
+***************************************/ 
+#define DISPLAY(...)         fprintf(stderr, __VA_ARGS__) 
+#define DISPLAYLEVEL(l, ...) if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); } 
+static unsigned g_displayLevel = 0;   /* 0 : no display;   1: errors;   2: default;  4: full information */ 
+ 
+#define DISPLAYUPDATE(l, ...) if (g_displayLevel>=l) { \ 
+            if (ZDICT_GetMilliSpan(g_time) > refreshRate)  \ 
+            { g_time = clock(); DISPLAY(__VA_ARGS__); \ 
+            if (g_displayLevel>=4) fflush(stdout); } } 
+static const unsigned refreshRate = 300; 
+static clock_t g_time = 0; 
+ 
+static void ZDICT_printHex(U32 dlevel, const void* ptr, size_t length) 
+{ 
+    const BYTE* const b = (const BYTE*)ptr; 
+    size_t u; 
+    for (u=0; u<length; u++) 
+    { 
+        BYTE c = b[u]; 
+        if (c<32 || c>126) c = '.';   /* non-printable char */ 
+        DISPLAYLEVEL(dlevel, "%c", c); 
+    } 
+} 
+ 
+ 
+/*-******************************************************** 
+*  Helper functions 
+**********************************************************/ 
+static unsigned ZDICT_GetMilliSpan(clock_t nPrevious) 
+{ 
+    clock_t nCurrent = clock(); 
+    unsigned nSpan = (unsigned)(((nCurrent - nPrevious) * 1000) / CLOCKS_PER_SEC); 
+    return nSpan; 
+} 
+ 
+unsigned ZDICT_isError(size_t errorCode) { return ERR_isError(errorCode); } 
+ 
+const char* ZDICT_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); } 
+ 
+ 
+/*-******************************************************** 
+*  Dictionary training functions 
+**********************************************************/ 
+static unsigned ZDICT_NbCommonBytes (register size_t val) 
+{ 
+    if (MEM_isLittleEndian()) { 
+        if (MEM_64bits()) { 
+#       if defined(_MSC_VER) && defined(_WIN64) 
+            unsigned long r = 0; 
+            _BitScanForward64( &r, (U64)val ); 
+            return (unsigned)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) 
+            return (__builtin_ctzll((U64)val) >> 3); 
+#       else 
+            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 }; 
+            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58]; 
+#       endif 
+        } else { /* 32 bits */ 
+#       if defined(_MSC_VER) 
+            unsigned long r=0; 
+            _BitScanForward( &r, (U32)val ); 
+            return (unsigned)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) 
+            return (__builtin_ctz((U32)val) >> 3); 
+#       else 
+            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 }; 
+            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27]; 
+#       endif 
+        } 
+    } else {  /* Big Endian CPU */ 
+        if (MEM_64bits()) { 
+#       if defined(_MSC_VER) && defined(_WIN64) 
+            unsigned long r = 0; 
+            _BitScanReverse64( &r, val ); 
+            return (unsigned)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) 
+            return (__builtin_clzll(val) >> 3); 
+#       else 
+            unsigned r; 
+            const unsigned n32 = sizeof(size_t)*4;   /* calculate this way due to compiler complaining in 32-bits mode */ 
+            if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; } 
+            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; } 
+            r += (!val); 
+            return r; 
+#       endif 
+        } else { /* 32 bits */ 
+#       if defined(_MSC_VER) 
+            unsigned long r = 0; 
+            _BitScanReverse( &r, (unsigned long)val ); 
+            return (unsigned)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) 
+            return (__builtin_clz((U32)val) >> 3); 
+#       else 
+            unsigned r; 
+            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; } 
+            r += (!val); 
+            return r; 
+#       endif 
+    }   } 
+} 
+ 
+ 
+/*! ZDICT_count() : 
+    Count the nb of common bytes between 2 pointers. 
+    Note : this function presumes end of buffer followed by noisy guard band. 
+*/ 
+static size_t ZDICT_count(const void* pIn, const void* pMatch) 
+{ 
+    const char* const pStart = (const char*)pIn; 
+    for (;;) { 
+        size_t diff = MEM_readST(pMatch) ^ MEM_readST(pIn); 
+        if (!diff) { pIn = (const char*)pIn+sizeof(size_t); pMatch = (const char*)pMatch+sizeof(size_t); continue; } 
+        pIn = (const char*)pIn+ZDICT_NbCommonBytes(diff); 
+        return (size_t)((const char*)pIn - pStart); 
+    } 
+} 
+ 
+ 
+typedef struct { 
+    U32 pos; 
+    U32 length; 
+    U32 savings; 
+} dictItem; 
+ 
+static void ZDICT_initDictItem(dictItem* d) 
+{ 
+    d->pos = 1; 
+    d->length = 0; 
+    d->savings = (U32)(-1); 
+} 
+ 
+ 
+#define LLIMIT 64          /* heuristic determined experimentally */ 
+#define MINMATCHLENGTH 7   /* heuristic determined experimentally */ 
+static dictItem ZDICT_analyzePos( 
+                       BYTE* doneMarks, 
+                       const int* suffix, U32 start, 
+                       const void* buffer, U32 minRatio) 
+{ 
+    U32 lengthList[LLIMIT] = {0}; 
+    U32 cumulLength[LLIMIT] = {0}; 
+    U32 savings[LLIMIT] = {0}; 
+    const BYTE* b = (const BYTE*)buffer; 
+    size_t length; 
+    size_t maxLength = LLIMIT; 
+    size_t pos = suffix[start]; 
+    U32 end = start; 
+    dictItem solution; 
+ 
+    /* init */ 
+    memset(&solution, 0, sizeof(solution)); 
+    doneMarks[pos] = 1; 
+ 
+    /* trivial repetition cases */ 
+    if ( (MEM_read16(b+pos+0) == MEM_read16(b+pos+2)) 
+       ||(MEM_read16(b+pos+1) == MEM_read16(b+pos+3)) 
+       ||(MEM_read16(b+pos+2) == MEM_read16(b+pos+4)) ) { 
+        /* skip and mark segment */ 
+        U16 u16 = MEM_read16(b+pos+4); 
+        U32 u, e = 6; 
+        while (MEM_read16(b+pos+e) == u16) e+=2 ; 
+        if (b[pos+e] == b[pos+e-1]) e++; 
+        for (u=1; u<e; u++) 
+            doneMarks[pos+u] = 1; 
+        return solution; 
+    } 
+ 
+    /* look forward */ 
+    do { 
+        end++; 
+        length = ZDICT_count(b + pos, b + suffix[end]); 
+    } while (length >=MINMATCHLENGTH); 
+ 
+    /* look backward */ 
+    do { 
+        length = ZDICT_count(b + pos, b + *(suffix+start-1)); 
+        if (length >=MINMATCHLENGTH) start--; 
+    } while(length >= MINMATCHLENGTH); 
+ 
+    /* exit if not found a minimum nb of repetitions */ 
+    if (end-start < minRatio) { 
+        U32 idx; 
+        for(idx=start; idx<end; idx++) 
+            doneMarks[suffix[idx]] = 1; 
+        return solution; 
+    } 
+ 
+    {   int i; 
+        U32 searchLength; 
+        U32 refinedStart = start; 
+        U32 refinedEnd = end; 
+ 
+        DISPLAYLEVEL(4, "\n"); 
+        DISPLAYLEVEL(4, "found %3u matches of length >= %u at pos %7u  ", (U32)(end-start), MINMATCHLENGTH, (U32)pos); 
+        DISPLAYLEVEL(4, "\n"); 
+ 
+        for (searchLength = MINMATCHLENGTH ; ; searchLength++) { 
+            BYTE currentChar = 0; 
+            U32 currentCount = 0; 
+            U32 currentID = refinedStart; 
+            U32 id; 
+            U32 selectedCount = 0; 
+            U32 selectedID = currentID; 
+            for (id =refinedStart; id < refinedEnd; id++) { 
+                if (b[ suffix[id] + searchLength] != currentChar) { 
+                    if (currentCount > selectedCount) { 
+                        selectedCount = currentCount; 
+                        selectedID = currentID; 
+                    } 
+                    currentID = id; 
+                    currentChar = b[ suffix[id] + searchLength]; 
+                    currentCount = 0; 
+                } 
+                currentCount ++; 
+            } 
+            if (currentCount > selectedCount) {  /* for last */ 
+                selectedCount = currentCount; 
+                selectedID = currentID; 
+            } 
+ 
+            if (selectedCount < minRatio) 
+                break; 
+            refinedStart = selectedID; 
+            refinedEnd = refinedStart + selectedCount; 
+        } 
+ 
+        /* evaluate gain based on new ref */ 
+        start = refinedStart; 
+        pos = suffix[refinedStart]; 
+        end = start; 
+        memset(lengthList, 0, sizeof(lengthList)); 
+ 
+        /* look forward */ 
+        do { 
+            end++; 
+            length = ZDICT_count(b + pos, b + suffix[end]); 
+            if (length >= LLIMIT) length = LLIMIT-1; 
+            lengthList[length]++; 
+        } while (length >=MINMATCHLENGTH); 
+ 
+        /* look backward */ 
+        do { 
+            length = ZDICT_count(b + pos, b + suffix[start-1]); 
+            if (length >= LLIMIT) length = LLIMIT-1; 
+            lengthList[length]++; 
+            if (length >=MINMATCHLENGTH) start--; 
+        } while(length >= MINMATCHLENGTH); 
+ 
+        /* largest useful length */ 
+        memset(cumulLength, 0, sizeof(cumulLength)); 
+        cumulLength[maxLength-1] = lengthList[maxLength-1]; 
+        for (i=(int)(maxLength-2); i>=0; i--) 
+            cumulLength[i] = cumulLength[i+1] + lengthList[i]; 
+ 
+        for (i=LLIMIT-1; i>=MINMATCHLENGTH; i--) if (cumulLength[i]>=minRatio) break; 
+        maxLength = i; 
+ 
+        /* reduce maxLength in case of final into repetitive data */ 
+        { 
+            U32 l = (U32)maxLength; 
+            BYTE c = b[pos + maxLength-1]; 
+            while (b[pos+l-2]==c) l--; 
+            maxLength = l; 
+        } 
+        if (maxLength < MINMATCHLENGTH) return solution;   /* skip : no long-enough solution */ 
+ 
+        /* calculate savings */ 
+        savings[5] = 0; 
+        for (i=MINMATCHLENGTH; i<=(int)maxLength; i++) 
+            savings[i] = savings[i-1] + (lengthList[i] * (i-3)); 
+ 
+        DISPLAYLEVEL(4, "Selected ref at position %u, of length %u : saves %u (ratio: %.2f)  \n", 
+                     (U32)pos, (U32)maxLength, savings[maxLength], (double)savings[maxLength] / maxLength); 
+ 
+        solution.pos = (U32)pos; 
+        solution.length = (U32)maxLength; 
+        solution.savings = savings[maxLength]; 
+ 
+        /* mark positions done */ 
+        { 
+            U32 id; 
+            U32 testedPos; 
+            for (id=start; id<end; id++) { 
+                U32 p, pEnd; 
+                testedPos = suffix[id]; 
+                if (testedPos == pos) 
+                    length = solution.length; 
+                else { 
+                    length = ZDICT_count(b+pos, b+testedPos); 
+                    if (length > solution.length) length = solution.length; 
+                } 
+                pEnd = (U32)(testedPos + length); 
+                for (p=testedPos; p<pEnd; p++) 
+                    doneMarks[p] = 1; 
+    }   }   } 
+ 
+    return solution; 
+} 
+ 
+ 
+/*! ZDICT_checkMerge 
+    check if dictItem can be merged, do it if possible 
+    @return : id of destination elt, 0 if not merged 
+*/ 
+static U32 ZDICT_checkMerge(dictItem* table, dictItem elt, U32 eltNbToSkip) 
+{ 
+    const U32 tableSize = table->pos; 
+    const U32 max = elt.pos + (elt.length-1); 
+ 
+    /* tail overlap */ 
+    U32 u; for (u=1; u<tableSize; u++) { 
+        if (u==eltNbToSkip) continue; 
+        if ((table[u].pos > elt.pos) && (table[u].pos < max)) {  /* overlap */ 
+            /* append */ 
+            U32 addedLength = table[u].pos - elt.pos; 
+            table[u].length += addedLength; 
+            table[u].pos = elt.pos; 
+            table[u].savings += elt.savings * addedLength / elt.length;   /* rough approx */ 
+            table[u].savings += elt.length / 8;    /* rough approx */ 
+            elt = table[u]; 
+            while ((u>1) && (table[u-1].savings < elt.savings)) 
+                table[u] = table[u-1], u--; 
+            table[u] = elt; 
+            return u; 
+    }   } 
+ 
+    /* front overlap */ 
+    for (u=1; u<tableSize; u++) { 
+        if (u==eltNbToSkip) continue; 
+        if ((table[u].pos + table[u].length > elt.pos) && (table[u].pos < elt.pos)) {  /* overlap */ 
+            /* append */ 
+            int addedLength = (elt.pos + elt.length) - (table[u].pos + table[u].length); 
+            table[u].savings += elt.length / 8;    /* rough approx */ 
+            if (addedLength > 0) {   /* otherwise, already included */ 
+                table[u].length += addedLength; 
+                table[u].savings += elt.savings * addedLength / elt.length;   /* rough approx */ 
+            } 
+            elt = table[u]; 
+            while ((u>1) && (table[u-1].savings < elt.savings)) 
+                table[u] = table[u-1], u--; 
+            table[u] = elt; 
+            return u; 
+    }   } 
+ 
+    return 0; 
+} 
+ 
+ 
+static void ZDICT_removeDictItem(dictItem* table, U32 id) 
+{ 
+    /* convention : first element is nb of elts */ 
+    U32 max = table->pos; 
+    U32 u; 
+    if (!id) return;   /* protection, should never happen */ 
+    for (u=id; u<max-1; u++) 
+        table[u] = table[u+1]; 
+    table->pos--; 
+} 
+ 
+ 
+static void ZDICT_insertDictItem(dictItem* table, U32 maxSize, dictItem elt) 
+{ 
+    /* merge if possible */ 
+    U32 mergeId = ZDICT_checkMerge(table, elt, 0); 
+    if (mergeId) { 
+        U32 newMerge = 1; 
+        while (newMerge) { 
+            newMerge = ZDICT_checkMerge(table, table[mergeId], mergeId); 
+            if (newMerge) ZDICT_removeDictItem(table, mergeId); 
+            mergeId = newMerge; 
+        } 
+        return; 
+    } 
+ 
+    /* insert */ 
+    { 
+        U32 current; 
+        U32 nextElt = table->pos; 
+        if (nextElt >= maxSize) nextElt = maxSize-1; 
+        current = nextElt-1; 
+        while (table[current].savings < elt.savings) { 
+            table[current+1] = table[current]; 
+            current--; 
+        } 
+        table[current+1] = elt; 
+        table->pos = nextElt+1; 
+    } 
+} 
+ 
+ 
+static U32 ZDICT_dictSize(const dictItem* dictList) 
+{ 
+    U32 u, dictSize = 0; 
+    for (u=1; u<dictList[0].pos; u++) 
+        dictSize += dictList[u].length; 
+    return dictSize; 
+} 
+ 
+ 
+static size_t ZDICT_trainBuffer(dictItem* dictList, U32 dictListSize, 
+                            const void* const buffer, const size_t bufferSize,   /* buffer must end with noisy guard band */ 
+                            const size_t* fileSizes, unsigned nbFiles, 
+                            U32 shiftRatio, unsigned maxDictSize) 
+{ 
+    int* const suffix0 = (int*)malloc((bufferSize+2)*sizeof(*suffix0)); 
+    int* const suffix = suffix0+1; 
+    U32* reverseSuffix = (U32*)malloc((bufferSize)*sizeof(*reverseSuffix)); 
+    BYTE* doneMarks = (BYTE*)malloc((bufferSize+16)*sizeof(*doneMarks));   /* +16 for overflow security */ 
+    U32* filePos = (U32*)malloc(nbFiles * sizeof(*filePos)); 
+    U32 minRatio = nbFiles >> shiftRatio; 
+    int divSuftSortResult; 
+    size_t result = 0; 
+ 
+    /* init */ 
+    DISPLAYLEVEL(2, "\r%70s\r", "");   /* clean display line */ 
+    if (!suffix0 || !reverseSuffix || !doneMarks || !filePos) { 
+        result = ERROR(memory_allocation); 
+        goto _cleanup; 
+    } 
+    if (minRatio < MINRATIO) minRatio = MINRATIO; 
+    memset(doneMarks, 0, bufferSize+16); 
+ 
+    /* sort */ 
+    DISPLAYLEVEL(2, "sorting %u files of total size %u MB ...\n", nbFiles, (U32)(bufferSize>>20)); 
+    divSuftSortResult = divsufsort((const unsigned char*)buffer, suffix, (int)bufferSize, 0); 
+    if (divSuftSortResult != 0) { result = ERROR(GENERIC); goto _cleanup; } 
+    suffix[bufferSize] = (int)bufferSize;   /* leads into noise */ 
+    suffix0[0] = (int)bufferSize;           /* leads into noise */ 
+    { 
+        /* build reverse suffix sort */ 
+        size_t pos; 
+        for (pos=0; pos < bufferSize; pos++) 
+            reverseSuffix[suffix[pos]] = (U32)pos; 
+        /* build file pos */ 
+        filePos[0] = 0; 
+        for (pos=1; pos<nbFiles; pos++) 
+            filePos[pos] = (U32)(filePos[pos-1] + fileSizes[pos-1]); 
+    } 
+ 
+    DISPLAYLEVEL(2, "finding patterns ... \n"); 
+    DISPLAYLEVEL(3, "minimum ratio : %u \n", minRatio); 
+ 
+    { 
+        U32 cursor; for (cursor=0; cursor < bufferSize; ) { 
+            dictItem solution; 
+            if (doneMarks[cursor]) { cursor++; continue; } 
+            solution = ZDICT_analyzePos(doneMarks, suffix, reverseSuffix[cursor], buffer, minRatio); 
+            if (solution.length==0) { cursor++; continue; } 
+            ZDICT_insertDictItem(dictList, dictListSize, solution); 
+            cursor += solution.length; 
+            DISPLAYUPDATE(2, "\r%4.2f %% \r", (double)cursor / bufferSize * 100); 
+    }   } 
+ 
+    /* limit dictionary size */ 
+    { 
+        U32 max = dictList->pos;   /* convention : nb of useful elts within dictList */ 
+        U32 currentSize = 0; 
+        U32 n; for (n=1; n<max; n++) { 
+            currentSize += dictList[n].length; 
+            if (currentSize > maxDictSize) break; 
+        } 
+        dictList->pos = n; 
+    } 
+ 
+_cleanup: 
+    free(suffix0); 
+    free(reverseSuffix); 
+    free(doneMarks); 
+    free(filePos); 
+    return result; 
+} 
+ 
+ 
+static void ZDICT_fillNoise(void* buffer, size_t length) 
+{ 
+    unsigned acc = PRIME1; 
+    size_t p=0;; 
+    for (p=0; p<length; p++) { 
+        acc *= PRIME2; 
+        ((unsigned char*)buffer)[p] = (unsigned char)(acc >> 21); 
+    } 
+} 
+ 
+ 
+typedef struct 
+{ 
+    ZSTD_CCtx* ref; 
+    ZSTD_CCtx* zc; 
+    void* workPlace;   /* must be ZSTD_BLOCKSIZE_MAX allocated */ 
+} EStats_ress_t; 
+ 
+ 
+static void ZDICT_countEStats(EStats_ress_t esr, 
+                            U32* countLit, U32* offsetcodeCount, U32* matchlengthCount, U32* litlengthCount, 
+                            const void* src, size_t srcSize) 
+{ 
+    const seqStore_t* seqStorePtr; 
+ 
+    if (srcSize > ZSTD_BLOCKSIZE_MAX) srcSize = ZSTD_BLOCKSIZE_MAX;   /* protection vs large samples */ 
+    ZSTD_copyCCtx(esr.zc, esr.ref); 
+    ZSTD_compressBlock(esr.zc, esr.workPlace, ZSTD_BLOCKSIZE_MAX, src, srcSize); 
+    seqStorePtr = ZSTD_getSeqStore(esr.zc); 
+ 
+    /* literals stats */ 
+    {   const BYTE* bytePtr; 
+        for(bytePtr = seqStorePtr->litStart; bytePtr < seqStorePtr->lit; bytePtr++) 
+            countLit[*bytePtr]++; 
+    } 
+ 
+    /* seqStats */ 
+    {   size_t const nbSeq = (size_t)(seqStorePtr->offset - seqStorePtr->offsetStart); 
+        ZSTD_seqToCodes(seqStorePtr, nbSeq); 
+ 
+        {   const BYTE* codePtr = seqStorePtr->offCodeStart; 
+            size_t u; 
+            for (u=0; u<nbSeq; u++) offsetcodeCount[codePtr[u]]++; 
+        } 
+ 
+        {   const BYTE* codePtr = seqStorePtr->mlCodeStart; 
+            size_t u; 
+            for (u=0; u<nbSeq; u++) matchlengthCount[codePtr[u]]++; 
+        } 
+ 
+        {   const BYTE* codePtr = seqStorePtr->llCodeStart; 
+            size_t u; 
+            for (u=0; u<nbSeq; u++) litlengthCount[codePtr[u]]++; 
+    }   } 
+} 
+ 
+/* 
+static size_t ZDICT_maxSampleSize(const size_t* fileSizes, unsigned nbFiles) 
+{ 
+    unsigned u; 
+    size_t max=0; 
+    for (u=0; u<nbFiles; u++) 
+        if (max < fileSizes[u]) max = fileSizes[u]; 
+    return max; 
+} 
+*/ 
+ 
+static size_t ZDICT_totalSampleSize(const size_t* fileSizes, unsigned nbFiles) 
+{ 
+    size_t total; 
+    unsigned u; 
+    for (u=0, total=0; u<nbFiles; u++) total += fileSizes[u]; 
+    return total; 
+} 
+ 
+#define OFFCODE_MAX 18  /* only applicable to first block */ 
+static size_t ZDICT_analyzeEntropy(void*  dstBuffer, size_t maxDstSize, 
+                                 unsigned compressionLevel, 
+                           const void*  srcBuffer, const size_t* fileSizes, unsigned nbFiles, 
+                           const void* dictBuffer, size_t  dictBufferSize) 
+{ 
+    U32 countLit[256]; 
+    HUF_CREATE_STATIC_CTABLE(hufTable, 255); 
+    U32 offcodeCount[OFFCODE_MAX+1]; 
+    short offcodeNCount[OFFCODE_MAX+1]; 
+    U32 matchLengthCount[MaxML+1]; 
+    short matchLengthNCount[MaxML+1]; 
+    U32 litLengthCount[MaxLL+1]; 
+    short litLengthNCount[MaxLL+1]; 
+    EStats_ress_t esr; 
+    ZSTD_parameters params; 
+    U32 u, huffLog = 12, Offlog = OffFSELog, mlLog = MLFSELog, llLog = LLFSELog, total; 
+    size_t pos = 0, errorCode; 
+    size_t eSize = 0; 
+    size_t const totalSrcSize = ZDICT_totalSampleSize(fileSizes, nbFiles); 
+    size_t const averageSampleSize = totalSrcSize / nbFiles; 
+ 
+    /* init */ 
+    for (u=0; u<256; u++) countLit[u]=1;   /* any character must be described */ 
+    for (u=0; u<=OFFCODE_MAX; u++) offcodeCount[u]=1; 
+    for (u=0; u<=MaxML; u++) matchLengthCount[u]=1; 
+    for (u=0; u<=MaxLL; u++) litLengthCount[u]=1; 
+    esr.ref = ZSTD_createCCtx(); 
+    esr.zc = ZSTD_createCCtx(); 
+    esr.workPlace = malloc(ZSTD_BLOCKSIZE_MAX); 
+    if (!esr.ref || !esr.zc || !esr.workPlace) { 
+            eSize = ERROR(memory_allocation); 
+            DISPLAYLEVEL(1, "Not enough memory"); 
+            goto _cleanup; 
+    } 
+    if (compressionLevel==0) compressionLevel=g_compressionLevel_default; 
+    params.cParams = ZSTD_getCParams(compressionLevel, averageSampleSize, dictBufferSize); 
+    params.cParams.strategy = ZSTD_greedy; 
+    params.fParams.contentSizeFlag = 0; 
+    ZSTD_compressBegin_advanced(esr.ref, dictBuffer, dictBufferSize, params, 0); 
+ 
+    /* collect stats on all files */ 
+    for (u=0; u<nbFiles; u++) { 
+        ZDICT_countEStats(esr, 
+                        countLit, offcodeCount, matchLengthCount, litLengthCount, 
+           (const char*)srcBuffer + pos, fileSizes[u]); 
+        pos += fileSizes[u]; 
+    } 
+ 
+    /* analyze */ 
+    errorCode = HUF_buildCTable (hufTable, countLit, 255, huffLog); 
+    if (HUF_isError(errorCode)) { 
+        eSize = ERROR(GENERIC); 
+        DISPLAYLEVEL(1, "HUF_buildCTable error"); 
+        goto _cleanup; 
+    } 
+    huffLog = (U32)errorCode; 
+ 
+    total=0; for (u=0; u<=OFFCODE_MAX; u++) total+=offcodeCount[u]; 
+    errorCode = FSE_normalizeCount(offcodeNCount, Offlog, offcodeCount, total, OFFCODE_MAX); 
+    if (FSE_isError(errorCode)) { 
+        eSize = ERROR(GENERIC); 
+        DISPLAYLEVEL(1, "FSE_normalizeCount error with offcodeCount"); 
+        goto _cleanup; 
+    } 
+    Offlog = (U32)errorCode; 
+ 
+    total=0; for (u=0; u<=MaxML; u++) total+=matchLengthCount[u]; 
+    errorCode = FSE_normalizeCount(matchLengthNCount, mlLog, matchLengthCount, total, MaxML); 
+    if (FSE_isError(errorCode)) { 
+        eSize = ERROR(GENERIC); 
+        DISPLAYLEVEL(1, "FSE_normalizeCount error with matchLengthCount"); 
+        goto _cleanup; 
+    } 
+    mlLog = (U32)errorCode; 
+ 
+    total=0; for (u=0; u<=MaxLL; u++) total+=litLengthCount[u]; 
+    errorCode = FSE_normalizeCount(litLengthNCount, llLog, litLengthCount, total, MaxLL); 
+    if (FSE_isError(errorCode)) { 
+        eSize = ERROR(GENERIC); 
+        DISPLAYLEVEL(1, "FSE_normalizeCount error with litLengthCount"); 
+        goto _cleanup; 
+    } 
+    llLog = (U32)errorCode; 
+ 
+    /* write result to buffer */ 
+    errorCode = HUF_writeCTable(dstBuffer, maxDstSize, hufTable, 255, huffLog); 
+    if (HUF_isError(errorCode)) { 
+        eSize = ERROR(GENERIC); 
+        DISPLAYLEVEL(1, "HUF_writeCTable error"); 
+        goto _cleanup; 
+    } 
+    dstBuffer = (char*)dstBuffer + errorCode; 
+    maxDstSize -= errorCode; 
+    eSize += errorCode; 
+ 
+    errorCode = FSE_writeNCount(dstBuffer, maxDstSize, offcodeNCount, OFFCODE_MAX, Offlog); 
+    if (FSE_isError(errorCode)) { 
+        eSize = ERROR(GENERIC); 
+        DISPLAYLEVEL(1, "FSE_writeNCount error with offcodeNCount"); 
+        goto _cleanup; 
+    } 
+    dstBuffer = (char*)dstBuffer + errorCode; 
+    maxDstSize -= errorCode; 
+    eSize += errorCode; 
+ 
+    errorCode = FSE_writeNCount(dstBuffer, maxDstSize, matchLengthNCount, MaxML, mlLog); 
+    if (FSE_isError(errorCode)) { 
+        eSize = ERROR(GENERIC); 
+        DISPLAYLEVEL(1, "FSE_writeNCount error with matchLengthNCount"); 
+        goto _cleanup; 
+    } 
+    dstBuffer = (char*)dstBuffer + errorCode; 
+    maxDstSize -= errorCode; 
+    eSize += errorCode; 
+ 
+    errorCode = FSE_writeNCount(dstBuffer, maxDstSize, litLengthNCount, MaxLL, llLog); 
+    if (FSE_isError(errorCode)) { 
+        eSize = ERROR(GENERIC); 
+        DISPLAYLEVEL(1, "FSE_writeNCount error with litlengthNCount"); 
+        goto _cleanup; 
+    } 
+    dstBuffer = (char*)dstBuffer + errorCode; 
+    maxDstSize -= errorCode; 
+    eSize += errorCode; 
+ 
+_cleanup: 
+    ZSTD_freeCCtx(esr.ref); 
+    ZSTD_freeCCtx(esr.zc); 
+    free(esr.workPlace); 
+ 
+    return eSize; 
+} 
+ 
+ 
+#define DIB_FASTSEGMENTSIZE 64 
+/*! ZDICT_fastSampling()  (based on an idea proposed by Giuseppe Ottaviano) : 
+    Fill `dictBuffer` with stripes of size DIB_FASTSEGMENTSIZE from `samplesBuffer`, 
+    up to `dictSize`. 
+    Filling starts from the end of `dictBuffer`, down to maximum possible. 
+    if `dictSize` is not a multiply of DIB_FASTSEGMENTSIZE, some bytes at beginning of `dictBuffer` won't be used. 
+    @return : amount of data written into `dictBuffer`, 
+              or an error code 
+*/ 
+static size_t ZDICT_fastSampling(void* dictBuffer, size_t dictSize, 
+                         const void* samplesBuffer, size_t samplesSize) 
+{ 
+    char* dstPtr = (char*)dictBuffer + dictSize; 
+    const char* srcPtr = (const char*)samplesBuffer; 
+    size_t nbSegments = dictSize / DIB_FASTSEGMENTSIZE; 
+    size_t segNb, interSize; 
+ 
+    if (nbSegments <= 2) return ERROR(srcSize_wrong); 
+    if (samplesSize < dictSize) return ERROR(srcSize_wrong); 
+ 
+    /* first and last segments are part of dictionary, in case they contain interesting header/footer */ 
+    dstPtr -= DIB_FASTSEGMENTSIZE; 
+    memcpy(dstPtr, srcPtr, DIB_FASTSEGMENTSIZE); 
+    dstPtr -= DIB_FASTSEGMENTSIZE; 
+    memcpy(dstPtr, srcPtr+samplesSize-DIB_FASTSEGMENTSIZE, DIB_FASTSEGMENTSIZE); 
+ 
+    /* regularly copy a segment */ 
+    interSize = (samplesSize - nbSegments*DIB_FASTSEGMENTSIZE) / (nbSegments-1); 
+    srcPtr += DIB_FASTSEGMENTSIZE; 
+    for (segNb=2; segNb < nbSegments; segNb++) { 
+        srcPtr += interSize; 
+        dstPtr -= DIB_FASTSEGMENTSIZE; 
+        memcpy(dstPtr, srcPtr, DIB_FASTSEGMENTSIZE); 
+        srcPtr += DIB_FASTSEGMENTSIZE; 
+    } 
+ 
+    return nbSegments * DIB_FASTSEGMENTSIZE; 
+} 
+ 
+ 
+#define DIB_MINSAMPLESSIZE (DIB_FASTSEGMENTSIZE*3) 
+/*! ZDICT_trainFromBuffer_unsafe() : 
+*   `samplesBuffer` must be followed by noisy guard band. 
+*   @return : size of dictionary. 
+*/ 
+size_t ZDICT_trainFromBuffer_unsafe( 
+                            void* dictBuffer, size_t maxDictSize, 
+                            const void* samplesBuffer, const size_t* sampleSizes, unsigned nbSamples, 
+                            ZDICT_params_t params) 
+{ 
+    U32 const dictListSize = MAX( MAX(DICTLISTSIZE, nbSamples), (U32)(maxDictSize/16)); 
+    dictItem* dictList = (dictItem*)malloc(dictListSize * sizeof(*dictList)); 
+    unsigned selectivity = params.selectivityLevel; 
+    unsigned compressionLevel = params.compressionLevel; 
+    size_t targetDictSize = maxDictSize; 
+    size_t sBuffSize; 
+    size_t dictSize = 0; 
+ 
+    /* checks */ 
     if (maxDictSize <= g_provision_entropySize + g_min_fast_dictContent) return ERROR(dstSize_tooSmall);
-    if (!dictList) return ERROR(memory_allocation);
-
-    /* init */
-    { unsigned u; for (u=0, sBuffSize=0; u<nbSamples; u++) sBuffSize += sampleSizes[u]; }
+    if (!dictList) return ERROR(memory_allocation); 
+ 
+    /* init */ 
+    { unsigned u; for (u=0, sBuffSize=0; u<nbSamples; u++) sBuffSize += sampleSizes[u]; } 
     if (sBuffSize < DIB_MINSAMPLESSIZE) return 0;   /* not enough source to create dictionary */
-    ZDICT_initDictItem(dictList);
-    g_displayLevel = params.notificationLevel;
-    if (selectivity==0) selectivity = g_selectivity_default;
-    if (compressionLevel==0) compressionLevel = g_compressionLevel_default;
-
-    /* build dictionary */
-    if (selectivity>1) {  /* selectivity == 1 => fast mode */
-        ZDICT_trainBuffer(dictList, dictListSize,
-                        samplesBuffer, sBuffSize,
-                        sampleSizes, nbSamples,
-                        selectivity, (U32)targetDictSize);
-
-        /* display best matches */
-        if (g_displayLevel>= 3) {
-            U32 const nb = 25;
-            U32 const dictContentSize = ZDICT_dictSize(dictList);
-            U32 u;
-            DISPLAYLEVEL(3, "\n %u segments found, of total size %u \n", dictList[0].pos, dictContentSize);
-            DISPLAYLEVEL(3, "list %u best segments \n", nb);
-            for (u=1; u<=nb; u++) {
-                U32 p = dictList[u].pos;
-                U32 l = dictList[u].length;
-                U32 d = MIN(40, l);
-                DISPLAYLEVEL(3, "%3u:%3u bytes at pos %8u, savings %7u bytes |",
-                             u, l, p, dictList[u].savings);
-                ZDICT_printHex(3, (const char*)samplesBuffer+p, d);
-                DISPLAYLEVEL(3, "| \n");
-    }   }   }
-
-    /* create dictionary */
-    {   U32 dictContentSize = ZDICT_dictSize(dictList);
-        size_t hSize;
-        BYTE* ptr;
-        U32 u;
-
-        /* build dict content */
-        ptr = (BYTE*)dictBuffer + maxDictSize;
-        for (u=1; u<dictList->pos; u++) {
-            U32 l = dictList[u].length;
-            ptr -= l;
+    ZDICT_initDictItem(dictList); 
+    g_displayLevel = params.notificationLevel; 
+    if (selectivity==0) selectivity = g_selectivity_default; 
+    if (compressionLevel==0) compressionLevel = g_compressionLevel_default; 
+ 
+    /* build dictionary */ 
+    if (selectivity>1) {  /* selectivity == 1 => fast mode */ 
+        ZDICT_trainBuffer(dictList, dictListSize, 
+                        samplesBuffer, sBuffSize, 
+                        sampleSizes, nbSamples, 
+                        selectivity, (U32)targetDictSize); 
+ 
+        /* display best matches */ 
+        if (g_displayLevel>= 3) { 
+            U32 const nb = 25; 
+            U32 const dictContentSize = ZDICT_dictSize(dictList); 
+            U32 u; 
+            DISPLAYLEVEL(3, "\n %u segments found, of total size %u \n", dictList[0].pos, dictContentSize); 
+            DISPLAYLEVEL(3, "list %u best segments \n", nb); 
+            for (u=1; u<=nb; u++) { 
+                U32 p = dictList[u].pos; 
+                U32 l = dictList[u].length; 
+                U32 d = MIN(40, l); 
+                DISPLAYLEVEL(3, "%3u:%3u bytes at pos %8u, savings %7u bytes |", 
+                             u, l, p, dictList[u].savings); 
+                ZDICT_printHex(3, (const char*)samplesBuffer+p, d); 
+                DISPLAYLEVEL(3, "| \n"); 
+    }   }   } 
+ 
+    /* create dictionary */ 
+    {   U32 dictContentSize = ZDICT_dictSize(dictList); 
+        size_t hSize; 
+        BYTE* ptr; 
+        U32 u; 
+ 
+        /* build dict content */ 
+        ptr = (BYTE*)dictBuffer + maxDictSize; 
+        for (u=1; u<dictList->pos; u++) { 
+            U32 l = dictList[u].length; 
+            ptr -= l; 
             if (ptr<(BYTE*)dictBuffer) return ERROR(GENERIC);   /* should not happen */
-            memcpy(ptr, (const char*)samplesBuffer+dictList[u].pos, l);
-        }
-
-        /* fast mode dict content */
-        if (selectivity==1) {  /* note could also be used to complete a dictionary, but not necessarily better */
-            DISPLAYLEVEL(3, "\r%70s\r", "");   /* clean display line */
-            DISPLAYLEVEL(3, "Adding %u KB with fast sampling \n", (U32)(targetDictSize>>10));
-            dictContentSize = (U32)ZDICT_fastSampling(dictBuffer, targetDictSize,
-                                                      samplesBuffer, sBuffSize);
-        }
-
-       /* dictionary header */
-        MEM_writeLE32(dictBuffer, ZSTD_DICT_MAGIC);
-        hSize = 4;
-
-        /* entropic tables */
-        DISPLAYLEVEL(2, "\r%70s\r", "");   /* clean display line */
-        DISPLAYLEVEL(2, "statistics ... \n");
-        hSize += ZDICT_analyzeEntropy((char*)dictBuffer+4, maxDictSize-4,
-                                    compressionLevel,
-                                    samplesBuffer, sampleSizes, nbSamples,
-                                    (char*)dictBuffer + maxDictSize - dictContentSize, dictContentSize);
-
-        if (hSize + dictContentSize < maxDictSize)
-            memmove((char*)dictBuffer + hSize, (char*)dictBuffer + maxDictSize - dictContentSize, dictContentSize);
-        dictSize = MIN(maxDictSize, hSize+dictContentSize);
-    }
-
-    /* clean up */
-    free(dictList);
-    return dictSize;
-}
-
-
-/* issue : samplesBuffer need to be followed by a noisy guard band.
-*  work around : duplicate the buffer, and add the noise */
-size_t ZDICT_trainFromBuffer_advanced(void* dictBuffer, size_t dictBufferCapacity,
-                           const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
-                           ZDICT_params_t params)
-{
-    void* newBuff;
-    size_t sBuffSize;
-
-    { unsigned u; for (u=0, sBuffSize=0; u<nbSamples; u++) sBuffSize += samplesSizes[u]; }
-    if (sBuffSize==0) return 0;   /* empty content => no dictionary */
-    newBuff = malloc(sBuffSize + NOISELENGTH);
-    if (!newBuff) return ERROR(memory_allocation);
-
-    memcpy(newBuff, samplesBuffer, sBuffSize);
-    ZDICT_fillNoise((char*)newBuff + sBuffSize, NOISELENGTH);   /* guard band, for end of buffer condition */
-
-    { size_t const result = ZDICT_trainFromBuffer_unsafe(
-                                        dictBuffer, dictBufferCapacity,
-                                        newBuff, samplesSizes, nbSamples,
-                                        params);
-      free(newBuff);
-      return result; }
-}
-
-
-size_t ZDICT_trainFromBuffer(void* dictBuffer, size_t dictBufferCapacity,
-                             const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples)
-{
-    ZDICT_params_t params;
-    memset(&params, 0, sizeof(params));
-    return ZDICT_trainFromBuffer_advanced(dictBuffer, dictBufferCapacity,
-                                          samplesBuffer, samplesSizes, nbSamples,
-                                          params);
-}
-
+            memcpy(ptr, (const char*)samplesBuffer+dictList[u].pos, l); 
+        } 
+ 
+        /* fast mode dict content */ 
+        if (selectivity==1) {  /* note could also be used to complete a dictionary, but not necessarily better */ 
+            DISPLAYLEVEL(3, "\r%70s\r", "");   /* clean display line */ 
+            DISPLAYLEVEL(3, "Adding %u KB with fast sampling \n", (U32)(targetDictSize>>10)); 
+            dictContentSize = (U32)ZDICT_fastSampling(dictBuffer, targetDictSize, 
+                                                      samplesBuffer, sBuffSize); 
+        } 
+ 
+       /* dictionary header */ 
+        MEM_writeLE32(dictBuffer, ZSTD_DICT_MAGIC); 
+        hSize = 4; 
+ 
+        /* entropic tables */ 
+        DISPLAYLEVEL(2, "\r%70s\r", "");   /* clean display line */ 
+        DISPLAYLEVEL(2, "statistics ... \n"); 
+        hSize += ZDICT_analyzeEntropy((char*)dictBuffer+4, maxDictSize-4, 
+                                    compressionLevel, 
+                                    samplesBuffer, sampleSizes, nbSamples, 
+                                    (char*)dictBuffer + maxDictSize - dictContentSize, dictContentSize); 
+ 
+        if (hSize + dictContentSize < maxDictSize) 
+            memmove((char*)dictBuffer + hSize, (char*)dictBuffer + maxDictSize - dictContentSize, dictContentSize); 
+        dictSize = MIN(maxDictSize, hSize+dictContentSize); 
+    } 
+ 
+    /* clean up */ 
+    free(dictList); 
+    return dictSize; 
+} 
+ 
+ 
+/* issue : samplesBuffer need to be followed by a noisy guard band. 
+*  work around : duplicate the buffer, and add the noise */ 
+size_t ZDICT_trainFromBuffer_advanced(void* dictBuffer, size_t dictBufferCapacity, 
+                           const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples, 
+                           ZDICT_params_t params) 
+{ 
+    void* newBuff; 
+    size_t sBuffSize; 
+ 
+    { unsigned u; for (u=0, sBuffSize=0; u<nbSamples; u++) sBuffSize += samplesSizes[u]; } 
+    if (sBuffSize==0) return 0;   /* empty content => no dictionary */ 
+    newBuff = malloc(sBuffSize + NOISELENGTH); 
+    if (!newBuff) return ERROR(memory_allocation); 
+ 
+    memcpy(newBuff, samplesBuffer, sBuffSize); 
+    ZDICT_fillNoise((char*)newBuff + sBuffSize, NOISELENGTH);   /* guard band, for end of buffer condition */ 
+ 
+    { size_t const result = ZDICT_trainFromBuffer_unsafe( 
+                                        dictBuffer, dictBufferCapacity, 
+                                        newBuff, samplesSizes, nbSamples, 
+                                        params); 
+      free(newBuff); 
+      return result; } 
+} 
+ 
+ 
+size_t ZDICT_trainFromBuffer(void* dictBuffer, size_t dictBufferCapacity, 
+                             const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples) 
+{ 
+    ZDICT_params_t params; 
+    memset(&params, 0, sizeof(params)); 
+    return ZDICT_trainFromBuffer_advanced(dictBuffer, dictBufferCapacity, 
+                                          samplesBuffer, samplesSizes, nbSamples, 
+                                          params); 
+} 
+ 
diff --git a/contrib/libs/zstd06/dictBuilder/zdict.h b/contrib/libs/zstd06/dictBuilder/zdict.h
index d9e6d3262d..a898cb9c32 100644
--- a/contrib/libs/zstd06/dictBuilder/zdict.h
+++ b/contrib/libs/zstd06/dictBuilder/zdict.h
@@ -1,68 +1,68 @@
 #include <contrib/libs/zstd06/renames.h>
-/*
-    dictBuilder header file
-    Copyright (C) Yann Collet 2016
-
-    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 source repository : https://www.zstd.net
-*/
-
-#ifndef DICTBUILDER_H_001
-#define DICTBUILDER_H_001
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/*-*************************************
-*  Public functions
-***************************************/
-/*! ZDICT_trainFromBuffer() :
-    Train a dictionary from a memory buffer `samplesBuffer`,
-    where `nbSamples` samples have been stored concatenated.
-    Each sample size is provided into an orderly table `samplesSizes`.
-    Resulting dictionary will be saved into `dictBuffer`.
-    @return : size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
-              or an error code, which can be tested by ZDICT_isError().
-*/
-size_t ZDICT_trainFromBuffer(void* dictBuffer, size_t dictBufferCapacity,
-                             const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples);
-
-
-/*-*************************************
-*  Helper functions
-***************************************/
-unsigned ZDICT_isError(size_t errorCode);
-const char* ZDICT_getErrorName(size_t errorCode);
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif
+/* 
+    dictBuilder header file 
+    Copyright (C) Yann Collet 2016 
+ 
+    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 source repository : https://www.zstd.net 
+*/ 
+ 
+#ifndef DICTBUILDER_H_001 
+#define DICTBUILDER_H_001 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/*-************************************* 
+*  Public functions 
+***************************************/ 
+/*! ZDICT_trainFromBuffer() : 
+    Train a dictionary from a memory buffer `samplesBuffer`, 
+    where `nbSamples` samples have been stored concatenated. 
+    Each sample size is provided into an orderly table `samplesSizes`. 
+    Resulting dictionary will be saved into `dictBuffer`. 
+    @return : size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`) 
+              or an error code, which can be tested by ZDICT_isError(). 
+*/ 
+size_t ZDICT_trainFromBuffer(void* dictBuffer, size_t dictBufferCapacity, 
+                             const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples); 
+ 
+ 
+/*-************************************* 
+*  Helper functions 
+***************************************/ 
+unsigned ZDICT_isError(size_t errorCode); 
+const char* ZDICT_getErrorName(size_t errorCode); 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif 
diff --git a/contrib/libs/zstd06/dictBuilder/zdict_static.h b/contrib/libs/zstd06/dictBuilder/zdict_static.h
index f83f917008..6553e904ae 100644
--- a/contrib/libs/zstd06/dictBuilder/zdict_static.h
+++ b/contrib/libs/zstd06/dictBuilder/zdict_static.h
@@ -1,81 +1,81 @@
 #include <contrib/libs/zstd06/renames.h>
-/*
-    dictBuilder header file
-    for static linking only
-    Copyright (C) Yann Collet 2016
-
-    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 source repository : https://www.zstd.net
-*/
-
-/* This library is EXPERIMENTAL, below API is not yet stable */
-
-#ifndef DICTBUILDER_STATIC_H_002
-#define DICTBUILDER_STATIC_H_002
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include "zdict.h"
-
-
-/*-*************************************
-*  Public type
-***************************************/
-typedef struct {
-    unsigned selectivityLevel;   /* 0 means default; larger => bigger selection => larger dictionary */
-    unsigned compressionLevel;   /* 0 means default; target a specific zstd compression level */
-    unsigned notificationLevel;  /* Write to stderr; 0 = none (default); 1 = errors; 2 = progression; 3 = details; 4 = debug; */
-    unsigned reserved[3];        /* space for future parameters */
-} ZDICT_params_t;
-
-
-/*-*************************************
-*  Public functions
-***************************************/
-/*! ZDICT_trainFromBuffer_advanced() :
-    Same as ZDICT_trainFromBuffer() with control over more parameters.
-    `parameters` is optional and can be provided with values set to 0 to mean "default".
-    @return : size of dictionary stored into `dictBuffer` (<= `dictBufferSize`)
-              or an error code, which can be tested by DiB_isError().
-    note : ZDICT_trainFromBuffer_advanced() will send notifications into stderr if instructed to, using ZDICT_setNotificationLevel()
-*/
-size_t ZDICT_trainFromBuffer_advanced(void* dictBuffer, size_t dictBufferCapacity,
-                             const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
-                             ZDICT_params_t parameters);
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* DICTBUILDER_STATIC_H_002 */
+/* 
+    dictBuilder header file 
+    for static linking only 
+    Copyright (C) Yann Collet 2016 
+ 
+    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 source repository : https://www.zstd.net 
+*/ 
+ 
+/* This library is EXPERIMENTAL, below API is not yet stable */ 
+ 
+#ifndef DICTBUILDER_STATIC_H_002 
+#define DICTBUILDER_STATIC_H_002 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/*-************************************* 
+*  Dependencies 
+***************************************/ 
+#include "zdict.h" 
+ 
+ 
+/*-************************************* 
+*  Public type 
+***************************************/ 
+typedef struct { 
+    unsigned selectivityLevel;   /* 0 means default; larger => bigger selection => larger dictionary */ 
+    unsigned compressionLevel;   /* 0 means default; target a specific zstd compression level */ 
+    unsigned notificationLevel;  /* Write to stderr; 0 = none (default); 1 = errors; 2 = progression; 3 = details; 4 = debug; */ 
+    unsigned reserved[3];        /* space for future parameters */ 
+} ZDICT_params_t; 
+ 
+ 
+/*-************************************* 
+*  Public functions 
+***************************************/ 
+/*! ZDICT_trainFromBuffer_advanced() : 
+    Same as ZDICT_trainFromBuffer() with control over more parameters. 
+    `parameters` is optional and can be provided with values set to 0 to mean "default". 
+    @return : size of dictionary stored into `dictBuffer` (<= `dictBufferSize`) 
+              or an error code, which can be tested by DiB_isError(). 
+    note : ZDICT_trainFromBuffer_advanced() will send notifications into stderr if instructed to, using ZDICT_setNotificationLevel() 
+*/ 
+size_t ZDICT_trainFromBuffer_advanced(void* dictBuffer, size_t dictBufferCapacity, 
+                             const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples, 
+                             ZDICT_params_t parameters); 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* DICTBUILDER_STATIC_H_002 */ 
diff --git a/contrib/libs/zstd06/legacy/zstd_legacy.h b/contrib/libs/zstd06/legacy/zstd_legacy.h
index 80fc364cac..8b17a15317 100644
--- a/contrib/libs/zstd06/legacy/zstd_legacy.h
+++ b/contrib/libs/zstd06/legacy/zstd_legacy.h
@@ -1,65 +1,65 @@
 #include <contrib/libs/zstd06/renames.h>
-/*
-    zstd_legacy - decoder for legacy format
-    Header File
+/* 
+    zstd_legacy - decoder for legacy format 
+    Header File 
     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 source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-#ifndef ZSTD_LEGACY_H
-#define ZSTD_LEGACY_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* *************************************
-*  Includes
-***************************************/
-#include "mem.h"            /* MEM_STATIC */
-#include "error_private.h"  /* ERROR */
-#include "zstd_v01.h"
-#include "zstd_v02.h"
-#include "zstd_v03.h"
-#include "zstd_v04.h"
-#include "zstd_v05.h"
+ 
+    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 source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+#ifndef ZSTD_LEGACY_H 
+#define ZSTD_LEGACY_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/* ************************************* 
+*  Includes 
+***************************************/ 
+#include "mem.h"            /* MEM_STATIC */ 
+#include "error_private.h"  /* ERROR */ 
+#include "zstd_v01.h" 
+#include "zstd_v02.h" 
+#include "zstd_v03.h" 
+#include "zstd_v04.h" 
+#include "zstd_v05.h" 
 #include "zstd_v07.h"
 #include "zstd_v08.h"
-
+ 
 
 /** ZSTD_isLegacy() :
     @return : > 0 if supported by legacy decoder. 0 otherwise.
               return value is the version.
 */
-MEM_STATIC unsigned ZSTD_isLegacy (U32 magicNumberLE)
-{
-	switch(magicNumberLE)
-	{
+MEM_STATIC unsigned ZSTD_isLegacy (U32 magicNumberLE) 
+{ 
+	switch(magicNumberLE) 
+	{ 
 		case ZSTDv01_magicNumberLE:return 1;
 		case ZSTDv02_magicNumber : return 2;
 		case ZSTDv03_magicNumber : return 3;
@@ -67,17 +67,17 @@ MEM_STATIC unsigned ZSTD_isLegacy (U32 magicNumberLE)
 		case ZSTDv05_MAGICNUMBER : return 5;
 		case ZSTDv07_MAGICNUMBER : return 7;
 		case ZSTDv08_MAGICNUMBER : return 8;
-		default : return 0;
-	}
-}
-
-
-MEM_STATIC size_t ZSTD_decompressLegacy(
-                     void* dst, size_t dstCapacity,
-               const void* src, size_t compressedSize,
+		default : return 0; 
+	} 
+} 
+ 
+ 
+MEM_STATIC size_t ZSTD_decompressLegacy( 
+                     void* dst, size_t dstCapacity, 
+               const void* src, size_t compressedSize, 
                const void* dict,size_t dictSize,
-                     U32 magicNumberLE)
-{
+                     U32 magicNumberLE) 
+{ 
     switch(magicNumberLE)
     {
         case ZSTDv01_magicNumberLE :
@@ -116,12 +116,12 @@ MEM_STATIC size_t ZSTD_decompressLegacy(
         default :
             return ERROR(prefix_unknown);
     }
-}
-
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif   /* ZSTD_LEGACY_H */
+} 
+ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif   /* ZSTD_LEGACY_H */ 
diff --git a/contrib/libs/zstd06/legacy/zstd_v01.c b/contrib/libs/zstd06/legacy/zstd_v01.c
index d62367df29..f2d657ece9 100644
--- a/contrib/libs/zstd06/legacy/zstd_v01.c
+++ b/contrib/libs/zstd06/legacy/zstd_v01.c
@@ -1,2178 +1,2178 @@
-/* ******************************************************************
-   ZSTD_v01
-   Zstandard decoder, compatible with v0.1.x format
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-
-/******************************************
-*  Includes
-******************************************/
-#include <stddef.h>    /* size_t, ptrdiff_t */
-#include "zstd_v01.h"
-
-
-/******************************************
-*  Static allocation
-******************************************/
-/* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */
-#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
-
-/* You can statically allocate Huff0 DTable as a table of unsigned short using below macro */
-#define HUF_DTABLE_SIZE_U16(maxTableLog)   (1 + (1<<maxTableLog))
-#define HUF_CREATE_STATIC_DTABLE(DTable, maxTableLog) \
-        unsigned short DTable[HUF_DTABLE_SIZE_U16(maxTableLog)] = { maxTableLog }
-
-
-/******************************************
-*  Error Management
-******************************************/
-#define FSE_LIST_ERRORS(ITEM) \
-        ITEM(FSE_OK_NoError) ITEM(FSE_ERROR_GENERIC) \
-        ITEM(FSE_ERROR_tableLog_tooLarge) ITEM(FSE_ERROR_maxSymbolValue_tooLarge) ITEM(FSE_ERROR_maxSymbolValue_tooSmall) \
-        ITEM(FSE_ERROR_dstSize_tooSmall) ITEM(FSE_ERROR_srcSize_wrong)\
-        ITEM(FSE_ERROR_corruptionDetected) \
-        ITEM(FSE_ERROR_maxCode)
-
-#define FSE_GENERATE_ENUM(ENUM) ENUM,
-typedef enum { FSE_LIST_ERRORS(FSE_GENERATE_ENUM) } FSE_errorCodes;  /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */
-
-
-/******************************************
-*  FSE symbol compression API
-******************************************/
-/*
-   This API consists of small unitary functions, which highly benefit from being inlined.
-   You will want to enable link-time-optimization to ensure these functions are properly inlined in your binary.
-   Visual seems to do it automatically.
-   For gcc or clang, you'll need to add -flto flag at compilation and linking stages.
-   If none of these solutions is applicable, include "fse.c" directly.
-*/
-
-typedef unsigned FSE_CTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
-typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
-
-typedef struct
-{
-    size_t bitContainer;
-    int    bitPos;
-    char*  startPtr;
-    char*  ptr;
-    char*  endPtr;
-} FSE_CStream_t;
-
-typedef struct
-{
-    ptrdiff_t   value;
-    const void* stateTable;
-    const void* symbolTT;
-    unsigned    stateLog;
-} FSE_CState_t;
-
-typedef struct
-{
-    size_t   bitContainer;
-    unsigned bitsConsumed;
-    const char* ptr;
-    const char* start;
-} FSE_DStream_t;
-
-typedef struct
-{
-    size_t      state;
-    const void* table;   /* precise table may vary, depending on U16 */
-} FSE_DState_t;
-
-typedef enum { FSE_DStream_unfinished = 0,
-               FSE_DStream_endOfBuffer = 1,
-               FSE_DStream_completed = 2,
-               FSE_DStream_tooFar = 3 } FSE_DStream_status;  /* result of FSE_reloadDStream() */
-               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... ?! */
-
-
-/****************************************************************
-*  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
-
-
-/****************************************************************
-*  Byte symbol type
-****************************************************************/
-typedef struct
-{
-    unsigned short newState;
-    unsigned char  symbol;
-    unsigned char  nbBits;
-} FSE_decode_t;   /* size == U32 */
-
-
-
-/****************************************************************
-*  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
-#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#  ifdef __GNUC__
-#    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) */
-
-
-#ifndef MEM_ACCESS_MODULE
-#define MEM_ACCESS_MODULE
-/****************************************************************
-*  Basic Types
-*****************************************************************/
-#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-# include <stdint.h>
-typedef  uint8_t BYTE;
-typedef uint16_t U16;
-typedef  int16_t S16;
-typedef uint32_t U32;
-typedef  int32_t S32;
-typedef uint64_t U64;
-typedef  int64_t S64;
-#else
-typedef unsigned char       BYTE;
-typedef unsigned short      U16;
-typedef   signed short      S16;
-typedef unsigned int        U32;
-typedef   signed int        S32;
-typedef unsigned long long  U64;
-typedef   signed long long  S64;
-#endif
-
-#endif   /* MEM_ACCESS_MODULE */
-
-/****************************************************************
-*  Memory I/O
-*****************************************************************/
-/* FSE_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 is portable but violate C standard.
- *            It can generate buggy code on targets generating assembly depending on alignment.
- *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
- * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
- * Prefer these methods in priority order (0 > 1 > 2)
- */
-#ifndef FSE_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 FSE_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 FSE_FORCE_MEMORY_ACCESS 1
-#  endif
-#endif
-
-
-static unsigned FSE_32bits(void)
-{
-    return sizeof(void*)==4;
-}
-
-static unsigned FSE_isLittleEndian(void)
-{
-    const union { U32 i; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
-    return one.c[0];
-}
-
-#if defined(FSE_FORCE_MEMORY_ACCESS) && (FSE_FORCE_MEMORY_ACCESS==2)
-
-static U16 FSE_read16(const void* memPtr) { return *(const U16*) memPtr; }
-static U32 FSE_read32(const void* memPtr) { return *(const U32*) memPtr; }
-static U64 FSE_read64(const void* memPtr) { return *(const U64*) memPtr; }
-
-#elif defined(FSE_FORCE_MEMORY_ACCESS) && (FSE_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 { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign;
-
-static U16 FSE_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
-static U32 FSE_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
-static U64 FSE_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
-
-#else
-
-static U16 FSE_read16(const void* memPtr)
-{
-    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-static U32 FSE_read32(const void* memPtr)
-{
-    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-static U64 FSE_read64(const void* memPtr)
-{
-    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-#endif // FSE_FORCE_MEMORY_ACCESS
-
-static U16 FSE_readLE16(const void* memPtr)
-{
-    if (FSE_isLittleEndian())
-        return FSE_read16(memPtr);
-    else
-    {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U16)(p[0] + (p[1]<<8));
-    }
-}
-
-static U32 FSE_readLE32(const void* memPtr)
-{
-    if (FSE_isLittleEndian())
-        return FSE_read32(memPtr);
-    else
-    {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));
-    }
-}
-
-
-static U64 FSE_readLE64(const void* memPtr)
-{
-    if (FSE_isLittleEndian())
-        return FSE_read64(memPtr);
-    else
-    {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)
-                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));
-    }
-}
-
-static size_t FSE_readLEST(const void* memPtr)
-{
-    if (FSE_32bits())
-        return (size_t)FSE_readLE32(memPtr);
-    else
-        return (size_t)FSE_readLE64(memPtr);
-}
-
-
-
-/****************************************************************
-*  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
-
-
-/****************************************************************
-*  Error Management
-****************************************************************/
-#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-
-
-/****************************************************************
-*  Complex types
-****************************************************************/
-typedef struct
-{
-    int deltaFindState;
-    U32 deltaNbBits;
-} FSE_symbolCompressionTransform; /* total 8 bytes */
-
-typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];
-
-/****************************************************************
-*  Internal functions
-****************************************************************/
-FORCE_INLINE unsigned FSE_highbit32 (register U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
-    unsigned long r;
-    _BitScanReverse ( &r, val );
-    return (unsigned) r;
-#   elif defined(__GNUC__) && (GCC_VERSION >= 304)   /* GCC Intrinsic */
-    return 31 - __builtin_clz (val);
-#   else   /* Software version */
-    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
-    U32 v = val;
-    unsigned r;
-    v |= v >> 1;
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
-    return r;
-#   endif
-}
-
-
-/****************************************************************
-*  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)
-
-
-
-static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }
-
+/* ****************************************************************** 
+   ZSTD_v01 
+   Zstandard decoder, compatible with v0.1.x format 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+ 
+/****************************************** 
+*  Includes 
+******************************************/ 
+#include <stddef.h>    /* size_t, ptrdiff_t */ 
+#include "zstd_v01.h" 
+ 
+ 
+/****************************************** 
+*  Static allocation 
+******************************************/ 
+/* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */ 
+#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog)) 
+ 
+/* You can statically allocate Huff0 DTable as a table of unsigned short using below macro */ 
+#define HUF_DTABLE_SIZE_U16(maxTableLog)   (1 + (1<<maxTableLog)) 
+#define HUF_CREATE_STATIC_DTABLE(DTable, maxTableLog) \ 
+        unsigned short DTable[HUF_DTABLE_SIZE_U16(maxTableLog)] = { maxTableLog } 
+ 
+ 
+/****************************************** 
+*  Error Management 
+******************************************/ 
+#define FSE_LIST_ERRORS(ITEM) \ 
+        ITEM(FSE_OK_NoError) ITEM(FSE_ERROR_GENERIC) \ 
+        ITEM(FSE_ERROR_tableLog_tooLarge) ITEM(FSE_ERROR_maxSymbolValue_tooLarge) ITEM(FSE_ERROR_maxSymbolValue_tooSmall) \ 
+        ITEM(FSE_ERROR_dstSize_tooSmall) ITEM(FSE_ERROR_srcSize_wrong)\ 
+        ITEM(FSE_ERROR_corruptionDetected) \ 
+        ITEM(FSE_ERROR_maxCode) 
+ 
+#define FSE_GENERATE_ENUM(ENUM) ENUM, 
+typedef enum { FSE_LIST_ERRORS(FSE_GENERATE_ENUM) } FSE_errorCodes;  /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */ 
+ 
+ 
+/****************************************** 
+*  FSE symbol compression API 
+******************************************/ 
+/* 
+   This API consists of small unitary functions, which highly benefit from being inlined. 
+   You will want to enable link-time-optimization to ensure these functions are properly inlined in your binary. 
+   Visual seems to do it automatically. 
+   For gcc or clang, you'll need to add -flto flag at compilation and linking stages. 
+   If none of these solutions is applicable, include "fse.c" directly. 
+*/ 
+ 
+typedef unsigned FSE_CTable;   /* don't allocate that. It's just a way to be more restrictive than void* */ 
+typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */ 
+ 
+typedef struct 
+{ 
+    size_t bitContainer; 
+    int    bitPos; 
+    char*  startPtr; 
+    char*  ptr; 
+    char*  endPtr; 
+} FSE_CStream_t; 
+ 
+typedef struct 
+{ 
+    ptrdiff_t   value; 
+    const void* stateTable; 
+    const void* symbolTT; 
+    unsigned    stateLog; 
+} FSE_CState_t; 
+ 
+typedef struct 
+{ 
+    size_t   bitContainer; 
+    unsigned bitsConsumed; 
+    const char* ptr; 
+    const char* start; 
+} FSE_DStream_t; 
+ 
+typedef struct 
+{ 
+    size_t      state; 
+    const void* table;   /* precise table may vary, depending on U16 */ 
+} FSE_DState_t; 
+ 
+typedef enum { FSE_DStream_unfinished = 0, 
+               FSE_DStream_endOfBuffer = 1, 
+               FSE_DStream_completed = 2, 
+               FSE_DStream_tooFar = 3 } FSE_DStream_status;  /* result of FSE_reloadDStream() */ 
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... ?! */ 
+ 
+ 
+/**************************************************************** 
+*  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 
+ 
+ 
+/**************************************************************** 
+*  Byte symbol type 
+****************************************************************/ 
+typedef struct 
+{ 
+    unsigned short newState; 
+    unsigned char  symbol; 
+    unsigned char  nbBits; 
+} FSE_decode_t;   /* size == U32 */ 
+ 
+ 
+ 
+/**************************************************************** 
+*  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 
+#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) 
+#  ifdef __GNUC__ 
+#    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) */ 
+ 
+ 
+#ifndef MEM_ACCESS_MODULE 
+#define MEM_ACCESS_MODULE 
+/**************************************************************** 
+*  Basic Types 
+*****************************************************************/ 
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */ 
+# include <stdint.h> 
+typedef  uint8_t BYTE; 
+typedef uint16_t U16; 
+typedef  int16_t S16; 
+typedef uint32_t U32; 
+typedef  int32_t S32; 
+typedef uint64_t U64; 
+typedef  int64_t S64; 
+#else 
+typedef unsigned char       BYTE; 
+typedef unsigned short      U16; 
+typedef   signed short      S16; 
+typedef unsigned int        U32; 
+typedef   signed int        S32; 
+typedef unsigned long long  U64; 
+typedef   signed long long  S64; 
+#endif 
+ 
+#endif   /* MEM_ACCESS_MODULE */ 
+ 
+/**************************************************************** 
+*  Memory I/O 
+*****************************************************************/ 
+/* FSE_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 is portable but violate C standard. 
+ *            It can generate buggy code on targets generating assembly depending on alignment. 
+ *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) 
+ * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details. 
+ * Prefer these methods in priority order (0 > 1 > 2) 
+ */ 
+#ifndef FSE_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 FSE_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 FSE_FORCE_MEMORY_ACCESS 1 
+#  endif 
+#endif 
+ 
+ 
+static unsigned FSE_32bits(void) 
+{ 
+    return sizeof(void*)==4; 
+} 
+ 
+static unsigned FSE_isLittleEndian(void) 
+{ 
+    const union { U32 i; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */ 
+    return one.c[0]; 
+} 
+ 
+#if defined(FSE_FORCE_MEMORY_ACCESS) && (FSE_FORCE_MEMORY_ACCESS==2) 
+ 
+static U16 FSE_read16(const void* memPtr) { return *(const U16*) memPtr; } 
+static U32 FSE_read32(const void* memPtr) { return *(const U32*) memPtr; } 
+static U64 FSE_read64(const void* memPtr) { return *(const U64*) memPtr; } 
+ 
+#elif defined(FSE_FORCE_MEMORY_ACCESS) && (FSE_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 { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign; 
+ 
+static U16 FSE_read16(const void* ptr) { return ((const unalign*)ptr)->u16; } 
+static U32 FSE_read32(const void* ptr) { return ((const unalign*)ptr)->u32; } 
+static U64 FSE_read64(const void* ptr) { return ((const unalign*)ptr)->u64; } 
+ 
+#else 
+ 
+static U16 FSE_read16(const void* memPtr) 
+{ 
+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+static U32 FSE_read32(const void* memPtr) 
+{ 
+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+static U64 FSE_read64(const void* memPtr) 
+{ 
+    U64 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+#endif // FSE_FORCE_MEMORY_ACCESS 
+ 
+static U16 FSE_readLE16(const void* memPtr) 
+{ 
+    if (FSE_isLittleEndian()) 
+        return FSE_read16(memPtr); 
+    else 
+    { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U16)(p[0] + (p[1]<<8)); 
+    } 
+} 
+ 
+static U32 FSE_readLE32(const void* memPtr) 
+{ 
+    if (FSE_isLittleEndian()) 
+        return FSE_read32(memPtr); 
+    else 
+    { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24)); 
+    } 
+} 
+ 
+ 
+static U64 FSE_readLE64(const void* memPtr) 
+{ 
+    if (FSE_isLittleEndian()) 
+        return FSE_read64(memPtr); 
+    else 
+    { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24) 
+                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56)); 
+    } 
+} 
+ 
+static size_t FSE_readLEST(const void* memPtr) 
+{ 
+    if (FSE_32bits()) 
+        return (size_t)FSE_readLE32(memPtr); 
+    else 
+        return (size_t)FSE_readLE64(memPtr); 
+} 
+ 
+ 
+ 
+/**************************************************************** 
+*  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 
+ 
+ 
+/**************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */ 
+ 
+ 
+/**************************************************************** 
+*  Complex types 
+****************************************************************/ 
+typedef struct 
+{ 
+    int deltaFindState; 
+    U32 deltaNbBits; 
+} FSE_symbolCompressionTransform; /* total 8 bytes */ 
+ 
+typedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)]; 
+ 
+/**************************************************************** 
+*  Internal functions 
+****************************************************************/ 
+FORCE_INLINE unsigned FSE_highbit32 (register U32 val) 
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
+    unsigned long r; 
+    _BitScanReverse ( &r, val ); 
+    return (unsigned) r; 
+#   elif defined(__GNUC__) && (GCC_VERSION >= 304)   /* GCC Intrinsic */ 
+    return 31 - __builtin_clz (val); 
+#   else   /* Software version */ 
+    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 }; 
+    U32 v = val; 
+    unsigned r; 
+    v |= v >> 1; 
+    v |= v >> 2; 
+    v |= v >> 4; 
+    v |= v >> 8; 
+    v |= v >> 16; 
+    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27]; 
+    return r; 
+#   endif 
+} 
+ 
+ 
+/**************************************************************** 
+*  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) 
+ 
+ 
+ 
+static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; } 
+ 
 #define FSE_DECODE_TYPE FSE_decode_t
-
-
-typedef struct {
-    U16 tableLog;
-    U16 fastMode;
-} FSE_DTableHeader;   /* sizeof U32 */
-
+ 
+ 
+typedef struct { 
+    U16 tableLog; 
+    U16 fastMode; 
+} FSE_DTableHeader;   /* sizeof U32 */ 
+ 
 static size_t FSE_buildDTable
-(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
-{
-    void* ptr = dt;
-    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
-    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)(ptr) + 1;   /* because dt is unsigned, 32-bits aligned on 32-bits */
-    const U32 tableSize = 1 << tableLog;
-    const U32 tableMask = tableSize-1;
-    const U32 step = FSE_tableStep(tableSize);
-    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];
-    U32 position = 0;
-    U32 highThreshold = tableSize-1;
-    const S16 largeLimit= (S16)(1 << (tableLog-1));
-    U32 noLarge = 1;
-    U32 s;
-
-    /* Sanity Checks */
-    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return (size_t)-FSE_ERROR_maxSymbolValue_tooLarge;
-    if (tableLog > FSE_MAX_TABLELOG) return (size_t)-FSE_ERROR_tableLog_tooLarge;
-
-    /* Init, lay down lowprob symbols */
-    DTableH[0].tableLog = (U16)tableLog;
-    for (s=0; s<=maxSymbolValue; s++)
-    {
-        if (normalizedCounter[s]==-1)
-        {
-            tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;
-            symbolNext[s] = 1;
-        }
-        else
-        {
-            if (normalizedCounter[s] >= largeLimit) noLarge=0;
-            symbolNext[s] = normalizedCounter[s];
-        }
-    }
-
-    /* Spread symbols */
-    for (s=0; s<=maxSymbolValue; 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 (size_t)-FSE_ERROR_GENERIC;   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
-
-    /* Build Decoding table */
-    {
-        U32 i;
-        for (i=0; i<tableSize; i++)
-        {
-            FSE_FUNCTION_TYPE symbol = (FSE_FUNCTION_TYPE)(tableDecode[i].symbol);
-            U16 nextState = symbolNext[symbol]++;
-            tableDecode[i].nbBits = (BYTE) (tableLog - FSE_highbit32 ((U32)nextState) );
-            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize);
-        }
-    }
-
-    DTableH->fastMode = (U16)noLarge;
-    return 0;
-}
-
-
-/******************************************
-*  FSE byte symbol
-******************************************/
-#ifndef FSE_COMMONDEFS_ONLY
-
-static unsigned FSE_isError(size_t code) { return (code > (size_t)(-FSE_ERROR_maxCode)); }
-
-static short FSE_abs(short a)
-{
-    return a<0? -a : a;
-}
-
-
-/****************************************************************
-*  Header bitstream management
-****************************************************************/
-static 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 (size_t)-FSE_ERROR_srcSize_wrong;
-    bitStream = FSE_readLE32(ip);
-    nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */
-    if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return (size_t)-FSE_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 = FSE_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 (size_t)-FSE_ERROR_maxSymbolValue_tooSmall;
-            while (charnum < n0) normalizedCounter[charnum++] = 0;
-            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))
-            {
-                ip += bitCount>>3;
-                bitCount &= 7;
-                bitStream = FSE_readLE32(ip) >> bitCount;
-            }
-            else
-                bitStream >>= 2;
-        }
-        {
-            const short 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 = FSE_readLE32(ip) >> (bitCount & 31);
-            }
-        }
-    }
-    if (remaining != 1) return (size_t)-FSE_ERROR_GENERIC;
-    *maxSVPtr = charnum-1;
-
-    ip += (bitCount+7)>>3;
-    if ((size_t)(ip-istart) > hbSize) return (size_t)-FSE_ERROR_srcSize_wrong;
-    return ip-istart;
-}
-
-
-/*********************************************************
-*  Decompression (Byte symbols)
-*********************************************************/
-static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
-{
-    void* ptr = dt;
-    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
-    FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */
-
-    DTableH->tableLog = 0;
-    DTableH->fastMode = 0;
-
-    cell->newState = 0;
-    cell->symbol = symbolValue;
-    cell->nbBits = 0;
-
-    return 0;
-}
-
-
-static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
-{
-    void* ptr = dt;
-    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
-    FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */
-    const unsigned tableSize = 1 << nbBits;
-    const unsigned tableMask = tableSize - 1;
-    const unsigned maxSymbolValue = tableMask;
-    unsigned s;
-
-    /* Sanity checks */
-    if (nbBits < 1) return (size_t)-FSE_ERROR_GENERIC;             /* min size */
-
-    /* Build Decoding Table */
-    DTableH->tableLog = (U16)nbBits;
-    DTableH->fastMode = 1;
-    for (s=0; s<=maxSymbolValue; s++)
-    {
-        dinfo[s].newState = 0;
-        dinfo[s].symbol = (BYTE)s;
-        dinfo[s].nbBits = (BYTE)nbBits;
-    }
-
-    return 0;
-}
-
-
-/* FSE_initDStream
- * Initialize a FSE_DStream_t.
- * srcBuffer must point at the beginning of an FSE block.
- * The function result is the size of the FSE_block (== srcSize).
- * If srcSize is too small, the function will return an errorCode;
- */
-static size_t FSE_initDStream(FSE_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
-{
-    if (srcSize < 1) return (size_t)-FSE_ERROR_srcSize_wrong;
-
-    if (srcSize >=  sizeof(size_t))
-    {
-        U32 contain32;
-        bitD->start = (const char*)srcBuffer;
-        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t);
-        bitD->bitContainer = FSE_readLEST(bitD->ptr);
-        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
-        if (contain32 == 0) return (size_t)-FSE_ERROR_GENERIC;   /* stop bit not present */
-        bitD->bitsConsumed = 8 - FSE_highbit32(contain32);
-    }
-    else
-    {
-        U32 contain32;
-        bitD->start = (const char*)srcBuffer;
-        bitD->ptr   = bitD->start;
-        bitD->bitContainer = *(const BYTE*)(bitD->start);
-        switch(srcSize)
-        {
-            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);
-            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);
-            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);
-            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;
-            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;
-            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8;
-            default:;
-        }
-        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
-        if (contain32 == 0) return (size_t)-FSE_ERROR_GENERIC;   /* stop bit not present */
-        bitD->bitsConsumed = 8 - FSE_highbit32(contain32);
-        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;
-    }
-
-    return srcSize;
-}
-
-
-/*!FSE_lookBits
- * Provides next n bits from the bitContainer.
- * bitContainer is not modified (bits are still present for next read/look)
- * On 32-bits, maxNbBits==25
- * On 64-bits, maxNbBits==57
- * return : value extracted.
- */
-static size_t FSE_lookBits(FSE_DStream_t* bitD, U32 nbBits)
-{
-    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
-    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
-}
-
-static size_t FSE_lookBitsFast(FSE_DStream_t* bitD, U32 nbBits)   /* only if nbBits >= 1 !! */
-{
-    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
-    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);
-}
-
-static void FSE_skipBits(FSE_DStream_t* bitD, U32 nbBits)
-{
-    bitD->bitsConsumed += nbBits;
-}
-
-
-/*!FSE_readBits
- * Read next n bits from the bitContainer.
- * On 32-bits, don't read more than maxNbBits==25
- * On 64-bits, don't read more than maxNbBits==57
- * Use the fast variant *only* if n >= 1.
- * return : value extracted.
- */
-static size_t FSE_readBits(FSE_DStream_t* bitD, U32 nbBits)
-{
-    size_t value = FSE_lookBits(bitD, nbBits);
-    FSE_skipBits(bitD, nbBits);
-    return value;
-}
-
-static size_t FSE_readBitsFast(FSE_DStream_t* bitD, U32 nbBits)   /* only if nbBits >= 1 !! */
-{
-    size_t value = FSE_lookBitsFast(bitD, nbBits);
-    FSE_skipBits(bitD, nbBits);
-    return value;
-}
-
-static unsigned FSE_reloadDStream(FSE_DStream_t* bitD)
-{
-    if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
-        return FSE_DStream_tooFar;
-
-    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer))
-    {
-        bitD->ptr -= bitD->bitsConsumed >> 3;
-        bitD->bitsConsumed &= 7;
-        bitD->bitContainer = FSE_readLEST(bitD->ptr);
-        return FSE_DStream_unfinished;
-    }
-    if (bitD->ptr == bitD->start)
-    {
-        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return FSE_DStream_endOfBuffer;
-        return FSE_DStream_completed;
-    }
-    {
-        U32 nbBytes = bitD->bitsConsumed >> 3;
-        U32 result = FSE_DStream_unfinished;
-        if (bitD->ptr - nbBytes < bitD->start)
-        {
-            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
-            result = FSE_DStream_endOfBuffer;
-        }
-        bitD->ptr -= nbBytes;
-        bitD->bitsConsumed -= nbBytes*8;
-        bitD->bitContainer = FSE_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
-        return result;
-    }
-}
-
-
-static void FSE_initDState(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD, const FSE_DTable* dt)
-{
-    const void* ptr = dt;
-    const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr;
-    DStatePtr->state = FSE_readBits(bitD, DTableH->tableLog);
-    FSE_reloadDStream(bitD);
-    DStatePtr->table = dt + 1;
-}
-
-static BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD)
-{
-    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    const U32  nbBits = DInfo.nbBits;
-    BYTE symbol = DInfo.symbol;
-    size_t lowBits = FSE_readBits(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-static BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD)
-{
-    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    const U32 nbBits = DInfo.nbBits;
-    BYTE symbol = DInfo.symbol;
-    size_t lowBits = FSE_readBitsFast(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-/* FSE_endOfDStream
-   Tells if bitD has reached end of bitStream or not */
-
-static unsigned FSE_endOfDStream(const FSE_DStream_t* bitD)
-{
-    return ((bitD->ptr == bitD->start) && (bitD->bitsConsumed == sizeof(bitD->bitContainer)*8));
-}
-
-static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
-{
-    return DStatePtr->state == 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;
-
-    FSE_DStream_t bitD;
-    FSE_DState_t state1;
-    FSE_DState_t state2;
-    size_t errorCode;
-
-    /* Init */
-    errorCode = FSE_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 ( ; (FSE_reloadDStream(&bitD)==FSE_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 */
-            FSE_reloadDStream(&bitD);
-
-        op[1] = FSE_GETSYMBOL(&state2);
-
-        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            { if (FSE_reloadDStream(&bitD) > FSE_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 */
-            FSE_reloadDStream(&bitD);
-
-        op[3] = FSE_GETSYMBOL(&state2);
-    }
-
-    /* tail */
-    /* note : FSE_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly FSE_DStream_completed */
-    while (1)
-    {
-        if ( (FSE_reloadDStream(&bitD)>FSE_DStream_completed) || (op==omax) || (FSE_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) )
-            break;
-
-        *op++ = FSE_GETSYMBOL(&state1);
-
-        if ( (FSE_reloadDStream(&bitD)>FSE_DStream_completed) || (op==omax) || (FSE_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) )
-            break;
-
-        *op++ = FSE_GETSYMBOL(&state2);
-    }
-
-    /* end ? */
-    if (FSE_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2))
-        return op-ostart;
-
-    if (op==omax) return (size_t)-FSE_ERROR_dstSize_tooSmall;   /* dst buffer is full, but cSrc unfinished */
-
-    return (size_t)-FSE_ERROR_corruptionDetected;
-}
-
-
-static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
-                            const void* cSrc, size_t cSrcSize,
-                            const FSE_DTable* dt)
-{
-    FSE_DTableHeader DTableH;
-    memcpy(&DTableH, dt, sizeof(DTableH));   /* memcpy() into local variable, to avoid strict aliasing warning */
-
-    /* select fast mode (static) */
-    if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
-    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
-}
-
-
-static 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;
-    size_t errorCode;
-
-    if (cSrcSize<2) return (size_t)-FSE_ERROR_srcSize_wrong;   /* too small input size */
-
-    /* normal FSE decoding mode */
-    errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
-    if (FSE_isError(errorCode)) return errorCode;
-    if (errorCode >= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong;   /* too small input size */
-    ip += errorCode;
-    cSrcSize -= errorCode;
-
-    errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);
-    if (FSE_isError(errorCode)) return errorCode;
-
-    /* always return, even if it is an error code */
-    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);
-}
-
-
-
-/* *******************************************************
-*  Huff0 : Huffman block compression
-*********************************************************/
-#define HUF_MAX_SYMBOL_VALUE 255
-#define HUF_DEFAULT_TABLELOG  12       /* used by default, when not specified */
-#define HUF_MAX_TABLELOG  12           /* max possible tableLog; for allocation purpose; can be modified */
-#define HUF_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */
-#if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG)
-#  error "HUF_MAX_TABLELOG is too large !"
-#endif
-
-typedef struct HUF_CElt_s {
-  U16  val;
-  BYTE nbBits;
-} HUF_CElt ;
-
-typedef struct nodeElt_s {
-    U32 count;
-    U16 parent;
-    BYTE byte;
-    BYTE nbBits;
-} nodeElt;
-
-
-/* *******************************************************
-*  Huff0 : Huffman block decompression
-*********************************************************/
-typedef struct {
-    BYTE byte;
-    BYTE nbBits;
-} HUF_DElt;
-
-static size_t HUF_readDTable (U16* DTable, const void* src, size_t srcSize)
-{
-    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1];
-    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];  /* large enough for values from 0 to 16 */
-    U32 weightTotal;
-    U32 maxBits;
-    const BYTE* ip = (const BYTE*) src;
-    size_t iSize = ip[0];
-    size_t oSize;
-    U32 n;
-    U32 nextRankStart;
-    void* ptr = DTable+1;
-    HUF_DElt* const dt = (HUF_DElt*)ptr;
-
-    FSE_STATIC_ASSERT(sizeof(HUF_DElt) == sizeof(U16));   /* if compilation fails here, assertion is false */
-    //memset(huffWeight, 0, sizeof(huffWeight));   /* should not be necessary, but some analyzer complain ... */
-    if (iSize >= 128)  /* special header */
-    {
-        if (iSize >= (242))   /* RLE */
-        {
-            static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };
-            oSize = l[iSize-242];
-            memset(huffWeight, 1, sizeof(huffWeight));
-            iSize = 0;
-        }
-        else   /* Incompressible */
-        {
-            oSize = iSize - 127;
-            iSize = ((oSize+1)/2);
-            if (iSize+1 > srcSize) return (size_t)-FSE_ERROR_srcSize_wrong;
-            ip += 1;
-            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 (size_t)-FSE_ERROR_srcSize_wrong;
-        oSize = FSE_decompress(huffWeight, HUF_MAX_SYMBOL_VALUE, ip+1, iSize);   /* max 255 values decoded, last one is implied */
-        if (FSE_isError(oSize)) return oSize;
-    }
-
-    /* collect weight stats */
-    memset(rankVal, 0, sizeof(rankVal));
-    weightTotal = 0;
-    for (n=0; n<oSize; n++)
-    {
-        if (huffWeight[n] >= HUF_ABSOLUTEMAX_TABLELOG) return (size_t)-FSE_ERROR_corruptionDetected;
-        rankVal[huffWeight[n]]++;
-        weightTotal += (1 << huffWeight[n]) >> 1;
-    }
-
-    /* get last non-null symbol weight (implied, total must be 2^n) */
-    maxBits = FSE_highbit32(weightTotal) + 1;
-    if (maxBits > DTable[0]) return (size_t)-FSE_ERROR_tableLog_tooLarge;   /* DTable is too small */
-    DTable[0] = (U16)maxBits;
-    {
-        U32 total = 1 << maxBits;
-        U32 rest = total - weightTotal;
-        U32 verif = 1 << FSE_highbit32(rest);
-        U32 lastWeight = FSE_highbit32(rest) + 1;
-        if (verif != rest) return (size_t)-FSE_ERROR_corruptionDetected;    /* last value must be a clean power of 2 */
-        huffWeight[oSize] = (BYTE)lastWeight;
-        rankVal[lastWeight]++;
-    }
-
-    /* check tree construction validity */
-    if ((rankVal[1] < 2) || (rankVal[1] & 1)) return (size_t)-FSE_ERROR_corruptionDetected;   /* by construction : at least 2 elts of rank 1, must be even */
-
-    /* Prepare ranks */
-    nextRankStart = 0;
-    for (n=1; n<=maxBits; n++)
-    {
-        U32 current = nextRankStart;
-        nextRankStart += (rankVal[n] << (n-1));
-        rankVal[n] = current;
-    }
-
-    /* fill DTable */
-    for (n=0; n<=oSize; n++)
-    {
-        const U32 w = huffWeight[n];
-        const U32 length = (1 << w) >> 1;
-        U32 i;
-        HUF_DElt D;
-        D.byte = (BYTE)n; D.nbBits = (BYTE)(maxBits + 1 - w);
-        for (i = rankVal[w]; i < rankVal[w] + length; i++)
-            dt[i] = D;
-        rankVal[w] += length;
-    }
-
-    return iSize+1;
-}
-
-
-static BYTE HUF_decodeSymbol(FSE_DStream_t* Dstream, const HUF_DElt* dt, const U32 dtLog)
-{
-        const size_t val = FSE_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
-        const BYTE c = dt[val].byte;
-        FSE_skipBits(Dstream, dt[val].nbBits);
-        return c;
-}
-
-static size_t HUF_decompress_usingDTable(   /* -3% slower when non static */
-          void* dst, size_t maxDstSize,
-    const void* cSrc, size_t cSrcSize,
-    const U16* DTable)
-{
-    BYTE* const ostart = (BYTE*) dst;
-    BYTE* op = ostart;
-    BYTE* const omax = op + maxDstSize;
-    BYTE* const olimit = omax-15;
-
-    const void* ptr = DTable;
-    const HUF_DElt* const dt = (const HUF_DElt*)(ptr)+1;
-    const U32 dtLog = DTable[0];
-    size_t errorCode;
-    U32 reloadStatus;
-
-    /* Init */
-
-    const U16* jumpTable = (const U16*)cSrc;
-    const size_t length1 = FSE_readLE16(jumpTable);
-    const size_t length2 = FSE_readLE16(jumpTable+1);
-    const size_t length3 = FSE_readLE16(jumpTable+2);
-    const size_t length4 = cSrcSize - 6 - length1 - length2 - length3;   // check coherency !!
-    const char* const start1 = (const char*)(cSrc) + 6;
-    const char* const start2 = start1 + length1;
-    const char* const start3 = start2 + length2;
-    const char* const start4 = start3 + length3;
-    FSE_DStream_t bitD1, bitD2, bitD3, bitD4;
-
-    if (length1+length2+length3+6 >= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong;
-
-    errorCode = FSE_initDStream(&bitD1, start1, length1);
-    if (FSE_isError(errorCode)) return errorCode;
-    errorCode = FSE_initDStream(&bitD2, start2, length2);
-    if (FSE_isError(errorCode)) return errorCode;
-    errorCode = FSE_initDStream(&bitD3, start3, length3);
-    if (FSE_isError(errorCode)) return errorCode;
-    errorCode = FSE_initDStream(&bitD4, start4, length4);
-    if (FSE_isError(errorCode)) return errorCode;
-
-    reloadStatus=FSE_reloadDStream(&bitD2);
-
-    /* 16 symbols per loop */
-    for ( ; (reloadStatus<FSE_DStream_completed) && (op<olimit);  /* D2-3-4 are supposed to be synchronized and finish together */
-        op+=16, reloadStatus = FSE_reloadDStream(&bitD2) | FSE_reloadDStream(&bitD3) | FSE_reloadDStream(&bitD4), FSE_reloadDStream(&bitD1))
-    {
-#define HUF_DECODE_SYMBOL_0(n, Dstream) \
-        op[n] = HUF_decodeSymbol(&Dstream, dt, dtLog);
-
-#define HUF_DECODE_SYMBOL_1(n, Dstream) \
-        op[n] = HUF_decodeSymbol(&Dstream, dt, dtLog); \
-        if (FSE_32bits() && (HUF_MAX_TABLELOG>12)) FSE_reloadDStream(&Dstream)
-
-#define HUF_DECODE_SYMBOL_2(n, Dstream) \
-        op[n] = HUF_decodeSymbol(&Dstream, dt, dtLog); \
-        if (FSE_32bits()) FSE_reloadDStream(&Dstream)
-
-        HUF_DECODE_SYMBOL_1( 0, bitD1);
-        HUF_DECODE_SYMBOL_1( 1, bitD2);
-        HUF_DECODE_SYMBOL_1( 2, bitD3);
-        HUF_DECODE_SYMBOL_1( 3, bitD4);
-        HUF_DECODE_SYMBOL_2( 4, bitD1);
-        HUF_DECODE_SYMBOL_2( 5, bitD2);
-        HUF_DECODE_SYMBOL_2( 6, bitD3);
-        HUF_DECODE_SYMBOL_2( 7, bitD4);
-        HUF_DECODE_SYMBOL_1( 8, bitD1);
-        HUF_DECODE_SYMBOL_1( 9, bitD2);
-        HUF_DECODE_SYMBOL_1(10, bitD3);
-        HUF_DECODE_SYMBOL_1(11, bitD4);
-        HUF_DECODE_SYMBOL_0(12, bitD1);
-        HUF_DECODE_SYMBOL_0(13, bitD2);
-        HUF_DECODE_SYMBOL_0(14, bitD3);
-        HUF_DECODE_SYMBOL_0(15, bitD4);
-    }
-
-    if (reloadStatus!=FSE_DStream_completed)   /* not complete : some bitStream might be FSE_DStream_unfinished */
-        return (size_t)-FSE_ERROR_corruptionDetected;
-
-    /* tail */
-    {
-        // bitTail = bitD1;   // *much* slower : -20% !??!
-        FSE_DStream_t bitTail;
-        bitTail.ptr = bitD1.ptr;
-        bitTail.bitsConsumed = bitD1.bitsConsumed;
-        bitTail.bitContainer = bitD1.bitContainer;   // required in case of FSE_DStream_endOfBuffer
-        bitTail.start = start1;
-        for ( ; (FSE_reloadDStream(&bitTail) < FSE_DStream_completed) && (op<omax) ; op++)
-        {
-            HUF_DECODE_SYMBOL_0(0, bitTail);
-        }
-
-        if (FSE_endOfDStream(&bitTail))
-            return op-ostart;
-    }
-
-    if (op==omax) return (size_t)-FSE_ERROR_dstSize_tooSmall;   /* dst buffer is full, but cSrc unfinished */
-
-    return (size_t)-FSE_ERROR_corruptionDetected;
-}
-
-
-static size_t HUF_decompress (void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUF_CREATE_STATIC_DTABLE(DTable, HUF_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-    size_t errorCode;
-
-    errorCode = HUF_readDTable (DTable, cSrc, cSrcSize);
-    if (FSE_isError(errorCode)) return errorCode;
-    if (errorCode >= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong;
-    ip += errorCode;
-    cSrcSize -= errorCode;
-
-    return HUF_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, DTable);
-}
-
-
-#endif   /* FSE_COMMONDEFS_ONLY */
-
-/*
-    zstd - standard compression library
-    Header File for static linking only
-    Copyright (C) 2014-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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-
-/* The objects defined into this file should be considered experimental.
- * They are not labelled stable, as their prototype may change in the future.
- * You can use them for tests, provide feedback, or if you can endure risk of future changes.
- */
-
-/**************************************
-*  Error management
-**************************************/
-#define ZSTD_LIST_ERRORS(ITEM) \
-        ITEM(ZSTD_OK_NoError) ITEM(ZSTD_ERROR_GENERIC) \
-        ITEM(ZSTD_ERROR_MagicNumber) \
-        ITEM(ZSTD_ERROR_SrcSize) ITEM(ZSTD_ERROR_maxDstSize_tooSmall) \
-        ITEM(ZSTD_ERROR_corruption) \
-        ITEM(ZSTD_ERROR_maxCode)
-
-#define ZSTD_GENERATE_ENUM(ENUM) ENUM,
-typedef enum { ZSTD_LIST_ERRORS(ZSTD_GENERATE_ENUM) } ZSTD_errorCodes;   /* exposed list of errors; static linking only */
-
-/*
-    zstd - standard compression library
-    Copyright (C) 2014-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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-
-/****************************************************************
-*  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 */
-#define ZSTD_MEMORY_USAGE 17
-
-
-/**************************************
-   CPU Feature Detection
-**************************************/
-/*
- * Automated efficient unaligned memory access detection
- * Based on known hardware architectures
- * This list will be updated thanks to feedbacks
- */
-#if defined(CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS) \
-    || defined(__ARM_FEATURE_UNALIGNED) \
-    || defined(__i386__) || defined(__x86_64__) \
-    || defined(_M_IX86) || defined(_M_X64) \
-    || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_8__) \
-    || (defined(_M_ARM) && (_M_ARM >= 7))
-#  define ZSTD_UNALIGNED_ACCESS 1
-#else
-#  define ZSTD_UNALIGNED_ACCESS 0
-#endif
-
-
-/********************************************************
-*  Includes
-*********************************************************/
-#include <stdlib.h>      /* calloc */
-#include <string.h>      /* memcpy, memmove */
-#include <stdio.h>       /* debug : printf */
-
-
-/********************************************************
-*  Compiler specifics
-*********************************************************/
-#ifdef __AVX2__
-#  include <immintrin.h>   /* AVX2 intrinsics */
-#endif
-
-#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 : 4324)        /* disable: C4324: padded structure */
-#else
-#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#  ifdef __GNUC__
-#    define FORCE_INLINE static inline __attribute__((always_inline))
-#  else
-#    define FORCE_INLINE static inline
-#  endif
-#endif
-
-
-#ifndef MEM_ACCESS_MODULE
-#define MEM_ACCESS_MODULE
-/********************************************************
-*  Basic Types
-*********************************************************/
-#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-# include <stdint.h>
-typedef  uint8_t BYTE;
-typedef uint16_t U16;
-typedef  int16_t S16;
-typedef uint32_t U32;
-typedef  int32_t S32;
-typedef uint64_t U64;
-#else
-typedef unsigned char       BYTE;
-typedef unsigned short      U16;
-typedef   signed short      S16;
-typedef unsigned int        U32;
-typedef   signed int        S32;
-typedef unsigned long long  U64;
-#endif
-
-#endif   /* MEM_ACCESS_MODULE */
-
-
-/********************************************************
-*  Constants
-*********************************************************/
-static const U32 ZSTD_magicNumber = 0xFD2FB51E;   /* 3rd version : seqNb header */
-
-#define HASH_LOG (ZSTD_MEMORY_USAGE - 2)
-#define HASH_TABLESIZE (1 << HASH_LOG)
-#define HASH_MASK (HASH_TABLESIZE - 1)
-
-#define KNUTH 2654435761
-
-#define BIT7 128
-#define BIT6  64
-#define BIT5  32
-#define BIT4  16
-
-#define KB *(1 <<10)
-#define MB *(1 <<20)
-#define GB *(1U<<30)
-
-#define BLOCKSIZE (128 KB)                 /* define, for static allocation */
-
-#define WORKPLACESIZE (BLOCKSIZE*3)
-#define MINMATCH 4
-#define MLbits   7
-#define LLbits   6
-#define Offbits  5
-#define MaxML  ((1<<MLbits )-1)
-#define MaxLL  ((1<<LLbits )-1)
-#define MaxOff ((1<<Offbits)-1)
-#define LitFSELog  11
-#define MLFSELog   10
-#define LLFSELog   10
-#define OffFSELog   9
-#define MAX(a,b) ((a)<(b)?(b):(a))
-#define MaxSeq MAX(MaxLL, MaxML)
-
-#define LITERAL_NOENTROPY 63
-#define COMMAND_NOENTROPY 7   /* to remove */
-
-static const size_t ZSTD_blockHeaderSize = 3;
-static const size_t ZSTD_frameHeaderSize = 4;
-
-
-/********************************************************
-*  Memory operations
-*********************************************************/
-static unsigned ZSTD_32bits(void) { return sizeof(void*)==4; }
-
-static unsigned ZSTD_isLittleEndian(void)
-{
-    const union { U32 i; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
-    return one.c[0];
-}
-
-static U16    ZSTD_read16(const void* p) { U16 r; memcpy(&r, p, sizeof(r)); return r; }
-
-static U32    ZSTD_read32(const void* p) { U32 r; memcpy(&r, p, sizeof(r)); return r; }
-
-static void   ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
-
-static void   ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
-
-#define COPY8(d,s)    { ZSTD_copy8(d,s); d+=8; s+=8; }
-
-static void ZSTD_wildcopy(void* dst, const void* src, size_t length)
-{
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + length;
-    while (op < oend) COPY8(op, ip);
-}
-
-static U16 ZSTD_readLE16(const void* memPtr)
-{
-    if (ZSTD_isLittleEndian()) return ZSTD_read16(memPtr);
-    else
-    {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U16)((U16)p[0] + ((U16)p[1]<<8));
-    }
-}
-
-
-static U32 ZSTD_readLE32(const void* memPtr)
-{
-    if (ZSTD_isLittleEndian())
-        return ZSTD_read32(memPtr);
-    else
-    {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));
-    }
-}
-
-static U32 ZSTD_readBE32(const void* memPtr)
-{
-    const BYTE* p = (const BYTE*)memPtr;
-    return (U32)(((U32)p[0]<<24) + ((U32)p[1]<<16) + ((U32)p[2]<<8) + ((U32)p[3]<<0));
-}
-
-
-/**************************************
-*  Local structures
-***************************************/
-typedef struct ZSTD_Cctx_s ZSTD_Cctx;
-
-typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;
-
-typedef struct
-{
-    blockType_t blockType;
-    U32 origSize;
-} blockProperties_t;
-
-typedef struct {
-    void* buffer;
-    U32*  offsetStart;
-    U32*  offset;
-    BYTE* offCodeStart;
-    BYTE* offCode;
-    BYTE* litStart;
-    BYTE* lit;
-    BYTE* litLengthStart;
-    BYTE* litLength;
-    BYTE* matchLengthStart;
-    BYTE* matchLength;
-    BYTE* dumpsStart;
-    BYTE* dumps;
-} seqStore_t;
-
-
-typedef struct ZSTD_Cctx_s
-{
-    const BYTE* base;
-    U32 current;
-    U32 nextUpdate;
-    seqStore_t seqStore;
-#ifdef __AVX2__
-    __m256i hashTable[HASH_TABLESIZE>>3];
-#else
-    U32 hashTable[HASH_TABLESIZE];
-#endif
-	BYTE buffer[WORKPLACESIZE];
-} cctxi_t;
-
-
-
-
-/**************************************
-*  Error Management
-**************************************/
-/* tells if a return value is an error code */
-static unsigned ZSTD_isError(size_t code) { return (code > (size_t)(-ZSTD_ERROR_maxCode)); }
-
-/* published entry point */
-unsigned ZSTDv01_isError(size_t code) { return ZSTD_isError(code); }
-
-
-/**************************************
-*  Tool functions
-**************************************/
-#define ZSTD_VERSION_MAJOR    0    /* for breaking interface changes  */
-#define ZSTD_VERSION_MINOR    1    /* for new (non-breaking) interface capabilities */
-#define ZSTD_VERSION_RELEASE  3    /* for tweaks, bug-fixes, or development */
-#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
-
-/**************************************************************
-*   Decompression code
-**************************************************************/
-
-static size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
-{
-    const BYTE* const in = (const BYTE* const)src;
-    BYTE headerFlags;
-    U32 cSize;
-
-    if (srcSize < 3) return (size_t)-ZSTD_ERROR_SrcSize;
-
-    headerFlags = *in;
-    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);
-
-    bpPtr->blockType = (blockType_t)(headerFlags >> 6);
-    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;
-
-    if (bpPtr->blockType == bt_end) return 0;
-    if (bpPtr->blockType == bt_rle) return 1;
-    return cSize;
-}
-
-
-static size_t ZSTD_copyUncompressedBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    if (srcSize > maxDstSize) return (size_t)-ZSTD_ERROR_maxDstSize_tooSmall;
-    memcpy(dst, src, srcSize);
-    return srcSize;
-}
-
-
-static size_t ZSTD_decompressLiterals(void* ctx,
-                                      void* dst, size_t maxDstSize,
-                                const void* src, size_t srcSize)
-{
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + maxDstSize;
-    const BYTE* ip = (const BYTE*)src;
-    size_t errorCode;
-    size_t litSize;
-
-    /* check : minimum 2, for litSize, +1, for content */
-    if (srcSize <= 3) return (size_t)-ZSTD_ERROR_corruption;
-
-    litSize = ip[1] + (ip[0]<<8);
-    litSize += ((ip[-3] >> 3) & 7) << 16;   // mmmmh....
-    op = oend - litSize;
-
-    (void)ctx;
-    if (litSize > maxDstSize) return (size_t)-ZSTD_ERROR_maxDstSize_tooSmall;
-    errorCode = HUF_decompress(op, litSize, ip+2, srcSize-2);
-    if (FSE_isError(errorCode)) return (size_t)-ZSTD_ERROR_GENERIC;
-    return litSize;
-}
-
-
-static size_t ZSTD_decodeLiteralsBlock(void* ctx,
-                                void* dst, size_t maxDstSize,
-                          const BYTE** litStart, size_t* litSize,
-                          const void* src, size_t srcSize)
-{
-    const BYTE* const istart = (const BYTE* const)src;
-    const BYTE* ip = istart;
-    BYTE* const ostart = (BYTE* const)dst;
-    BYTE* const oend = ostart + maxDstSize;
-    blockProperties_t litbp;
-
-    size_t litcSize = ZSTD_getcBlockSize(src, srcSize, &litbp);
-    if (ZSTD_isError(litcSize)) return litcSize;
-    if (litcSize > srcSize - ZSTD_blockHeaderSize) return (size_t)-ZSTD_ERROR_SrcSize;
-    ip += ZSTD_blockHeaderSize;
-
-    switch(litbp.blockType)
-    {
-    case bt_raw:
-        *litStart = ip;
-        ip += litcSize;
-        *litSize = litcSize;
-        break;
-    case bt_rle:
-        {
-            size_t rleSize = litbp.origSize;
-            if (rleSize>maxDstSize) return (size_t)-ZSTD_ERROR_maxDstSize_tooSmall;
-            memset(oend - rleSize, *ip, rleSize);
-            *litStart = oend - rleSize;
-            *litSize = rleSize;
-            ip++;
-            break;
-        }
-    case bt_compressed:
-        {
-            size_t decodedLitSize = ZSTD_decompressLiterals(ctx, dst, maxDstSize, ip, litcSize);
-            if (ZSTD_isError(decodedLitSize)) return decodedLitSize;
-            *litStart = oend - decodedLitSize;
-            *litSize = decodedLitSize;
-            ip += litcSize;
-            break;
-        }
-    case bt_end:
-    default:
-        return (size_t)-ZSTD_ERROR_GENERIC;
-    }
-
-    return ip-istart;
-}
-
-
-static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,
-                         FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb,
-                         const void* src, size_t srcSize)
-{
-    const BYTE* const istart = (const BYTE* const)src;
-    const BYTE* ip = istart;
-    const BYTE* const iend = istart + srcSize;
-    U32 LLtype, Offtype, MLtype;
-    U32 LLlog, Offlog, MLlog;
-    size_t dumpsLength;
-
-    /* check */
-    if (srcSize < 5) return (size_t)-ZSTD_ERROR_SrcSize;
-
-    /* SeqHead */
-    *nbSeq = ZSTD_readLE16(ip); ip+=2;
-    LLtype  = *ip >> 6;
-    Offtype = (*ip >> 4) & 3;
-    MLtype  = (*ip >> 2) & 3;
-    if (*ip & 2)
-    {
-        dumpsLength  = ip[2];
-        dumpsLength += ip[1] << 8;
-        ip += 3;
-    }
-    else
-    {
-        dumpsLength  = ip[1];
-        dumpsLength += (ip[0] & 1) << 8;
-        ip += 2;
-    }
-    *dumpsPtr = ip;
-    ip += dumpsLength;
-    *dumpsLengthPtr = dumpsLength;
-
-    /* check */
-    if (ip > iend-3) return (size_t)-ZSTD_ERROR_SrcSize; /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */
-
-    /* sequences */
-    {
-        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL and MaxOff */
-        size_t headerSize;
-
-        /* Build DTables */
-        switch(LLtype)
-        {
-        U32 max;
-        case bt_rle :
-            LLlog = 0;
-            FSE_buildDTable_rle(DTableLL, *ip++); break;
-        case bt_raw :
-            LLlog = LLbits;
-            FSE_buildDTable_raw(DTableLL, LLbits); break;
-        default :
-            max = MaxLL;
-            headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);
-            if (FSE_isError(headerSize)) return (size_t)-ZSTD_ERROR_GENERIC;
-            if (LLlog > LLFSELog) return (size_t)-ZSTD_ERROR_corruption;
-            ip += headerSize;
-            FSE_buildDTable(DTableLL, norm, max, LLlog);
-        }
-
-        switch(Offtype)
-        {
-        U32 max;
-        case bt_rle :
-            Offlog = 0;
-            if (ip > iend-2) return (size_t)-ZSTD_ERROR_SrcSize; /* min : "raw", hence no header, but at least xxLog bits */
-            FSE_buildDTable_rle(DTableOffb, *ip++); break;
-        case bt_raw :
-            Offlog = Offbits;
-            FSE_buildDTable_raw(DTableOffb, Offbits); break;
-        default :
-            max = MaxOff;
-            headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);
-            if (FSE_isError(headerSize)) return (size_t)-ZSTD_ERROR_GENERIC;
-            if (Offlog > OffFSELog) return (size_t)-ZSTD_ERROR_corruption;
-            ip += headerSize;
-            FSE_buildDTable(DTableOffb, norm, max, Offlog);
-        }
-
-        switch(MLtype)
-        {
-        U32 max;
-        case bt_rle :
-            MLlog = 0;
-            if (ip > iend-2) return (size_t)-ZSTD_ERROR_SrcSize; /* min : "raw", hence no header, but at least xxLog bits */
-            FSE_buildDTable_rle(DTableML, *ip++); break;
-        case bt_raw :
-            MLlog = MLbits;
-            FSE_buildDTable_raw(DTableML, MLbits); break;
-        default :
-            max = MaxML;
-            headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);
-            if (FSE_isError(headerSize)) return (size_t)-ZSTD_ERROR_GENERIC;
-            if (MLlog > MLFSELog) return (size_t)-ZSTD_ERROR_corruption;
-            ip += headerSize;
-            FSE_buildDTable(DTableML, norm, max, MLlog);
-        }
-    }
-
-    return ip-istart;
-}
-
-
-typedef struct {
-    size_t litLength;
-    size_t offset;
-    size_t matchLength;
-} seq_t;
-
-typedef struct {
-    FSE_DStream_t DStream;
-    FSE_DState_t stateLL;
-    FSE_DState_t stateOffb;
-    FSE_DState_t stateML;
-    size_t prevOffset;
-    const BYTE* dumps;
-    const BYTE* dumpsEnd;
-} seqState_t;
-
-
-static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState)
-{
-    size_t litLength;
-    size_t prevOffset;
-    size_t offset;
-    size_t matchLength;
-    const BYTE* dumps = seqState->dumps;
-    const BYTE* const de = seqState->dumpsEnd;
-
-    /* Literal length */
-    litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream));
-    prevOffset = litLength ? seq->offset : seqState->prevOffset;
-    seqState->prevOffset = seq->offset;
-    if (litLength == MaxLL)
-    {
-        U32 add = dumps<de ? *dumps++ : 0;
-        if (add < 255) litLength += add;
-        else
-        {
-            if (dumps<=(de-3))
-            {
-                litLength = ZSTD_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */
-                dumps += 3;
-            }
-        }
-    }
-
-    /* Offset */
-    {
-        U32 offsetCode, nbBits;
-        offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream));
-        if (ZSTD_32bits()) FSE_reloadDStream(&(seqState->DStream));
-        nbBits = offsetCode - 1;
-        if (offsetCode==0) nbBits = 0;   /* cmove */
-        offset = ((size_t)1 << (nbBits & ((sizeof(offset)*8)-1))) + FSE_readBits(&(seqState->DStream), nbBits);
-        if (ZSTD_32bits()) FSE_reloadDStream(&(seqState->DStream));
-        if (offsetCode==0) offset = prevOffset;
-    }
-
-    /* MatchLength */
-    matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream));
-    if (matchLength == MaxML)
-    {
-        U32 add = dumps<de ? *dumps++ : 0;
-        if (add < 255) matchLength += add;
-        else
-        {
-            if (dumps<=(de-3))
-            {
-                matchLength = ZSTD_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */
-                dumps += 3;
-            }
-        }
-    }
-    matchLength += MINMATCH;
-
-    /* save result */
-    seq->litLength = litLength;
-    seq->offset = offset;
-    seq->matchLength = matchLength;
-    seqState->dumps = dumps;
-}
-
-
-static size_t ZSTD_execSequence(BYTE* op,
-                                seq_t sequence,
-                                const BYTE** litPtr, const BYTE* const litLimit,
-                                BYTE* const base, BYTE* const oend)
-{
-    static const int dec32table[] = {0, 1, 2, 1, 4, 4, 4, 4};   /* added */
-    static const int dec64table[] = {8, 8, 8, 7, 8, 9,10,11};   /* substracted */
-    const BYTE* const ostart = op;
-    const size_t litLength = sequence.litLength;
-    BYTE* const endMatch = op + litLength + sequence.matchLength;    /* risk : address space overflow (32-bits) */
-    const BYTE* const litEnd = *litPtr + litLength;
-
-    /* check */
-    if (endMatch > oend) return (size_t)-ZSTD_ERROR_maxDstSize_tooSmall;   /* overwrite beyond dst buffer */
-    if (litEnd > litLimit) return (size_t)-ZSTD_ERROR_corruption;
-    if (sequence.matchLength > (size_t)(*litPtr-op))  return (size_t)-ZSTD_ERROR_maxDstSize_tooSmall;    /* overwrite literal segment */
-
-    /* copy Literals */
-    if (((size_t)(*litPtr - op) < 8) || ((size_t)(oend-litEnd) < 8) || (op+litLength > oend-8))
-        memmove(op, *litPtr, litLength);   /* overwrite risk */
-    else
-        ZSTD_wildcopy(op, *litPtr, litLength);
-    op += litLength;
-    *litPtr = litEnd;   /* update for next sequence */
-
-    /* check : last match must be at a minimum distance of 8 from end of dest buffer */
-    if (oend-op < 8) return (size_t)-ZSTD_ERROR_maxDstSize_tooSmall;
-
-    /* copy Match */
-    {
-        const U32 overlapRisk = (((size_t)(litEnd - endMatch)) < 12);
-        const BYTE* match = op - sequence.offset;            /* possible underflow at op - offset ? */
-        size_t qutt = 12;
-        U64 saved[2];
-
-        /* check */
-        if (match < base) return (size_t)-ZSTD_ERROR_corruption;
-        if (sequence.offset > (size_t)base) return (size_t)-ZSTD_ERROR_corruption;
-
-        /* save beginning of literal sequence, in case of write overlap */
-        if (overlapRisk)
-        {
-            if ((endMatch + qutt) > oend) qutt = oend-endMatch;
-            memcpy(saved, endMatch, qutt);
-        }
-
-        if (sequence.offset < 8)
-        {
-            const int dec64 = dec64table[sequence.offset];
-            op[0] = match[0];
-            op[1] = match[1];
-            op[2] = match[2];
-            op[3] = match[3];
-            match += dec32table[sequence.offset];
-            ZSTD_copy4(op+4, match);
-            match -= dec64;
-        } else { ZSTD_copy8(op, match); }
-        op += 8; match += 8;
-
-        if (endMatch > oend-12)
-        {
-            if (op < oend-8)
-            {
-                ZSTD_wildcopy(op, match, (oend-8) - op);
-                match += (oend-8) - op;
-                op = oend-8;
-            }
-            while (op<endMatch) *op++ = *match++;
-        }
-        else
-            ZSTD_wildcopy(op, match, sequence.matchLength-8);   /* works even if matchLength < 8 */
-
-        /* restore, in case of overlap */
-        if (overlapRisk) memcpy(endMatch, saved, qutt);
-    }
-
-    return endMatch-ostart;
-}
-
-typedef struct ZSTDv01_Dctx_s
-{
-    U32 LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)];
-    U32 OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)];
-    U32 MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)];
-    void* previousDstEnd;
-    void* base;
-    size_t expected;
-    blockType_t bType;
-    U32 phase;
-} dctx_t;
-
-
-static size_t ZSTD_decompressSequences(
-                               void* ctx,
-                               void* dst, size_t maxDstSize,
-                         const void* seqStart, size_t seqSize,
-                         const BYTE* litStart, size_t litSize)
-{
-    dctx_t* dctx = (dctx_t*)ctx;
-    const BYTE* ip = (const BYTE*)seqStart;
-    const BYTE* const iend = ip + seqSize;
-    BYTE* const ostart = (BYTE* const)dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + maxDstSize;
-    size_t errorCode, dumpsLength;
-    const BYTE* litPtr = litStart;
-    const BYTE* const litEnd = litStart + litSize;
-    int nbSeq;
-    const BYTE* dumps;
-    U32* DTableLL = dctx->LLTable;
-    U32* DTableML = dctx->MLTable;
-    U32* DTableOffb = dctx->OffTable;
-    BYTE* const base = (BYTE*) (dctx->base);
-
-    /* Build Decoding Tables */
-    errorCode = ZSTD_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,
-                                      DTableLL, DTableML, DTableOffb,
-                                      ip, iend-ip);
-    if (ZSTD_isError(errorCode)) return errorCode;
-    ip += errorCode;
-
-    /* Regen sequences */
-    {
-        seq_t sequence;
-        seqState_t seqState;
-
-        memset(&sequence, 0, sizeof(sequence));
-        seqState.dumps = dumps;
-        seqState.dumpsEnd = dumps + dumpsLength;
-        seqState.prevOffset = 1;
-        errorCode = FSE_initDStream(&(seqState.DStream), ip, iend-ip);
-        if (FSE_isError(errorCode)) return (size_t)-ZSTD_ERROR_corruption;
-        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
-        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
-        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
-
-        for ( ; (FSE_reloadDStream(&(seqState.DStream)) <= FSE_DStream_completed) && (nbSeq>0) ; )
-        {
-            size_t oneSeqSize;
-            nbSeq--;
-            ZSTD_decodeSequence(&sequence, &seqState);
-            oneSeqSize = ZSTD_execSequence(op, sequence, &litPtr, litEnd, base, oend);
-            if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
-            op += oneSeqSize;
-        }
-
-        /* check if reached exact end */
-        if ( !FSE_endOfDStream(&(seqState.DStream)) ) return (size_t)-ZSTD_ERROR_corruption;   /* requested too much : data is corrupted */
-        if (nbSeq<0) return (size_t)-ZSTD_ERROR_corruption;   /* requested too many sequences : data is corrupted */
-
-        /* last literal segment */
-        {
-            size_t lastLLSize = litEnd - litPtr;
-            if (op+lastLLSize > oend) return (size_t)-ZSTD_ERROR_maxDstSize_tooSmall;
-            if (op != litPtr) memmove(op, litPtr, lastLLSize);
-            op += lastLLSize;
-        }
-    }
-
-    return op-ostart;
-}
-
-
-static size_t ZSTD_decompressBlock(
-                            void* ctx,
-                            void* dst, size_t maxDstSize,
-                      const void* src, size_t srcSize)
-{
-    /* blockType == blockCompressed, srcSize is trusted */
-    const BYTE* ip = (const BYTE*)src;
-    const BYTE* litPtr = NULL;
-    size_t litSize = 0;
-    size_t errorCode;
-
-    /* Decode literals sub-block */
-    errorCode = ZSTD_decodeLiteralsBlock(ctx, dst, maxDstSize, &litPtr, &litSize, src, srcSize);
-    if (ZSTD_isError(errorCode)) return errorCode;
-    ip += errorCode;
-    srcSize -= errorCode;
-
-    return ZSTD_decompressSequences(ctx, dst, maxDstSize, ip, srcSize, litPtr, litSize);
-}
-
-
-size_t ZSTDv01_decompressDCtx(void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    const BYTE* ip = (const BYTE*)src;
-    const BYTE* iend = ip + srcSize;
-    BYTE* const ostart = (BYTE* const)dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + maxDstSize;
-    size_t remainingSize = srcSize;
-    U32 magicNumber;
-    size_t errorCode=0;
-    blockProperties_t blockProperties;
-
-    /* Frame Header */
-    if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) return (size_t)-ZSTD_ERROR_SrcSize;
-    magicNumber = ZSTD_readBE32(src);
-    if (magicNumber != ZSTD_magicNumber) return (size_t)-ZSTD_ERROR_MagicNumber;
-    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize;
-
-    /* Loop on each block */
-    while (1)
-    {
-        size_t blockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties);
-        if (ZSTD_isError(blockSize)) return blockSize;
-
-        ip += ZSTD_blockHeaderSize;
-        remainingSize -= ZSTD_blockHeaderSize;
-        if (blockSize > remainingSize) return (size_t)-ZSTD_ERROR_SrcSize;
-
-        switch(blockProperties.blockType)
-        {
-        case bt_compressed:
-            errorCode = ZSTD_decompressBlock(ctx, op, oend-op, ip, blockSize);
-            break;
-        case bt_raw :
-            errorCode = ZSTD_copyUncompressedBlock(op, oend-op, ip, blockSize);
-            break;
-        case bt_rle :
-            return (size_t)-ZSTD_ERROR_GENERIC;   /* not yet supported */
-            break;
-        case bt_end :
-            /* end of frame */
-            if (remainingSize) return (size_t)-ZSTD_ERROR_SrcSize;
-            break;
-        default:
-            return (size_t)-ZSTD_ERROR_GENERIC;
-        }
-        if (blockSize == 0) break;   /* bt_end */
-
-        if (ZSTD_isError(errorCode)) return errorCode;
-        op += errorCode;
-        ip += blockSize;
-        remainingSize -= blockSize;
-    }
-
-    return op-ostart;
-}
-
-size_t ZSTDv01_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    dctx_t ctx;
-    ctx.base = dst;
-    return ZSTDv01_decompressDCtx(&ctx, dst, maxDstSize, src, srcSize);
-}
-
-
-/*******************************
-*  Streaming Decompression API
-*******************************/
-
-size_t ZSTDv01_resetDCtx(ZSTDv01_Dctx* dctx)
-{
-    dctx->expected = ZSTD_frameHeaderSize;
-    dctx->phase = 0;
-    dctx->previousDstEnd = NULL;
-    dctx->base = NULL;
-    return 0;
-}
-
-ZSTDv01_Dctx* ZSTDv01_createDCtx(void)
-{
-    ZSTDv01_Dctx* dctx = (ZSTDv01_Dctx*)malloc(sizeof(ZSTDv01_Dctx));
-    if (dctx==NULL) return NULL;
-    ZSTDv01_resetDCtx(dctx);
-    return dctx;
-}
-
-size_t ZSTDv01_freeDCtx(ZSTDv01_Dctx* dctx)
-{
-    free(dctx);
-    return 0;
-}
-
-size_t ZSTDv01_nextSrcSizeToDecompress(ZSTDv01_Dctx* dctx)
-{
-    return ((dctx_t*)dctx)->expected;
-}
-
-size_t ZSTDv01_decompressContinue(ZSTDv01_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    dctx_t* ctx = (dctx_t*)dctx;
-
-    /* Sanity check */
-    if (srcSize != ctx->expected) return (size_t)-ZSTD_ERROR_SrcSize;
-    if (dst != ctx->previousDstEnd)  /* not contiguous */
-        ctx->base = dst;
-
-    /* Decompress : frame header */
-    if (ctx->phase == 0)
-    {
-        /* Check frame magic header */
-        U32 magicNumber = ZSTD_readBE32(src);
-        if (magicNumber != ZSTD_magicNumber) return (size_t)-ZSTD_ERROR_MagicNumber;
-        ctx->phase = 1;
-        ctx->expected = ZSTD_blockHeaderSize;
-        return 0;
-    }
-
-    /* Decompress : block header */
-    if (ctx->phase == 1)
-    {
-        blockProperties_t bp;
-        size_t blockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
-        if (ZSTD_isError(blockSize)) return blockSize;
-        if (bp.blockType == bt_end)
-        {
-            ctx->expected = 0;
-            ctx->phase = 0;
-        }
-        else
-        {
-            ctx->expected = blockSize;
-            ctx->bType = bp.blockType;
-            ctx->phase = 2;
-        }
-
-        return 0;
-    }
-
-    /* Decompress : block content */
-    {
-        size_t rSize;
-        switch(ctx->bType)
-        {
-        case bt_compressed:
-            rSize = ZSTD_decompressBlock(ctx, dst, maxDstSize, src, srcSize);
-            break;
-        case bt_raw :
-            rSize = ZSTD_copyUncompressedBlock(dst, maxDstSize, src, srcSize);
-            break;
-        case bt_rle :
-            return (size_t)-ZSTD_ERROR_GENERIC;   /* not yet handled */
-            break;
-        case bt_end :   /* should never happen (filtered at phase 1) */
-            rSize = 0;
-            break;
-        default:
-            return (size_t)-ZSTD_ERROR_GENERIC;
-        }
-        ctx->phase = 1;
-        ctx->expected = ZSTD_blockHeaderSize;
-        ctx->previousDstEnd = (void*)( ((char*)dst) + rSize);
-        return rSize;
-    }
-
-}
-
-
+(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) 
+{ 
+    void* ptr = dt; 
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; 
+    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)(ptr) + 1;   /* because dt is unsigned, 32-bits aligned on 32-bits */ 
+    const U32 tableSize = 1 << tableLog; 
+    const U32 tableMask = tableSize-1; 
+    const U32 step = FSE_tableStep(tableSize); 
+    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1]; 
+    U32 position = 0; 
+    U32 highThreshold = tableSize-1; 
+    const S16 largeLimit= (S16)(1 << (tableLog-1)); 
+    U32 noLarge = 1; 
+    U32 s; 
+ 
+    /* Sanity Checks */ 
+    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return (size_t)-FSE_ERROR_maxSymbolValue_tooLarge; 
+    if (tableLog > FSE_MAX_TABLELOG) return (size_t)-FSE_ERROR_tableLog_tooLarge; 
+ 
+    /* Init, lay down lowprob symbols */ 
+    DTableH[0].tableLog = (U16)tableLog; 
+    for (s=0; s<=maxSymbolValue; s++) 
+    { 
+        if (normalizedCounter[s]==-1) 
+        { 
+            tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s; 
+            symbolNext[s] = 1; 
+        } 
+        else 
+        { 
+            if (normalizedCounter[s] >= largeLimit) noLarge=0; 
+            symbolNext[s] = normalizedCounter[s]; 
+        } 
+    } 
+ 
+    /* Spread symbols */ 
+    for (s=0; s<=maxSymbolValue; 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 (size_t)-FSE_ERROR_GENERIC;   /* position must reach all cells once, otherwise normalizedCounter is incorrect */ 
+ 
+    /* Build Decoding table */ 
+    { 
+        U32 i; 
+        for (i=0; i<tableSize; i++) 
+        { 
+            FSE_FUNCTION_TYPE symbol = (FSE_FUNCTION_TYPE)(tableDecode[i].symbol); 
+            U16 nextState = symbolNext[symbol]++; 
+            tableDecode[i].nbBits = (BYTE) (tableLog - FSE_highbit32 ((U32)nextState) ); 
+            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize); 
+        } 
+    } 
+ 
+    DTableH->fastMode = (U16)noLarge; 
+    return 0; 
+} 
+ 
+ 
+/****************************************** 
+*  FSE byte symbol 
+******************************************/ 
+#ifndef FSE_COMMONDEFS_ONLY 
+ 
+static unsigned FSE_isError(size_t code) { return (code > (size_t)(-FSE_ERROR_maxCode)); } 
+ 
+static short FSE_abs(short a) 
+{ 
+    return a<0? -a : a; 
+} 
+ 
+ 
+/**************************************************************** 
+*  Header bitstream management 
+****************************************************************/ 
+static 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 (size_t)-FSE_ERROR_srcSize_wrong; 
+    bitStream = FSE_readLE32(ip); 
+    nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */ 
+    if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return (size_t)-FSE_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 = FSE_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 (size_t)-FSE_ERROR_maxSymbolValue_tooSmall; 
+            while (charnum < n0) normalizedCounter[charnum++] = 0; 
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) 
+            { 
+                ip += bitCount>>3; 
+                bitCount &= 7; 
+                bitStream = FSE_readLE32(ip) >> bitCount; 
+            } 
+            else 
+                bitStream >>= 2; 
+        } 
+        { 
+            const short 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 = FSE_readLE32(ip) >> (bitCount & 31); 
+            } 
+        } 
+    } 
+    if (remaining != 1) return (size_t)-FSE_ERROR_GENERIC; 
+    *maxSVPtr = charnum-1; 
+ 
+    ip += (bitCount+7)>>3; 
+    if ((size_t)(ip-istart) > hbSize) return (size_t)-FSE_ERROR_srcSize_wrong; 
+    return ip-istart; 
+} 
+ 
+ 
+/********************************************************* 
+*  Decompression (Byte symbols) 
+*********************************************************/ 
+static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue) 
+{ 
+    void* ptr = dt; 
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; 
+    FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */ 
+ 
+    DTableH->tableLog = 0; 
+    DTableH->fastMode = 0; 
+ 
+    cell->newState = 0; 
+    cell->symbol = symbolValue; 
+    cell->nbBits = 0; 
+ 
+    return 0; 
+} 
+ 
+ 
+static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits) 
+{ 
+    void* ptr = dt; 
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; 
+    FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */ 
+    const unsigned tableSize = 1 << nbBits; 
+    const unsigned tableMask = tableSize - 1; 
+    const unsigned maxSymbolValue = tableMask; 
+    unsigned s; 
+ 
+    /* Sanity checks */ 
+    if (nbBits < 1) return (size_t)-FSE_ERROR_GENERIC;             /* min size */ 
+ 
+    /* Build Decoding Table */ 
+    DTableH->tableLog = (U16)nbBits; 
+    DTableH->fastMode = 1; 
+    for (s=0; s<=maxSymbolValue; s++) 
+    { 
+        dinfo[s].newState = 0; 
+        dinfo[s].symbol = (BYTE)s; 
+        dinfo[s].nbBits = (BYTE)nbBits; 
+    } 
+ 
+    return 0; 
+} 
+ 
+ 
+/* FSE_initDStream 
+ * Initialize a FSE_DStream_t. 
+ * srcBuffer must point at the beginning of an FSE block. 
+ * The function result is the size of the FSE_block (== srcSize). 
+ * If srcSize is too small, the function will return an errorCode; 
+ */ 
+static size_t FSE_initDStream(FSE_DStream_t* bitD, const void* srcBuffer, size_t srcSize) 
+{ 
+    if (srcSize < 1) return (size_t)-FSE_ERROR_srcSize_wrong; 
+ 
+    if (srcSize >=  sizeof(size_t)) 
+    { 
+        U32 contain32; 
+        bitD->start = (const char*)srcBuffer; 
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t); 
+        bitD->bitContainer = FSE_readLEST(bitD->ptr); 
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1]; 
+        if (contain32 == 0) return (size_t)-FSE_ERROR_GENERIC;   /* stop bit not present */ 
+        bitD->bitsConsumed = 8 - FSE_highbit32(contain32); 
+    } 
+    else 
+    { 
+        U32 contain32; 
+        bitD->start = (const char*)srcBuffer; 
+        bitD->ptr   = bitD->start; 
+        bitD->bitContainer = *(const BYTE*)(bitD->start); 
+        switch(srcSize) 
+        { 
+            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16); 
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24); 
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32); 
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; 
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; 
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8; 
+            default:; 
+        } 
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1]; 
+        if (contain32 == 0) return (size_t)-FSE_ERROR_GENERIC;   /* stop bit not present */ 
+        bitD->bitsConsumed = 8 - FSE_highbit32(contain32); 
+        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8; 
+    } 
+ 
+    return srcSize; 
+} 
+ 
+ 
+/*!FSE_lookBits 
+ * Provides next n bits from the bitContainer. 
+ * bitContainer is not modified (bits are still present for next read/look) 
+ * On 32-bits, maxNbBits==25 
+ * On 64-bits, maxNbBits==57 
+ * return : value extracted. 
+ */ 
+static size_t FSE_lookBits(FSE_DStream_t* bitD, U32 nbBits) 
+{ 
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1; 
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask); 
+} 
+ 
+static size_t FSE_lookBitsFast(FSE_DStream_t* bitD, U32 nbBits)   /* only if nbBits >= 1 !! */ 
+{ 
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1; 
+    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask); 
+} 
+ 
+static void FSE_skipBits(FSE_DStream_t* bitD, U32 nbBits) 
+{ 
+    bitD->bitsConsumed += nbBits; 
+} 
+ 
+ 
+/*!FSE_readBits 
+ * Read next n bits from the bitContainer. 
+ * On 32-bits, don't read more than maxNbBits==25 
+ * On 64-bits, don't read more than maxNbBits==57 
+ * Use the fast variant *only* if n >= 1. 
+ * return : value extracted. 
+ */ 
+static size_t FSE_readBits(FSE_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t value = FSE_lookBits(bitD, nbBits); 
+    FSE_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+static size_t FSE_readBitsFast(FSE_DStream_t* bitD, U32 nbBits)   /* only if nbBits >= 1 !! */ 
+{ 
+    size_t value = FSE_lookBitsFast(bitD, nbBits); 
+    FSE_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+static unsigned FSE_reloadDStream(FSE_DStream_t* bitD) 
+{ 
+    if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */ 
+        return FSE_DStream_tooFar; 
+ 
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) 
+    { 
+        bitD->ptr -= bitD->bitsConsumed >> 3; 
+        bitD->bitsConsumed &= 7; 
+        bitD->bitContainer = FSE_readLEST(bitD->ptr); 
+        return FSE_DStream_unfinished; 
+    } 
+    if (bitD->ptr == bitD->start) 
+    { 
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return FSE_DStream_endOfBuffer; 
+        return FSE_DStream_completed; 
+    } 
+    { 
+        U32 nbBytes = bitD->bitsConsumed >> 3; 
+        U32 result = FSE_DStream_unfinished; 
+        if (bitD->ptr - nbBytes < bitD->start) 
+        { 
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */ 
+            result = FSE_DStream_endOfBuffer; 
+        } 
+        bitD->ptr -= nbBytes; 
+        bitD->bitsConsumed -= nbBytes*8; 
+        bitD->bitContainer = FSE_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */ 
+        return result; 
+    } 
+} 
+ 
+ 
+static void FSE_initDState(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD, const FSE_DTable* dt) 
+{ 
+    const void* ptr = dt; 
+    const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr; 
+    DStatePtr->state = FSE_readBits(bitD, DTableH->tableLog); 
+    FSE_reloadDStream(bitD); 
+    DStatePtr->table = dt + 1; 
+} 
+ 
+static BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD) 
+{ 
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    const U32  nbBits = DInfo.nbBits; 
+    BYTE symbol = DInfo.symbol; 
+    size_t lowBits = FSE_readBits(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+static BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD) 
+{ 
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    const U32 nbBits = DInfo.nbBits; 
+    BYTE symbol = DInfo.symbol; 
+    size_t lowBits = FSE_readBitsFast(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+/* FSE_endOfDStream 
+   Tells if bitD has reached end of bitStream or not */ 
+ 
+static unsigned FSE_endOfDStream(const FSE_DStream_t* bitD) 
+{ 
+    return ((bitD->ptr == bitD->start) && (bitD->bitsConsumed == sizeof(bitD->bitContainer)*8)); 
+} 
+ 
+static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr) 
+{ 
+    return DStatePtr->state == 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; 
+ 
+    FSE_DStream_t bitD; 
+    FSE_DState_t state1; 
+    FSE_DState_t state2; 
+    size_t errorCode; 
+ 
+    /* Init */ 
+    errorCode = FSE_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 ( ; (FSE_reloadDStream(&bitD)==FSE_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 */ 
+            FSE_reloadDStream(&bitD); 
+ 
+        op[1] = FSE_GETSYMBOL(&state2); 
+ 
+        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            { if (FSE_reloadDStream(&bitD) > FSE_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 */ 
+            FSE_reloadDStream(&bitD); 
+ 
+        op[3] = FSE_GETSYMBOL(&state2); 
+    } 
+ 
+    /* tail */ 
+    /* note : FSE_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly FSE_DStream_completed */ 
+    while (1) 
+    { 
+        if ( (FSE_reloadDStream(&bitD)>FSE_DStream_completed) || (op==omax) || (FSE_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) ) 
+            break; 
+ 
+        *op++ = FSE_GETSYMBOL(&state1); 
+ 
+        if ( (FSE_reloadDStream(&bitD)>FSE_DStream_completed) || (op==omax) || (FSE_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) ) 
+            break; 
+ 
+        *op++ = FSE_GETSYMBOL(&state2); 
+    } 
+ 
+    /* end ? */ 
+    if (FSE_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2)) 
+        return op-ostart; 
+ 
+    if (op==omax) return (size_t)-FSE_ERROR_dstSize_tooSmall;   /* dst buffer is full, but cSrc unfinished */ 
+ 
+    return (size_t)-FSE_ERROR_corruptionDetected; 
+} 
+ 
+ 
+static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize, 
+                            const void* cSrc, size_t cSrcSize, 
+                            const FSE_DTable* dt) 
+{ 
+    FSE_DTableHeader DTableH; 
+    memcpy(&DTableH, dt, sizeof(DTableH));   /* memcpy() into local variable, to avoid strict aliasing warning */ 
+ 
+    /* select fast mode (static) */ 
+    if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1); 
+    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0); 
+} 
+ 
+ 
+static 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; 
+    size_t errorCode; 
+ 
+    if (cSrcSize<2) return (size_t)-FSE_ERROR_srcSize_wrong;   /* too small input size */ 
+ 
+    /* normal FSE decoding mode */ 
+    errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize); 
+    if (FSE_isError(errorCode)) return errorCode; 
+    if (errorCode >= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong;   /* too small input size */ 
+    ip += errorCode; 
+    cSrcSize -= errorCode; 
+ 
+    errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog); 
+    if (FSE_isError(errorCode)) return errorCode; 
+ 
+    /* always return, even if it is an error code */ 
+    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt); 
+} 
+ 
+ 
+ 
+/* ******************************************************* 
+*  Huff0 : Huffman block compression 
+*********************************************************/ 
+#define HUF_MAX_SYMBOL_VALUE 255 
+#define HUF_DEFAULT_TABLELOG  12       /* used by default, when not specified */ 
+#define HUF_MAX_TABLELOG  12           /* max possible tableLog; for allocation purpose; can be modified */ 
+#define HUF_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */ 
+#if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG) 
+#  error "HUF_MAX_TABLELOG is too large !" 
+#endif 
+ 
+typedef struct HUF_CElt_s { 
+  U16  val; 
+  BYTE nbBits; 
+} HUF_CElt ; 
+ 
+typedef struct nodeElt_s { 
+    U32 count; 
+    U16 parent; 
+    BYTE byte; 
+    BYTE nbBits; 
+} nodeElt; 
+ 
+ 
+/* ******************************************************* 
+*  Huff0 : Huffman block decompression 
+*********************************************************/ 
+typedef struct { 
+    BYTE byte; 
+    BYTE nbBits; 
+} HUF_DElt; 
+ 
+static size_t HUF_readDTable (U16* DTable, const void* src, size_t srcSize) 
+{ 
+    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1]; 
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];  /* large enough for values from 0 to 16 */ 
+    U32 weightTotal; 
+    U32 maxBits; 
+    const BYTE* ip = (const BYTE*) src; 
+    size_t iSize = ip[0]; 
+    size_t oSize; 
+    U32 n; 
+    U32 nextRankStart; 
+    void* ptr = DTable+1; 
+    HUF_DElt* const dt = (HUF_DElt*)ptr; 
+ 
+    FSE_STATIC_ASSERT(sizeof(HUF_DElt) == sizeof(U16));   /* if compilation fails here, assertion is false */ 
+    //memset(huffWeight, 0, sizeof(huffWeight));   /* should not be necessary, but some analyzer complain ... */ 
+    if (iSize >= 128)  /* special header */ 
+    { 
+        if (iSize >= (242))   /* RLE */ 
+        { 
+            static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 }; 
+            oSize = l[iSize-242]; 
+            memset(huffWeight, 1, sizeof(huffWeight)); 
+            iSize = 0; 
+        } 
+        else   /* Incompressible */ 
+        { 
+            oSize = iSize - 127; 
+            iSize = ((oSize+1)/2); 
+            if (iSize+1 > srcSize) return (size_t)-FSE_ERROR_srcSize_wrong; 
+            ip += 1; 
+            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 (size_t)-FSE_ERROR_srcSize_wrong; 
+        oSize = FSE_decompress(huffWeight, HUF_MAX_SYMBOL_VALUE, ip+1, iSize);   /* max 255 values decoded, last one is implied */ 
+        if (FSE_isError(oSize)) return oSize; 
+    } 
+ 
+    /* collect weight stats */ 
+    memset(rankVal, 0, sizeof(rankVal)); 
+    weightTotal = 0; 
+    for (n=0; n<oSize; n++) 
+    { 
+        if (huffWeight[n] >= HUF_ABSOLUTEMAX_TABLELOG) return (size_t)-FSE_ERROR_corruptionDetected; 
+        rankVal[huffWeight[n]]++; 
+        weightTotal += (1 << huffWeight[n]) >> 1; 
+    } 
+ 
+    /* get last non-null symbol weight (implied, total must be 2^n) */ 
+    maxBits = FSE_highbit32(weightTotal) + 1; 
+    if (maxBits > DTable[0]) return (size_t)-FSE_ERROR_tableLog_tooLarge;   /* DTable is too small */ 
+    DTable[0] = (U16)maxBits; 
+    { 
+        U32 total = 1 << maxBits; 
+        U32 rest = total - weightTotal; 
+        U32 verif = 1 << FSE_highbit32(rest); 
+        U32 lastWeight = FSE_highbit32(rest) + 1; 
+        if (verif != rest) return (size_t)-FSE_ERROR_corruptionDetected;    /* last value must be a clean power of 2 */ 
+        huffWeight[oSize] = (BYTE)lastWeight; 
+        rankVal[lastWeight]++; 
+    } 
+ 
+    /* check tree construction validity */ 
+    if ((rankVal[1] < 2) || (rankVal[1] & 1)) return (size_t)-FSE_ERROR_corruptionDetected;   /* by construction : at least 2 elts of rank 1, must be even */ 
+ 
+    /* Prepare ranks */ 
+    nextRankStart = 0; 
+    for (n=1; n<=maxBits; n++) 
+    { 
+        U32 current = nextRankStart; 
+        nextRankStart += (rankVal[n] << (n-1)); 
+        rankVal[n] = current; 
+    } 
+ 
+    /* fill DTable */ 
+    for (n=0; n<=oSize; n++) 
+    { 
+        const U32 w = huffWeight[n]; 
+        const U32 length = (1 << w) >> 1; 
+        U32 i; 
+        HUF_DElt D; 
+        D.byte = (BYTE)n; D.nbBits = (BYTE)(maxBits + 1 - w); 
+        for (i = rankVal[w]; i < rankVal[w] + length; i++) 
+            dt[i] = D; 
+        rankVal[w] += length; 
+    } 
+ 
+    return iSize+1; 
+} 
+ 
+ 
+static BYTE HUF_decodeSymbol(FSE_DStream_t* Dstream, const HUF_DElt* dt, const U32 dtLog) 
+{ 
+        const size_t val = FSE_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */ 
+        const BYTE c = dt[val].byte; 
+        FSE_skipBits(Dstream, dt[val].nbBits); 
+        return c; 
+} 
+ 
+static size_t HUF_decompress_usingDTable(   /* -3% slower when non static */ 
+          void* dst, size_t maxDstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const U16* DTable) 
+{ 
+    BYTE* const ostart = (BYTE*) dst; 
+    BYTE* op = ostart; 
+    BYTE* const omax = op + maxDstSize; 
+    BYTE* const olimit = omax-15; 
+ 
+    const void* ptr = DTable; 
+    const HUF_DElt* const dt = (const HUF_DElt*)(ptr)+1; 
+    const U32 dtLog = DTable[0]; 
+    size_t errorCode; 
+    U32 reloadStatus; 
+ 
+    /* Init */ 
+ 
+    const U16* jumpTable = (const U16*)cSrc; 
+    const size_t length1 = FSE_readLE16(jumpTable); 
+    const size_t length2 = FSE_readLE16(jumpTable+1); 
+    const size_t length3 = FSE_readLE16(jumpTable+2); 
+    const size_t length4 = cSrcSize - 6 - length1 - length2 - length3;   // check coherency !! 
+    const char* const start1 = (const char*)(cSrc) + 6; 
+    const char* const start2 = start1 + length1; 
+    const char* const start3 = start2 + length2; 
+    const char* const start4 = start3 + length3; 
+    FSE_DStream_t bitD1, bitD2, bitD3, bitD4; 
+ 
+    if (length1+length2+length3+6 >= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong; 
+ 
+    errorCode = FSE_initDStream(&bitD1, start1, length1); 
+    if (FSE_isError(errorCode)) return errorCode; 
+    errorCode = FSE_initDStream(&bitD2, start2, length2); 
+    if (FSE_isError(errorCode)) return errorCode; 
+    errorCode = FSE_initDStream(&bitD3, start3, length3); 
+    if (FSE_isError(errorCode)) return errorCode; 
+    errorCode = FSE_initDStream(&bitD4, start4, length4); 
+    if (FSE_isError(errorCode)) return errorCode; 
+ 
+    reloadStatus=FSE_reloadDStream(&bitD2); 
+ 
+    /* 16 symbols per loop */ 
+    for ( ; (reloadStatus<FSE_DStream_completed) && (op<olimit);  /* D2-3-4 are supposed to be synchronized and finish together */ 
+        op+=16, reloadStatus = FSE_reloadDStream(&bitD2) | FSE_reloadDStream(&bitD3) | FSE_reloadDStream(&bitD4), FSE_reloadDStream(&bitD1)) 
+    { 
+#define HUF_DECODE_SYMBOL_0(n, Dstream) \ 
+        op[n] = HUF_decodeSymbol(&Dstream, dt, dtLog); 
+ 
+#define HUF_DECODE_SYMBOL_1(n, Dstream) \ 
+        op[n] = HUF_decodeSymbol(&Dstream, dt, dtLog); \ 
+        if (FSE_32bits() && (HUF_MAX_TABLELOG>12)) FSE_reloadDStream(&Dstream) 
+ 
+#define HUF_DECODE_SYMBOL_2(n, Dstream) \ 
+        op[n] = HUF_decodeSymbol(&Dstream, dt, dtLog); \ 
+        if (FSE_32bits()) FSE_reloadDStream(&Dstream) 
+ 
+        HUF_DECODE_SYMBOL_1( 0, bitD1); 
+        HUF_DECODE_SYMBOL_1( 1, bitD2); 
+        HUF_DECODE_SYMBOL_1( 2, bitD3); 
+        HUF_DECODE_SYMBOL_1( 3, bitD4); 
+        HUF_DECODE_SYMBOL_2( 4, bitD1); 
+        HUF_DECODE_SYMBOL_2( 5, bitD2); 
+        HUF_DECODE_SYMBOL_2( 6, bitD3); 
+        HUF_DECODE_SYMBOL_2( 7, bitD4); 
+        HUF_DECODE_SYMBOL_1( 8, bitD1); 
+        HUF_DECODE_SYMBOL_1( 9, bitD2); 
+        HUF_DECODE_SYMBOL_1(10, bitD3); 
+        HUF_DECODE_SYMBOL_1(11, bitD4); 
+        HUF_DECODE_SYMBOL_0(12, bitD1); 
+        HUF_DECODE_SYMBOL_0(13, bitD2); 
+        HUF_DECODE_SYMBOL_0(14, bitD3); 
+        HUF_DECODE_SYMBOL_0(15, bitD4); 
+    } 
+ 
+    if (reloadStatus!=FSE_DStream_completed)   /* not complete : some bitStream might be FSE_DStream_unfinished */ 
+        return (size_t)-FSE_ERROR_corruptionDetected; 
+ 
+    /* tail */ 
+    { 
+        // bitTail = bitD1;   // *much* slower : -20% !??! 
+        FSE_DStream_t bitTail; 
+        bitTail.ptr = bitD1.ptr; 
+        bitTail.bitsConsumed = bitD1.bitsConsumed; 
+        bitTail.bitContainer = bitD1.bitContainer;   // required in case of FSE_DStream_endOfBuffer 
+        bitTail.start = start1; 
+        for ( ; (FSE_reloadDStream(&bitTail) < FSE_DStream_completed) && (op<omax) ; op++) 
+        { 
+            HUF_DECODE_SYMBOL_0(0, bitTail); 
+        } 
+ 
+        if (FSE_endOfDStream(&bitTail)) 
+            return op-ostart; 
+    } 
+ 
+    if (op==omax) return (size_t)-FSE_ERROR_dstSize_tooSmall;   /* dst buffer is full, but cSrc unfinished */ 
+ 
+    return (size_t)-FSE_ERROR_corruptionDetected; 
+} 
+ 
+ 
+static size_t HUF_decompress (void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUF_CREATE_STATIC_DTABLE(DTable, HUF_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+    size_t errorCode; 
+ 
+    errorCode = HUF_readDTable (DTable, cSrc, cSrcSize); 
+    if (FSE_isError(errorCode)) return errorCode; 
+    if (errorCode >= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong; 
+    ip += errorCode; 
+    cSrcSize -= errorCode; 
+ 
+    return HUF_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, DTable); 
+} 
+ 
+ 
+#endif   /* FSE_COMMONDEFS_ONLY */ 
+ 
+/* 
+    zstd - standard compression library 
+    Header File for static linking only 
+    Copyright (C) 2014-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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+ 
+/* The objects defined into this file should be considered experimental. 
+ * They are not labelled stable, as their prototype may change in the future. 
+ * You can use them for tests, provide feedback, or if you can endure risk of future changes. 
+ */ 
+ 
+/************************************** 
+*  Error management 
+**************************************/ 
+#define ZSTD_LIST_ERRORS(ITEM) \ 
+        ITEM(ZSTD_OK_NoError) ITEM(ZSTD_ERROR_GENERIC) \ 
+        ITEM(ZSTD_ERROR_MagicNumber) \ 
+        ITEM(ZSTD_ERROR_SrcSize) ITEM(ZSTD_ERROR_maxDstSize_tooSmall) \ 
+        ITEM(ZSTD_ERROR_corruption) \ 
+        ITEM(ZSTD_ERROR_maxCode) 
+ 
+#define ZSTD_GENERATE_ENUM(ENUM) ENUM, 
+typedef enum { ZSTD_LIST_ERRORS(ZSTD_GENERATE_ENUM) } ZSTD_errorCodes;   /* exposed list of errors; static linking only */ 
+ 
+/* 
+    zstd - standard compression library 
+    Copyright (C) 2014-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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+ 
+/**************************************************************** 
+*  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 */ 
+#define ZSTD_MEMORY_USAGE 17 
+ 
+ 
+/************************************** 
+   CPU Feature Detection 
+**************************************/ 
+/* 
+ * Automated efficient unaligned memory access detection 
+ * Based on known hardware architectures 
+ * This list will be updated thanks to feedbacks 
+ */ 
+#if defined(CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS) \ 
+    || defined(__ARM_FEATURE_UNALIGNED) \ 
+    || defined(__i386__) || defined(__x86_64__) \ 
+    || defined(_M_IX86) || defined(_M_X64) \ 
+    || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_8__) \ 
+    || (defined(_M_ARM) && (_M_ARM >= 7)) 
+#  define ZSTD_UNALIGNED_ACCESS 1 
+#else 
+#  define ZSTD_UNALIGNED_ACCESS 0 
+#endif 
+ 
+ 
+/******************************************************** 
+*  Includes 
+*********************************************************/ 
+#include <stdlib.h>      /* calloc */ 
+#include <string.h>      /* memcpy, memmove */ 
+#include <stdio.h>       /* debug : printf */ 
+ 
+ 
+/******************************************************** 
+*  Compiler specifics 
+*********************************************************/ 
+#ifdef __AVX2__ 
+#  include <immintrin.h>   /* AVX2 intrinsics */ 
+#endif 
+ 
+#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 : 4324)        /* disable: C4324: padded structure */ 
+#else 
+#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) 
+#  ifdef __GNUC__ 
+#    define FORCE_INLINE static inline __attribute__((always_inline)) 
+#  else 
+#    define FORCE_INLINE static inline 
+#  endif 
+#endif 
+ 
+ 
+#ifndef MEM_ACCESS_MODULE 
+#define MEM_ACCESS_MODULE 
+/******************************************************** 
+*  Basic Types 
+*********************************************************/ 
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */ 
+# include <stdint.h> 
+typedef  uint8_t BYTE; 
+typedef uint16_t U16; 
+typedef  int16_t S16; 
+typedef uint32_t U32; 
+typedef  int32_t S32; 
+typedef uint64_t U64; 
+#else 
+typedef unsigned char       BYTE; 
+typedef unsigned short      U16; 
+typedef   signed short      S16; 
+typedef unsigned int        U32; 
+typedef   signed int        S32; 
+typedef unsigned long long  U64; 
+#endif 
+ 
+#endif   /* MEM_ACCESS_MODULE */ 
+ 
+ 
+/******************************************************** 
+*  Constants 
+*********************************************************/ 
+static const U32 ZSTD_magicNumber = 0xFD2FB51E;   /* 3rd version : seqNb header */ 
+ 
+#define HASH_LOG (ZSTD_MEMORY_USAGE - 2) 
+#define HASH_TABLESIZE (1 << HASH_LOG) 
+#define HASH_MASK (HASH_TABLESIZE - 1) 
+ 
+#define KNUTH 2654435761 
+ 
+#define BIT7 128 
+#define BIT6  64 
+#define BIT5  32 
+#define BIT4  16 
+ 
+#define KB *(1 <<10) 
+#define MB *(1 <<20) 
+#define GB *(1U<<30) 
+ 
+#define BLOCKSIZE (128 KB)                 /* define, for static allocation */ 
+ 
+#define WORKPLACESIZE (BLOCKSIZE*3) 
+#define MINMATCH 4 
+#define MLbits   7 
+#define LLbits   6 
+#define Offbits  5 
+#define MaxML  ((1<<MLbits )-1) 
+#define MaxLL  ((1<<LLbits )-1) 
+#define MaxOff ((1<<Offbits)-1) 
+#define LitFSELog  11 
+#define MLFSELog   10 
+#define LLFSELog   10 
+#define OffFSELog   9 
+#define MAX(a,b) ((a)<(b)?(b):(a)) 
+#define MaxSeq MAX(MaxLL, MaxML) 
+ 
+#define LITERAL_NOENTROPY 63 
+#define COMMAND_NOENTROPY 7   /* to remove */ 
+ 
+static const size_t ZSTD_blockHeaderSize = 3; 
+static const size_t ZSTD_frameHeaderSize = 4; 
+ 
+ 
+/******************************************************** 
+*  Memory operations 
+*********************************************************/ 
+static unsigned ZSTD_32bits(void) { return sizeof(void*)==4; } 
+ 
+static unsigned ZSTD_isLittleEndian(void) 
+{ 
+    const union { U32 i; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */ 
+    return one.c[0]; 
+} 
+ 
+static U16    ZSTD_read16(const void* p) { U16 r; memcpy(&r, p, sizeof(r)); return r; } 
+ 
+static U32    ZSTD_read32(const void* p) { U32 r; memcpy(&r, p, sizeof(r)); return r; } 
+ 
+static void   ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); } 
+ 
+static void   ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); } 
+ 
+#define COPY8(d,s)    { ZSTD_copy8(d,s); d+=8; s+=8; } 
+ 
+static void ZSTD_wildcopy(void* dst, const void* src, size_t length) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + length; 
+    while (op < oend) COPY8(op, ip); 
+} 
+ 
+static U16 ZSTD_readLE16(const void* memPtr) 
+{ 
+    if (ZSTD_isLittleEndian()) return ZSTD_read16(memPtr); 
+    else 
+    { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U16)((U16)p[0] + ((U16)p[1]<<8)); 
+    } 
+} 
+ 
+ 
+static U32 ZSTD_readLE32(const void* memPtr) 
+{ 
+    if (ZSTD_isLittleEndian()) 
+        return ZSTD_read32(memPtr); 
+    else 
+    { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24)); 
+    } 
+} 
+ 
+static U32 ZSTD_readBE32(const void* memPtr) 
+{ 
+    const BYTE* p = (const BYTE*)memPtr; 
+    return (U32)(((U32)p[0]<<24) + ((U32)p[1]<<16) + ((U32)p[2]<<8) + ((U32)p[3]<<0)); 
+} 
+ 
+ 
+/************************************** 
+*  Local structures 
+***************************************/ 
+typedef struct ZSTD_Cctx_s ZSTD_Cctx; 
+ 
+typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t; 
+ 
+typedef struct 
+{ 
+    blockType_t blockType; 
+    U32 origSize; 
+} blockProperties_t; 
+ 
+typedef struct { 
+    void* buffer; 
+    U32*  offsetStart; 
+    U32*  offset; 
+    BYTE* offCodeStart; 
+    BYTE* offCode; 
+    BYTE* litStart; 
+    BYTE* lit; 
+    BYTE* litLengthStart; 
+    BYTE* litLength; 
+    BYTE* matchLengthStart; 
+    BYTE* matchLength; 
+    BYTE* dumpsStart; 
+    BYTE* dumps; 
+} seqStore_t; 
+ 
+ 
+typedef struct ZSTD_Cctx_s 
+{ 
+    const BYTE* base; 
+    U32 current; 
+    U32 nextUpdate; 
+    seqStore_t seqStore; 
+#ifdef __AVX2__ 
+    __m256i hashTable[HASH_TABLESIZE>>3]; 
+#else 
+    U32 hashTable[HASH_TABLESIZE]; 
+#endif 
+	BYTE buffer[WORKPLACESIZE]; 
+} cctxi_t; 
+ 
+ 
+ 
+ 
+/************************************** 
+*  Error Management 
+**************************************/ 
+/* tells if a return value is an error code */ 
+static unsigned ZSTD_isError(size_t code) { return (code > (size_t)(-ZSTD_ERROR_maxCode)); } 
+ 
+/* published entry point */ 
+unsigned ZSTDv01_isError(size_t code) { return ZSTD_isError(code); } 
+ 
+ 
+/************************************** 
+*  Tool functions 
+**************************************/ 
+#define ZSTD_VERSION_MAJOR    0    /* for breaking interface changes  */ 
+#define ZSTD_VERSION_MINOR    1    /* for new (non-breaking) interface capabilities */ 
+#define ZSTD_VERSION_RELEASE  3    /* for tweaks, bug-fixes, or development */ 
+#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE) 
+ 
+/************************************************************** 
+*   Decompression code 
+**************************************************************/ 
+ 
+static size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr) 
+{ 
+    const BYTE* const in = (const BYTE* const)src; 
+    BYTE headerFlags; 
+    U32 cSize; 
+ 
+    if (srcSize < 3) return (size_t)-ZSTD_ERROR_SrcSize; 
+ 
+    headerFlags = *in; 
+    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16); 
+ 
+    bpPtr->blockType = (blockType_t)(headerFlags >> 6); 
+    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0; 
+ 
+    if (bpPtr->blockType == bt_end) return 0; 
+    if (bpPtr->blockType == bt_rle) return 1; 
+    return cSize; 
+} 
+ 
+ 
+static size_t ZSTD_copyUncompressedBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    if (srcSize > maxDstSize) return (size_t)-ZSTD_ERROR_maxDstSize_tooSmall; 
+    memcpy(dst, src, srcSize); 
+    return srcSize; 
+} 
+ 
+ 
+static size_t ZSTD_decompressLiterals(void* ctx, 
+                                      void* dst, size_t maxDstSize, 
+                                const void* src, size_t srcSize) 
+{ 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + maxDstSize; 
+    const BYTE* ip = (const BYTE*)src; 
+    size_t errorCode; 
+    size_t litSize; 
+ 
+    /* check : minimum 2, for litSize, +1, for content */ 
+    if (srcSize <= 3) return (size_t)-ZSTD_ERROR_corruption; 
+ 
+    litSize = ip[1] + (ip[0]<<8); 
+    litSize += ((ip[-3] >> 3) & 7) << 16;   // mmmmh.... 
+    op = oend - litSize; 
+ 
+    (void)ctx; 
+    if (litSize > maxDstSize) return (size_t)-ZSTD_ERROR_maxDstSize_tooSmall; 
+    errorCode = HUF_decompress(op, litSize, ip+2, srcSize-2); 
+    if (FSE_isError(errorCode)) return (size_t)-ZSTD_ERROR_GENERIC; 
+    return litSize; 
+} 
+ 
+ 
+static size_t ZSTD_decodeLiteralsBlock(void* ctx, 
+                                void* dst, size_t maxDstSize, 
+                          const BYTE** litStart, size_t* litSize, 
+                          const void* src, size_t srcSize) 
+{ 
+    const BYTE* const istart = (const BYTE* const)src; 
+    const BYTE* ip = istart; 
+    BYTE* const ostart = (BYTE* const)dst; 
+    BYTE* const oend = ostart + maxDstSize; 
+    blockProperties_t litbp; 
+ 
+    size_t litcSize = ZSTD_getcBlockSize(src, srcSize, &litbp); 
+    if (ZSTD_isError(litcSize)) return litcSize; 
+    if (litcSize > srcSize - ZSTD_blockHeaderSize) return (size_t)-ZSTD_ERROR_SrcSize; 
+    ip += ZSTD_blockHeaderSize; 
+ 
+    switch(litbp.blockType) 
+    { 
+    case bt_raw: 
+        *litStart = ip; 
+        ip += litcSize; 
+        *litSize = litcSize; 
+        break; 
+    case bt_rle: 
+        { 
+            size_t rleSize = litbp.origSize; 
+            if (rleSize>maxDstSize) return (size_t)-ZSTD_ERROR_maxDstSize_tooSmall; 
+            memset(oend - rleSize, *ip, rleSize); 
+            *litStart = oend - rleSize; 
+            *litSize = rleSize; 
+            ip++; 
+            break; 
+        } 
+    case bt_compressed: 
+        { 
+            size_t decodedLitSize = ZSTD_decompressLiterals(ctx, dst, maxDstSize, ip, litcSize); 
+            if (ZSTD_isError(decodedLitSize)) return decodedLitSize; 
+            *litStart = oend - decodedLitSize; 
+            *litSize = decodedLitSize; 
+            ip += litcSize; 
+            break; 
+        } 
+    case bt_end: 
+    default: 
+        return (size_t)-ZSTD_ERROR_GENERIC; 
+    } 
+ 
+    return ip-istart; 
+} 
+ 
+ 
+static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr, 
+                         FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb, 
+                         const void* src, size_t srcSize) 
+{ 
+    const BYTE* const istart = (const BYTE* const)src; 
+    const BYTE* ip = istart; 
+    const BYTE* const iend = istart + srcSize; 
+    U32 LLtype, Offtype, MLtype; 
+    U32 LLlog, Offlog, MLlog; 
+    size_t dumpsLength; 
+ 
+    /* check */ 
+    if (srcSize < 5) return (size_t)-ZSTD_ERROR_SrcSize; 
+ 
+    /* SeqHead */ 
+    *nbSeq = ZSTD_readLE16(ip); ip+=2; 
+    LLtype  = *ip >> 6; 
+    Offtype = (*ip >> 4) & 3; 
+    MLtype  = (*ip >> 2) & 3; 
+    if (*ip & 2) 
+    { 
+        dumpsLength  = ip[2]; 
+        dumpsLength += ip[1] << 8; 
+        ip += 3; 
+    } 
+    else 
+    { 
+        dumpsLength  = ip[1]; 
+        dumpsLength += (ip[0] & 1) << 8; 
+        ip += 2; 
+    } 
+    *dumpsPtr = ip; 
+    ip += dumpsLength; 
+    *dumpsLengthPtr = dumpsLength; 
+ 
+    /* check */ 
+    if (ip > iend-3) return (size_t)-ZSTD_ERROR_SrcSize; /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */ 
+ 
+    /* sequences */ 
+    { 
+        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL and MaxOff */ 
+        size_t headerSize; 
+ 
+        /* Build DTables */ 
+        switch(LLtype) 
+        { 
+        U32 max; 
+        case bt_rle : 
+            LLlog = 0; 
+            FSE_buildDTable_rle(DTableLL, *ip++); break; 
+        case bt_raw : 
+            LLlog = LLbits; 
+            FSE_buildDTable_raw(DTableLL, LLbits); break; 
+        default : 
+            max = MaxLL; 
+            headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip); 
+            if (FSE_isError(headerSize)) return (size_t)-ZSTD_ERROR_GENERIC; 
+            if (LLlog > LLFSELog) return (size_t)-ZSTD_ERROR_corruption; 
+            ip += headerSize; 
+            FSE_buildDTable(DTableLL, norm, max, LLlog); 
+        } 
+ 
+        switch(Offtype) 
+        { 
+        U32 max; 
+        case bt_rle : 
+            Offlog = 0; 
+            if (ip > iend-2) return (size_t)-ZSTD_ERROR_SrcSize; /* min : "raw", hence no header, but at least xxLog bits */ 
+            FSE_buildDTable_rle(DTableOffb, *ip++); break; 
+        case bt_raw : 
+            Offlog = Offbits; 
+            FSE_buildDTable_raw(DTableOffb, Offbits); break; 
+        default : 
+            max = MaxOff; 
+            headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip); 
+            if (FSE_isError(headerSize)) return (size_t)-ZSTD_ERROR_GENERIC; 
+            if (Offlog > OffFSELog) return (size_t)-ZSTD_ERROR_corruption; 
+            ip += headerSize; 
+            FSE_buildDTable(DTableOffb, norm, max, Offlog); 
+        } 
+ 
+        switch(MLtype) 
+        { 
+        U32 max; 
+        case bt_rle : 
+            MLlog = 0; 
+            if (ip > iend-2) return (size_t)-ZSTD_ERROR_SrcSize; /* min : "raw", hence no header, but at least xxLog bits */ 
+            FSE_buildDTable_rle(DTableML, *ip++); break; 
+        case bt_raw : 
+            MLlog = MLbits; 
+            FSE_buildDTable_raw(DTableML, MLbits); break; 
+        default : 
+            max = MaxML; 
+            headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip); 
+            if (FSE_isError(headerSize)) return (size_t)-ZSTD_ERROR_GENERIC; 
+            if (MLlog > MLFSELog) return (size_t)-ZSTD_ERROR_corruption; 
+            ip += headerSize; 
+            FSE_buildDTable(DTableML, norm, max, MLlog); 
+        } 
+    } 
+ 
+    return ip-istart; 
+} 
+ 
+ 
+typedef struct { 
+    size_t litLength; 
+    size_t offset; 
+    size_t matchLength; 
+} seq_t; 
+ 
+typedef struct { 
+    FSE_DStream_t DStream; 
+    FSE_DState_t stateLL; 
+    FSE_DState_t stateOffb; 
+    FSE_DState_t stateML; 
+    size_t prevOffset; 
+    const BYTE* dumps; 
+    const BYTE* dumpsEnd; 
+} seqState_t; 
+ 
+ 
+static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState) 
+{ 
+    size_t litLength; 
+    size_t prevOffset; 
+    size_t offset; 
+    size_t matchLength; 
+    const BYTE* dumps = seqState->dumps; 
+    const BYTE* const de = seqState->dumpsEnd; 
+ 
+    /* Literal length */ 
+    litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream)); 
+    prevOffset = litLength ? seq->offset : seqState->prevOffset; 
+    seqState->prevOffset = seq->offset; 
+    if (litLength == MaxLL) 
+    { 
+        U32 add = dumps<de ? *dumps++ : 0; 
+        if (add < 255) litLength += add; 
+        else 
+        { 
+            if (dumps<=(de-3)) 
+            { 
+                litLength = ZSTD_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */ 
+                dumps += 3; 
+            } 
+        } 
+    } 
+ 
+    /* Offset */ 
+    { 
+        U32 offsetCode, nbBits; 
+        offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream)); 
+        if (ZSTD_32bits()) FSE_reloadDStream(&(seqState->DStream)); 
+        nbBits = offsetCode - 1; 
+        if (offsetCode==0) nbBits = 0;   /* cmove */ 
+        offset = ((size_t)1 << (nbBits & ((sizeof(offset)*8)-1))) + FSE_readBits(&(seqState->DStream), nbBits); 
+        if (ZSTD_32bits()) FSE_reloadDStream(&(seqState->DStream)); 
+        if (offsetCode==0) offset = prevOffset; 
+    } 
+ 
+    /* MatchLength */ 
+    matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream)); 
+    if (matchLength == MaxML) 
+    { 
+        U32 add = dumps<de ? *dumps++ : 0; 
+        if (add < 255) matchLength += add; 
+        else 
+        { 
+            if (dumps<=(de-3)) 
+            { 
+                matchLength = ZSTD_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */ 
+                dumps += 3; 
+            } 
+        } 
+    } 
+    matchLength += MINMATCH; 
+ 
+    /* save result */ 
+    seq->litLength = litLength; 
+    seq->offset = offset; 
+    seq->matchLength = matchLength; 
+    seqState->dumps = dumps; 
+} 
+ 
+ 
+static size_t ZSTD_execSequence(BYTE* op, 
+                                seq_t sequence, 
+                                const BYTE** litPtr, const BYTE* const litLimit, 
+                                BYTE* const base, BYTE* const oend) 
+{ 
+    static const int dec32table[] = {0, 1, 2, 1, 4, 4, 4, 4};   /* added */ 
+    static const int dec64table[] = {8, 8, 8, 7, 8, 9,10,11};   /* substracted */ 
+    const BYTE* const ostart = op; 
+    const size_t litLength = sequence.litLength; 
+    BYTE* const endMatch = op + litLength + sequence.matchLength;    /* risk : address space overflow (32-bits) */ 
+    const BYTE* const litEnd = *litPtr + litLength; 
+ 
+    /* check */ 
+    if (endMatch > oend) return (size_t)-ZSTD_ERROR_maxDstSize_tooSmall;   /* overwrite beyond dst buffer */ 
+    if (litEnd > litLimit) return (size_t)-ZSTD_ERROR_corruption; 
+    if (sequence.matchLength > (size_t)(*litPtr-op))  return (size_t)-ZSTD_ERROR_maxDstSize_tooSmall;    /* overwrite literal segment */ 
+ 
+    /* copy Literals */ 
+    if (((size_t)(*litPtr - op) < 8) || ((size_t)(oend-litEnd) < 8) || (op+litLength > oend-8)) 
+        memmove(op, *litPtr, litLength);   /* overwrite risk */ 
+    else 
+        ZSTD_wildcopy(op, *litPtr, litLength); 
+    op += litLength; 
+    *litPtr = litEnd;   /* update for next sequence */ 
+ 
+    /* check : last match must be at a minimum distance of 8 from end of dest buffer */ 
+    if (oend-op < 8) return (size_t)-ZSTD_ERROR_maxDstSize_tooSmall; 
+ 
+    /* copy Match */ 
+    { 
+        const U32 overlapRisk = (((size_t)(litEnd - endMatch)) < 12); 
+        const BYTE* match = op - sequence.offset;            /* possible underflow at op - offset ? */ 
+        size_t qutt = 12; 
+        U64 saved[2]; 
+ 
+        /* check */ 
+        if (match < base) return (size_t)-ZSTD_ERROR_corruption; 
+        if (sequence.offset > (size_t)base) return (size_t)-ZSTD_ERROR_corruption; 
+ 
+        /* save beginning of literal sequence, in case of write overlap */ 
+        if (overlapRisk) 
+        { 
+            if ((endMatch + qutt) > oend) qutt = oend-endMatch; 
+            memcpy(saved, endMatch, qutt); 
+        } 
+ 
+        if (sequence.offset < 8) 
+        { 
+            const int dec64 = dec64table[sequence.offset]; 
+            op[0] = match[0]; 
+            op[1] = match[1]; 
+            op[2] = match[2]; 
+            op[3] = match[3]; 
+            match += dec32table[sequence.offset]; 
+            ZSTD_copy4(op+4, match); 
+            match -= dec64; 
+        } else { ZSTD_copy8(op, match); } 
+        op += 8; match += 8; 
+ 
+        if (endMatch > oend-12) 
+        { 
+            if (op < oend-8) 
+            { 
+                ZSTD_wildcopy(op, match, (oend-8) - op); 
+                match += (oend-8) - op; 
+                op = oend-8; 
+            } 
+            while (op<endMatch) *op++ = *match++; 
+        } 
+        else 
+            ZSTD_wildcopy(op, match, sequence.matchLength-8);   /* works even if matchLength < 8 */ 
+ 
+        /* restore, in case of overlap */ 
+        if (overlapRisk) memcpy(endMatch, saved, qutt); 
+    } 
+ 
+    return endMatch-ostart; 
+} 
+ 
+typedef struct ZSTDv01_Dctx_s 
+{ 
+    U32 LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)]; 
+    U32 OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)]; 
+    U32 MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)]; 
+    void* previousDstEnd; 
+    void* base; 
+    size_t expected; 
+    blockType_t bType; 
+    U32 phase; 
+} dctx_t; 
+ 
+ 
+static size_t ZSTD_decompressSequences( 
+                               void* ctx, 
+                               void* dst, size_t maxDstSize, 
+                         const void* seqStart, size_t seqSize, 
+                         const BYTE* litStart, size_t litSize) 
+{ 
+    dctx_t* dctx = (dctx_t*)ctx; 
+    const BYTE* ip = (const BYTE*)seqStart; 
+    const BYTE* const iend = ip + seqSize; 
+    BYTE* const ostart = (BYTE* const)dst; 
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + maxDstSize; 
+    size_t errorCode, dumpsLength; 
+    const BYTE* litPtr = litStart; 
+    const BYTE* const litEnd = litStart + litSize; 
+    int nbSeq; 
+    const BYTE* dumps; 
+    U32* DTableLL = dctx->LLTable; 
+    U32* DTableML = dctx->MLTable; 
+    U32* DTableOffb = dctx->OffTable; 
+    BYTE* const base = (BYTE*) (dctx->base); 
+ 
+    /* Build Decoding Tables */ 
+    errorCode = ZSTD_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength, 
+                                      DTableLL, DTableML, DTableOffb, 
+                                      ip, iend-ip); 
+    if (ZSTD_isError(errorCode)) return errorCode; 
+    ip += errorCode; 
+ 
+    /* Regen sequences */ 
+    { 
+        seq_t sequence; 
+        seqState_t seqState; 
+ 
+        memset(&sequence, 0, sizeof(sequence)); 
+        seqState.dumps = dumps; 
+        seqState.dumpsEnd = dumps + dumpsLength; 
+        seqState.prevOffset = 1; 
+        errorCode = FSE_initDStream(&(seqState.DStream), ip, iend-ip); 
+        if (FSE_isError(errorCode)) return (size_t)-ZSTD_ERROR_corruption; 
+        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL); 
+        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb); 
+        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML); 
+ 
+        for ( ; (FSE_reloadDStream(&(seqState.DStream)) <= FSE_DStream_completed) && (nbSeq>0) ; ) 
+        { 
+            size_t oneSeqSize; 
+            nbSeq--; 
+            ZSTD_decodeSequence(&sequence, &seqState); 
+            oneSeqSize = ZSTD_execSequence(op, sequence, &litPtr, litEnd, base, oend); 
+            if (ZSTD_isError(oneSeqSize)) return oneSeqSize; 
+            op += oneSeqSize; 
+        } 
+ 
+        /* check if reached exact end */ 
+        if ( !FSE_endOfDStream(&(seqState.DStream)) ) return (size_t)-ZSTD_ERROR_corruption;   /* requested too much : data is corrupted */ 
+        if (nbSeq<0) return (size_t)-ZSTD_ERROR_corruption;   /* requested too many sequences : data is corrupted */ 
+ 
+        /* last literal segment */ 
+        { 
+            size_t lastLLSize = litEnd - litPtr; 
+            if (op+lastLLSize > oend) return (size_t)-ZSTD_ERROR_maxDstSize_tooSmall; 
+            if (op != litPtr) memmove(op, litPtr, lastLLSize); 
+            op += lastLLSize; 
+        } 
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+static size_t ZSTD_decompressBlock( 
+                            void* ctx, 
+                            void* dst, size_t maxDstSize, 
+                      const void* src, size_t srcSize) 
+{ 
+    /* blockType == blockCompressed, srcSize is trusted */ 
+    const BYTE* ip = (const BYTE*)src; 
+    const BYTE* litPtr = NULL; 
+    size_t litSize = 0; 
+    size_t errorCode; 
+ 
+    /* Decode literals sub-block */ 
+    errorCode = ZSTD_decodeLiteralsBlock(ctx, dst, maxDstSize, &litPtr, &litSize, src, srcSize); 
+    if (ZSTD_isError(errorCode)) return errorCode; 
+    ip += errorCode; 
+    srcSize -= errorCode; 
+ 
+    return ZSTD_decompressSequences(ctx, dst, maxDstSize, ip, srcSize, litPtr, litSize); 
+} 
+ 
+ 
+size_t ZSTDv01_decompressDCtx(void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    const BYTE* iend = ip + srcSize; 
+    BYTE* const ostart = (BYTE* const)dst; 
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + maxDstSize; 
+    size_t remainingSize = srcSize; 
+    U32 magicNumber; 
+    size_t errorCode=0; 
+    blockProperties_t blockProperties; 
+ 
+    /* Frame Header */ 
+    if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) return (size_t)-ZSTD_ERROR_SrcSize; 
+    magicNumber = ZSTD_readBE32(src); 
+    if (magicNumber != ZSTD_magicNumber) return (size_t)-ZSTD_ERROR_MagicNumber; 
+    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize; 
+ 
+    /* Loop on each block */ 
+    while (1) 
+    { 
+        size_t blockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties); 
+        if (ZSTD_isError(blockSize)) return blockSize; 
+ 
+        ip += ZSTD_blockHeaderSize; 
+        remainingSize -= ZSTD_blockHeaderSize; 
+        if (blockSize > remainingSize) return (size_t)-ZSTD_ERROR_SrcSize; 
+ 
+        switch(blockProperties.blockType) 
+        { 
+        case bt_compressed: 
+            errorCode = ZSTD_decompressBlock(ctx, op, oend-op, ip, blockSize); 
+            break; 
+        case bt_raw : 
+            errorCode = ZSTD_copyUncompressedBlock(op, oend-op, ip, blockSize); 
+            break; 
+        case bt_rle : 
+            return (size_t)-ZSTD_ERROR_GENERIC;   /* not yet supported */ 
+            break; 
+        case bt_end : 
+            /* end of frame */ 
+            if (remainingSize) return (size_t)-ZSTD_ERROR_SrcSize; 
+            break; 
+        default: 
+            return (size_t)-ZSTD_ERROR_GENERIC; 
+        } 
+        if (blockSize == 0) break;   /* bt_end */ 
+ 
+        if (ZSTD_isError(errorCode)) return errorCode; 
+        op += errorCode; 
+        ip += blockSize; 
+        remainingSize -= blockSize; 
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+size_t ZSTDv01_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    dctx_t ctx; 
+    ctx.base = dst; 
+    return ZSTDv01_decompressDCtx(&ctx, dst, maxDstSize, src, srcSize); 
+} 
+ 
+ 
+/******************************* 
+*  Streaming Decompression API 
+*******************************/ 
+ 
+size_t ZSTDv01_resetDCtx(ZSTDv01_Dctx* dctx) 
+{ 
+    dctx->expected = ZSTD_frameHeaderSize; 
+    dctx->phase = 0; 
+    dctx->previousDstEnd = NULL; 
+    dctx->base = NULL; 
+    return 0; 
+} 
+ 
+ZSTDv01_Dctx* ZSTDv01_createDCtx(void) 
+{ 
+    ZSTDv01_Dctx* dctx = (ZSTDv01_Dctx*)malloc(sizeof(ZSTDv01_Dctx)); 
+    if (dctx==NULL) return NULL; 
+    ZSTDv01_resetDCtx(dctx); 
+    return dctx; 
+} 
+ 
+size_t ZSTDv01_freeDCtx(ZSTDv01_Dctx* dctx) 
+{ 
+    free(dctx); 
+    return 0; 
+} 
+ 
+size_t ZSTDv01_nextSrcSizeToDecompress(ZSTDv01_Dctx* dctx) 
+{ 
+    return ((dctx_t*)dctx)->expected; 
+} 
+ 
+size_t ZSTDv01_decompressContinue(ZSTDv01_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    dctx_t* ctx = (dctx_t*)dctx; 
+ 
+    /* Sanity check */ 
+    if (srcSize != ctx->expected) return (size_t)-ZSTD_ERROR_SrcSize; 
+    if (dst != ctx->previousDstEnd)  /* not contiguous */ 
+        ctx->base = dst; 
+ 
+    /* Decompress : frame header */ 
+    if (ctx->phase == 0) 
+    { 
+        /* Check frame magic header */ 
+        U32 magicNumber = ZSTD_readBE32(src); 
+        if (magicNumber != ZSTD_magicNumber) return (size_t)-ZSTD_ERROR_MagicNumber; 
+        ctx->phase = 1; 
+        ctx->expected = ZSTD_blockHeaderSize; 
+        return 0; 
+    } 
+ 
+    /* Decompress : block header */ 
+    if (ctx->phase == 1) 
+    { 
+        blockProperties_t bp; 
+        size_t blockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp); 
+        if (ZSTD_isError(blockSize)) return blockSize; 
+        if (bp.blockType == bt_end) 
+        { 
+            ctx->expected = 0; 
+            ctx->phase = 0; 
+        } 
+        else 
+        { 
+            ctx->expected = blockSize; 
+            ctx->bType = bp.blockType; 
+            ctx->phase = 2; 
+        } 
+ 
+        return 0; 
+    } 
+ 
+    /* Decompress : block content */ 
+    { 
+        size_t rSize; 
+        switch(ctx->bType) 
+        { 
+        case bt_compressed: 
+            rSize = ZSTD_decompressBlock(ctx, dst, maxDstSize, src, srcSize); 
+            break; 
+        case bt_raw : 
+            rSize = ZSTD_copyUncompressedBlock(dst, maxDstSize, src, srcSize); 
+            break; 
+        case bt_rle : 
+            return (size_t)-ZSTD_ERROR_GENERIC;   /* not yet handled */ 
+            break; 
+        case bt_end :   /* should never happen (filtered at phase 1) */ 
+            rSize = 0; 
+            break; 
+        default: 
+            return (size_t)-ZSTD_ERROR_GENERIC; 
+        } 
+        ctx->phase = 1; 
+        ctx->expected = ZSTD_blockHeaderSize; 
+        ctx->previousDstEnd = (void*)( ((char*)dst) + rSize); 
+        return rSize; 
+    } 
+ 
+} 
+ 
+ 
diff --git a/contrib/libs/zstd06/legacy/zstd_v01.h b/contrib/libs/zstd06/legacy/zstd_v01.h
index 2b0bea2857..c90731b2b1 100644
--- a/contrib/libs/zstd06/legacy/zstd_v01.h
+++ b/contrib/libs/zstd06/legacy/zstd_v01.h
@@ -1,101 +1,101 @@
 #include <contrib/libs/zstd06/renames.h>
-/*
-    zstd - standard compression library
-    Header File
-    Copyright (C) 2014-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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-#pragma once
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* *************************************
-*  Includes
-***************************************/
-#include <stddef.h>   /* size_t */
-
-
-/* *************************************
-*  Simple one-step function
-***************************************/
-/**
-ZSTDv01_decompress() : decompress ZSTD frames compliant with v0.1.x format
-    compressedSize : is the exact source size
-    maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated.
-                      It must be equal or larger than originalSize, otherwise decompression will fail.
-    return : the number of bytes decompressed into destination buffer (originalSize)
-             or an errorCode if it fails (which can be tested using ZSTDv01_isError())
-*/
-size_t ZSTDv01_decompress( void* dst, size_t maxOriginalSize,
-                     const void* src, size_t compressedSize);
-
-/**
-ZSTDv01_isError() : tells if the result of ZSTDv01_decompress() is an error
-*/
-unsigned ZSTDv01_isError(size_t code);
-
-
-/* *************************************
-*  Advanced functions
-***************************************/
-typedef struct ZSTDv01_Dctx_s ZSTDv01_Dctx;
-ZSTDv01_Dctx* ZSTDv01_createDCtx(void);
-size_t ZSTDv01_freeDCtx(ZSTDv01_Dctx* dctx);
-
-size_t ZSTDv01_decompressDCtx(void* ctx,
-                              void* dst, size_t maxOriginalSize,
-                        const void* src, size_t compressedSize);
-
-/* *************************************
-*  Streaming functions
-***************************************/
-size_t ZSTDv01_resetDCtx(ZSTDv01_Dctx* dctx);
-
-size_t ZSTDv01_nextSrcSizeToDecompress(ZSTDv01_Dctx* dctx);
-size_t ZSTDv01_decompressContinue(ZSTDv01_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
-/**
-  Use above functions alternatively.
-  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
-  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
-  Result is the number of bytes regenerated within 'dst'.
-  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
-*/
-
-/* *************************************
-*  Prefix - version detection
-***************************************/
-#define ZSTDv01_magicNumber   0xFD2FB51E   /* Big Endian version */
-#define ZSTDv01_magicNumberLE 0x1EB52FFD   /* Little Endian version */
-
-
-#if defined (__cplusplus)
-}
-#endif
+/* 
+    zstd - standard compression library 
+    Header File 
+    Copyright (C) 2014-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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+#pragma once 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/* ************************************* 
+*  Includes 
+***************************************/ 
+#include <stddef.h>   /* size_t */ 
+ 
+ 
+/* ************************************* 
+*  Simple one-step function 
+***************************************/ 
+/** 
+ZSTDv01_decompress() : decompress ZSTD frames compliant with v0.1.x format 
+    compressedSize : is the exact source size 
+    maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated. 
+                      It must be equal or larger than originalSize, otherwise decompression will fail. 
+    return : the number of bytes decompressed into destination buffer (originalSize) 
+             or an errorCode if it fails (which can be tested using ZSTDv01_isError()) 
+*/ 
+size_t ZSTDv01_decompress( void* dst, size_t maxOriginalSize, 
+                     const void* src, size_t compressedSize); 
+ 
+/** 
+ZSTDv01_isError() : tells if the result of ZSTDv01_decompress() is an error 
+*/ 
+unsigned ZSTDv01_isError(size_t code); 
+ 
+ 
+/* ************************************* 
+*  Advanced functions 
+***************************************/ 
+typedef struct ZSTDv01_Dctx_s ZSTDv01_Dctx; 
+ZSTDv01_Dctx* ZSTDv01_createDCtx(void); 
+size_t ZSTDv01_freeDCtx(ZSTDv01_Dctx* dctx); 
+ 
+size_t ZSTDv01_decompressDCtx(void* ctx, 
+                              void* dst, size_t maxOriginalSize, 
+                        const void* src, size_t compressedSize); 
+ 
+/* ************************************* 
+*  Streaming functions 
+***************************************/ 
+size_t ZSTDv01_resetDCtx(ZSTDv01_Dctx* dctx); 
+ 
+size_t ZSTDv01_nextSrcSizeToDecompress(ZSTDv01_Dctx* dctx); 
+size_t ZSTDv01_decompressContinue(ZSTDv01_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize); 
+/** 
+  Use above functions alternatively. 
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue(). 
+  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block. 
+  Result is the number of bytes regenerated within 'dst'. 
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header. 
+*/ 
+ 
+/* ************************************* 
+*  Prefix - version detection 
+***************************************/ 
+#define ZSTDv01_magicNumber   0xFD2FB51E   /* Big Endian version */ 
+#define ZSTDv01_magicNumberLE 0x1EB52FFD   /* Little Endian version */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
diff --git a/contrib/libs/zstd06/legacy/zstd_v02.c b/contrib/libs/zstd06/legacy/zstd_v02.c
index 2d4cfa59c4..ffc6c9d61e 100644
--- a/contrib/libs/zstd06/legacy/zstd_v02.c
+++ b/contrib/libs/zstd06/legacy/zstd_v02.c
@@ -1,3748 +1,3748 @@
-/* ******************************************************************
-   Error codes and messages
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef ERROR_H_MODULE
-#define ERROR_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-#include <stddef.h>    /* size_t, ptrdiff_t */
-#include "zstd_v02.h"
-
-/******************************************
-*  Compiler-specific
-******************************************/
-#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#  define ERR_STATIC static inline
-#elif defined(_MSC_VER)
-#  define ERR_STATIC static __inline
-#elif defined(__GNUC__)
-#  define ERR_STATIC static __attribute__((unused))
-#else
-#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
-#endif
-
-
-/******************************************
-*  Error Management
-******************************************/
-#define PREFIX(name) ZSTD_error_##name
-
-#define ERROR(name) (size_t)-PREFIX(name)
-
-#define ERROR_LIST(ITEM) \
-        ITEM(PREFIX(No_Error)) ITEM(PREFIX(GENERIC)) \
-        ITEM(PREFIX(memory_allocation)) \
-        ITEM(PREFIX(dstSize_tooSmall)) ITEM(PREFIX(srcSize_wrong)) \
-        ITEM(PREFIX(prefix_unknown)) ITEM(PREFIX(corruption_detected)) \
-        ITEM(PREFIX(tableLog_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooSmall)) \
-        ITEM(PREFIX(maxCode))
-
-#define ERROR_GENERATE_ENUM(ENUM) ENUM,
-typedef enum { ERROR_LIST(ERROR_GENERATE_ENUM) } ERR_codes;  /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */
-
-#define ERROR_CONVERTTOSTRING(STRING) #STRING,
-#define ERROR_GENERATE_STRING(EXPR) ERROR_CONVERTTOSTRING(EXPR)
-
-ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* ERROR_H_MODULE */
-
-
-/* ******************************************************************
-   mem.h
-   low-level memory access routines
-   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
-****************************************************************** */
-#ifndef MEM_H_MODULE
-#define MEM_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/******************************************
-*  Includes
-******************************************/
-#include <stddef.h>    /* size_t, ptrdiff_t */
-#include <string.h>    /* memcpy */
-
-
-/******************************************
-*  Compiler-specific
-******************************************/
-#if defined(__GNUC__)
-#  define MEM_STATIC static __attribute__((unused))
-#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#  define MEM_STATIC static inline
-#elif defined(_MSC_VER)
-#  define MEM_STATIC static __inline
-#else
-#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
-#endif
-
-
-/****************************************************************
-*  Basic Types
-*****************************************************************/
-#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-# include <stdint.h>
-  typedef  uint8_t BYTE;
-  typedef uint16_t U16;
-  typedef  int16_t S16;
-  typedef uint32_t U32;
-  typedef  int32_t S32;
-  typedef uint64_t U64;
-  typedef  int64_t S64;
-#else
-  typedef unsigned char       BYTE;
-  typedef unsigned short      U16;
-  typedef   signed short      S16;
-  typedef unsigned int        U32;
-  typedef   signed int        S32;
-  typedef unsigned long long  U64;
-  typedef   signed long long  S64;
-#endif
-
-
-/****************************************************************
-*  Memory I/O
-*****************************************************************/
-/* MEM_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 is portable but violate C standard.
- *            It can generate buggy code on targets generating assembly depending on alignment.
- *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
- * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
- * Prefer these methods in priority order (0 > 1 > 2)
- */
-#ifndef MEM_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 MEM_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 MEM_FORCE_MEMORY_ACCESS 1
-#  endif
-#endif
-
-MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }
-MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }
-
-MEM_STATIC unsigned MEM_isLittleEndian(void)
-{
-    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
-    return one.c[0];
-}
-
-#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)
-
-/* violates C standard on structure alignment.
-Only use if no other choice to achieve best performance on target platform */
-MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
-MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
-MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
-MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
-MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }
-
-#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_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 { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign;
-
-MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
-MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
-MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
-MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; }
-MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign*)memPtr)->u64 = value; }
-
-#else
-
-/* default method, safe and standard.
-   can sometimes prove slower */
-
-MEM_STATIC U16 MEM_read16(const void* memPtr)
-{
-    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC U32 MEM_read32(const void* memPtr)
-{
-    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC U64 MEM_read64(const void* memPtr)
-{
-    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-MEM_STATIC void MEM_write32(void* memPtr, U32 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-MEM_STATIC void MEM_write64(void* memPtr, U64 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-#endif // MEM_FORCE_MEMORY_ACCESS
-
-
-MEM_STATIC U16 MEM_readLE16(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read16(memPtr);
-    else
-    {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U16)(p[0] + (p[1]<<8));
-    }
-}
-
-MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
-{
-    if (MEM_isLittleEndian())
-    {
-        MEM_write16(memPtr, val);
-    }
-    else
-    {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE)val;
-        p[1] = (BYTE)(val>>8);
-    }
-}
-
-MEM_STATIC U32 MEM_readLE32(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read32(memPtr);
-    else
-    {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));
-    }
-}
-
-MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)
-{
-    if (MEM_isLittleEndian())
-    {
-        MEM_write32(memPtr, val32);
-    }
-    else
-    {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE)val32;
-        p[1] = (BYTE)(val32>>8);
-        p[2] = (BYTE)(val32>>16);
-        p[3] = (BYTE)(val32>>24);
-    }
-}
-
-MEM_STATIC U64 MEM_readLE64(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read64(memPtr);
-    else
-    {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)
-                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));
-    }
-}
-
-MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)
-{
-    if (MEM_isLittleEndian())
-    {
-        MEM_write64(memPtr, val64);
-    }
-    else
-    {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE)val64;
-        p[1] = (BYTE)(val64>>8);
-        p[2] = (BYTE)(val64>>16);
-        p[3] = (BYTE)(val64>>24);
-        p[4] = (BYTE)(val64>>32);
-        p[5] = (BYTE)(val64>>40);
-        p[6] = (BYTE)(val64>>48);
-        p[7] = (BYTE)(val64>>56);
-    }
-}
-
-MEM_STATIC size_t MEM_readLEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readLE32(memPtr);
-    else
-        return (size_t)MEM_readLE64(memPtr);
-}
-
-MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val)
-{
-    if (MEM_32bits())
-        MEM_writeLE32(memPtr, (U32)val);
-    else
-        MEM_writeLE64(memPtr, (U64)val);
-}
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* MEM_H_MODULE */
-
-
-/* ******************************************************************
-   bitstream
-   Part of NewGen Entropy library
-   header file (to include)
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef BITSTREAM_H_MODULE
-#define BITSTREAM_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/*
-*  This API consists of small unitary functions, which highly benefit from being inlined.
-*  Since link-time-optimization is not available for all compilers,
-*  these functions are defined into a .h to be included.
-*/
-
-
-/**********************************************
-*  bitStream decompression API (read backward)
-**********************************************/
-typedef struct
-{
-    size_t   bitContainer;
-    unsigned bitsConsumed;
-    const char* ptr;
-    const char* start;
-} BIT_DStream_t;
-
-typedef enum { BIT_DStream_unfinished = 0,
-               BIT_DStream_endOfBuffer = 1,
-               BIT_DStream_completed = 2,
-               BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */
-               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
-
-MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
-MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
-MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
-MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
-
-
-/*
-* Start by invoking BIT_initDStream().
-* A chunk of the bitStream is then stored into a local register.
-* 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 manually filled from memory by the BIT_reloadDStream() method.
-* A reload guarantee a minimum of ((8*sizeof(size_t))-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()
-*/
-
-
-/******************************************
-*  unsafe API
-******************************************/
-MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
-/* faster, but works only if nbBits >= 1 */
-
-
-
-/****************************************************************
-*  Helper functions
-****************************************************************/
-MEM_STATIC unsigned BIT_highbit32 (register U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
-    unsigned long r=0;
-    _BitScanReverse ( &r, val );
-    return (unsigned) r;
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
-    return 31 - __builtin_clz (val);
-#   else   /* Software version */
-    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
-    U32 v = val;
-    unsigned r;
-    v |= v >> 1;
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
-    return r;
-#   endif
-}
-
-
-
-/**********************************************************
-* bitStream decoding
-**********************************************************/
-
-/*!BIT_initDStream
-*  Initialize a BIT_DStream_t.
-*  @bitD : a pointer to an already allocated BIT_DStream_t structure
-*  @srcBuffer must point at the beginning of a bitStream
-*  @srcSize must be the exact size of the bitStream
-*  @result : size of stream (== srcSize) or an errorCode if a problem is detected
-*/
-MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
-{
-    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
-
-    if (srcSize >=  sizeof(size_t))   /* normal case */
-    {
-        U32 contain32;
-        bitD->start = (const char*)srcBuffer;
-        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t);
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);
-        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
-        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
-        bitD->bitsConsumed = 8 - BIT_highbit32(contain32);
-    }
-    else
-    {
-        U32 contain32;
-        bitD->start = (const char*)srcBuffer;
-        bitD->ptr   = bitD->start;
-        bitD->bitContainer = *(const BYTE*)(bitD->start);
-        switch(srcSize)
-        {
-            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);
-            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);
-            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);
-            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;
-            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;
-            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8;
-            default:;
-        }
-        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
-        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
-        bitD->bitsConsumed = 8 - BIT_highbit32(contain32);
-        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;
-    }
-
-    return srcSize;
-}
-
-/*!BIT_lookBits
- * Provides next n bits from local register
- * local register is not modified (bits are still present for next read/look)
- * On 32-bits, maxNbBits==25
- * On 64-bits, maxNbBits==57
- * @return : value extracted
- */
-MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)
-{
-    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
-    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
-}
-
-/*! BIT_lookBitsFast :
-*   unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits)
-{
-    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
-    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);
-}
-
-MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
-{
-    bitD->bitsConsumed += nbBits;
-}
-
-/*!BIT_readBits
- * Read next n bits from local register.
- * pay attention to not read more than nbBits contained into local register.
- * @return : extracted value.
- */
-MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
-{
-    size_t value = BIT_lookBits(bitD, nbBits);
-    BIT_skipBits(bitD, nbBits);
-    return value;
-}
-
-/*!BIT_readBitsFast :
-*  unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)
-{
-    size_t value = BIT_lookBitsFast(bitD, nbBits);
-    BIT_skipBits(bitD, nbBits);
-    return value;
-}
-
-MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
-{
-	if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
-		return BIT_DStream_overflow;
-
-    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer))
-    {
-        bitD->ptr -= bitD->bitsConsumed >> 3;
-        bitD->bitsConsumed &= 7;
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);
-        return BIT_DStream_unfinished;
-    }
-    if (bitD->ptr == bitD->start)
-    {
-        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
-        return BIT_DStream_completed;
-    }
-    {
-        U32 nbBytes = bitD->bitsConsumed >> 3;
-        BIT_DStream_status result = BIT_DStream_unfinished;
-        if (bitD->ptr - nbBytes < bitD->start)
-        {
-            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
-            result = BIT_DStream_endOfBuffer;
-        }
-        bitD->ptr -= nbBytes;
-        bitD->bitsConsumed -= nbBytes*8;
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
-        return result;
-    }
-}
-
-/*! BIT_endOfDStream
-*   @return Tells if DStream has reached its exact end
-*/
-MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
-{
-    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
-}
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* BITSTREAM_H_MODULE */
-/* ******************************************************************
-   Error codes and messages
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef ERROR_H_MODULE
-#define ERROR_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/******************************************
-*  Compiler-specific
-******************************************/
-#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#  define ERR_STATIC static inline
-#elif defined(_MSC_VER)
-#  define ERR_STATIC static __inline
-#elif defined(__GNUC__)
-#  define ERR_STATIC static __attribute__((unused))
-#else
-#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
-#endif
-
-
-/******************************************
-*  Error Management
-******************************************/
-#define PREFIX(name) ZSTD_error_##name
-
-#define ERROR(name) (size_t)-PREFIX(name)
-
-#define ERROR_LIST(ITEM) \
-        ITEM(PREFIX(No_Error)) ITEM(PREFIX(GENERIC)) \
-        ITEM(PREFIX(dstSize_tooSmall)) ITEM(PREFIX(srcSize_wrong)) \
-        ITEM(PREFIX(prefix_unknown)) ITEM(PREFIX(corruption_detected)) \
-        ITEM(PREFIX(tableLog_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooSmall)) \
-        ITEM(PREFIX(maxCode))
-
-#define ERROR_GENERATE_ENUM(ENUM) ENUM,
-typedef enum { ERROR_LIST(ERROR_GENERATE_ENUM) } ERR_codes;  /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */
-
-#define ERROR_CONVERTTOSTRING(STRING) #STRING,
-#define ERROR_GENERATE_STRING(EXPR) ERROR_CONVERTTOSTRING(EXPR)
-static const char* ERR_strings[] = { ERROR_LIST(ERROR_GENERATE_STRING) };
-
-ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }
-
-ERR_STATIC const char* ERR_getErrorName(size_t code)
-{
-    static const char* codeError = "Unspecified error code";
-    if (ERR_isError(code)) return ERR_strings[-(int)(code)];
-    return codeError;
-}
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* ERROR_H_MODULE */
-/*
-Constructor and Destructor of type FSE_CTable
-    Note that its size depends on 'tableLog' and 'maxSymbolValue' */
-typedef unsigned FSE_CTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
-typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
-
-
-/* ******************************************************************
-   FSE : Finite State Entropy coder
-   header file for static linking (only)
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/******************************************
-*  Static allocation
-******************************************/
-/* FSE buffer bounds */
-#define FSE_NCOUNTBOUND 512
-#define FSE_BLOCKBOUND(size) (size + (size>>7))
-#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
-
-/* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */
-#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))
-#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
-
-
-/******************************************
-*  FSE advanced API
-******************************************/
-static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);
-/* build a fake FSE_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */
-
-static size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);
-/* build a fake FSE_DTable, designed to always generate the same symbolValue */
-
-
-/******************************************
-*  FSE symbol decompression API
-******************************************/
-typedef struct
-{
-    size_t      state;
-    const void* table;   /* precise table may vary, depending on U16 */
-} FSE_DState_t;
-
-
-static void     FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);
-
-static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
-
-static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
-
-/*
-Let's now decompose FSE_decompress_usingDTable() into its unitary components.
-You will decode FSE-encoded symbols from the bitStream,
-and also any other bitFields you put in, **in reverse order**.
-
-You will need a few variables to track your bitStream. They are :
-
-BIT_DStream_t DStream;    // Stream context
-FSE_DState_t  DState;     // State context. Multiple ones are possible
-FSE_DTable*   DTablePtr;  // Decoding table, provided by FSE_buildDTable()
-
-The first thing to do is to init the bitStream.
-    errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize);
-
-You should then retrieve your initial state(s)
-(in reverse flushing order if you have several ones) :
-    errorCode = FSE_initDState(&DState, &DStream, DTablePtr);
-
-You can then decode your data, symbol after symbol.
-For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'.
-Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
-    unsigned char symbol = FSE_decodeSymbol(&DState, &DStream);
-
-You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
-Note : maximum allowed nbBits is 25, for 32-bits compatibility
-    size_t bitField = BIT_readBits(&DStream, nbBits);
-
-All above operations only read from local register (which size depends on size_t).
-Refueling the register from memory is manually performed by the reload method.
-    endSignal = FSE_reloadDStream(&DStream);
-
-BIT_reloadDStream() result tells if there is still some more data to read from DStream.
-BIT_DStream_unfinished : there is still some data left into the DStream.
-BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
-BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
-BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted.
-
-When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
-to properly detect the exact end of stream.
-After each decoded symbol, check if DStream is fully consumed using this simple test :
-    BIT_reloadDStream(&DStream) >= BIT_DStream_completed
-
-When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
-Checking if DStream has reached its end is performed by :
-    BIT_endOfDStream(&DStream);
-Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
-    FSE_endOfDState(&DState);
-*/
-
-
-/******************************************
-*  FSE unsafe API
-******************************************/
-static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
-/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
-
-
-/******************************************
-*  Implementation of inline functions
-******************************************/
-
-/* decompression */
-
-typedef struct {
-    U16 tableLog;
-    U16 fastMode;
-} FSE_DTableHeader;   /* sizeof U32 */
-
-typedef struct
-{
-    unsigned short newState;
-    unsigned char  symbol;
-    unsigned char  nbBits;
-} FSE_decode_t;   /* size == U32 */
-
-MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
-{
-    FSE_DTableHeader DTableH;
-    memcpy(&DTableH, dt, sizeof(DTableH));
-    DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog);
-    BIT_reloadDStream(bitD);
-    DStatePtr->table = dt + 1;
-}
-
-MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
-{
-    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    const U32  nbBits = DInfo.nbBits;
-    BYTE symbol = DInfo.symbol;
-    size_t lowBits = BIT_readBits(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
-{
-    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    const U32 nbBits = DInfo.nbBits;
-    BYTE symbol = DInfo.symbol;
-    size_t lowBits = BIT_readBitsFast(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
-{
-    return DStatePtr->state == 0;
-}
-
-
-#if defined (__cplusplus)
-}
-#endif
-/* ******************************************************************
-   Huff0 : Huffman coder, part of New Generation Entropy library
-   header file for static linking (only)
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/******************************************
-*  Static allocation macros
-******************************************/
-/* Huff0 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 Huff0's DTable */
-#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog))  /* nb Cells; use unsigned short for X2, unsigned int for X4 */
-#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 functions
-******************************************/
-static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
-static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */
-static size_t HUF_decompress4X6 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* quad-symbols decoder */
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-/*
-    zstd - standard compression library
-    Header File
-    Copyright (C) 2014-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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* *************************************
-*  Includes
-***************************************/
-#include <stddef.h>   /* size_t */
-
-
-/* *************************************
-*  Version
-***************************************/
-#define ZSTD_VERSION_MAJOR    0    /* for breaking interface changes  */
-#define ZSTD_VERSION_MINOR    2    /* for new (non-breaking) interface capabilities */
-#define ZSTD_VERSION_RELEASE  2    /* for tweaks, bug-fixes, or development */
-#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
-
-
-/* *************************************
-*  Advanced functions
-***************************************/
-typedef struct ZSTD_CCtx_s ZSTD_CCtx;   /* incomplete type */
-
-#if defined (__cplusplus)
-}
-#endif
-/*
-    zstd - standard compression library
-    Header File for static linking only
-    Copyright (C) 2014-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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-
-/* The objects defined into this file should be considered experimental.
- * They are not labelled stable, as their prototype may change in the future.
- * You can use them for tests, provide feedback, or if you can endure risk of future changes.
- */
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* *************************************
-*  Streaming functions
-***************************************/
-
-typedef struct ZSTD_DCtx_s ZSTD_DCtx;
-
-/*
-  Use above functions alternatively.
-  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
-  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
-  Result is the number of bytes regenerated within 'dst'.
-  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
-*/
-
-/* *************************************
-*  Prefix - version detection
-***************************************/
-#define ZSTD_magicNumber 0xFD2FB522   /* v0.2 (current)*/
-
-
-#if defined (__cplusplus)
-}
-#endif
-/* ******************************************************************
-   FSE : Finite State Entropy coder
-   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
-****************************************************************** */
-
-#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
-
-
-/****************************************************************
-*  Byte symbol type
-****************************************************************/
-#endif   /* !FSE_COMMONDEFS_ONLY */
-
-
-/****************************************************************
-*  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) */
-
-/****************************************************************
-*  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
-
-
-/****************************************************************
-*  Error Management
-****************************************************************/
-#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 */
-
+/* ****************************************************************** 
+   Error codes and messages 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef ERROR_H_MODULE 
+#define ERROR_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+#include <stddef.h>    /* size_t, ptrdiff_t */ 
+#include "zstd_v02.h" 
+ 
+/****************************************** 
+*  Compiler-specific 
+******************************************/ 
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+#  define ERR_STATIC static inline 
+#elif defined(_MSC_VER) 
+#  define ERR_STATIC static __inline 
+#elif defined(__GNUC__) 
+#  define ERR_STATIC static __attribute__((unused)) 
+#else 
+#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */ 
+#endif 
+ 
+ 
+/****************************************** 
+*  Error Management 
+******************************************/ 
+#define PREFIX(name) ZSTD_error_##name 
+ 
+#define ERROR(name) (size_t)-PREFIX(name) 
+ 
+#define ERROR_LIST(ITEM) \ 
+        ITEM(PREFIX(No_Error)) ITEM(PREFIX(GENERIC)) \ 
+        ITEM(PREFIX(memory_allocation)) \ 
+        ITEM(PREFIX(dstSize_tooSmall)) ITEM(PREFIX(srcSize_wrong)) \ 
+        ITEM(PREFIX(prefix_unknown)) ITEM(PREFIX(corruption_detected)) \ 
+        ITEM(PREFIX(tableLog_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooSmall)) \ 
+        ITEM(PREFIX(maxCode)) 
+ 
+#define ERROR_GENERATE_ENUM(ENUM) ENUM, 
+typedef enum { ERROR_LIST(ERROR_GENERATE_ENUM) } ERR_codes;  /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */ 
+ 
+#define ERROR_CONVERTTOSTRING(STRING) #STRING, 
+#define ERROR_GENERATE_STRING(EXPR) ERROR_CONVERTTOSTRING(EXPR) 
+ 
+ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); } 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* ERROR_H_MODULE */ 
+ 
+ 
+/* ****************************************************************** 
+   mem.h 
+   low-level memory access routines 
+   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 
+****************************************************************** */ 
+#ifndef MEM_H_MODULE 
+#define MEM_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/****************************************** 
+*  Includes 
+******************************************/ 
+#include <stddef.h>    /* size_t, ptrdiff_t */ 
+#include <string.h>    /* memcpy */ 
+ 
+ 
+/****************************************** 
+*  Compiler-specific 
+******************************************/ 
+#if defined(__GNUC__) 
+#  define MEM_STATIC static __attribute__((unused)) 
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+#  define MEM_STATIC static inline 
+#elif defined(_MSC_VER) 
+#  define MEM_STATIC static __inline 
+#else 
+#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */ 
+#endif 
+ 
+ 
+/**************************************************************** 
+*  Basic Types 
+*****************************************************************/ 
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+# include <stdint.h> 
+  typedef  uint8_t BYTE; 
+  typedef uint16_t U16; 
+  typedef  int16_t S16; 
+  typedef uint32_t U32; 
+  typedef  int32_t S32; 
+  typedef uint64_t U64; 
+  typedef  int64_t S64; 
+#else 
+  typedef unsigned char       BYTE; 
+  typedef unsigned short      U16; 
+  typedef   signed short      S16; 
+  typedef unsigned int        U32; 
+  typedef   signed int        S32; 
+  typedef unsigned long long  U64; 
+  typedef   signed long long  S64; 
+#endif 
+ 
+ 
+/**************************************************************** 
+*  Memory I/O 
+*****************************************************************/ 
+/* MEM_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 is portable but violate C standard. 
+ *            It can generate buggy code on targets generating assembly depending on alignment. 
+ *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) 
+ * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details. 
+ * Prefer these methods in priority order (0 > 1 > 2) 
+ */ 
+#ifndef MEM_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 MEM_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 MEM_FORCE_MEMORY_ACCESS 1 
+#  endif 
+#endif 
+ 
+MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; } 
+MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; } 
+ 
+MEM_STATIC unsigned MEM_isLittleEndian(void) 
+{ 
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */ 
+    return one.c[0]; 
+} 
+ 
+#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2) 
+ 
+/* violates C standard on structure alignment. 
+Only use if no other choice to achieve best performance on target platform */ 
+MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; } 
+MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; } 
+MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; } 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; } 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; } 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; } 
+ 
+#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_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 { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign; 
+ 
+MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; } 
+MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; } 
+MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; } 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; } 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; } 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign*)memPtr)->u64 = value; } 
+ 
+#else 
+ 
+/* default method, safe and standard. 
+   can sometimes prove slower */ 
+ 
+MEM_STATIC U16 MEM_read16(const void* memPtr) 
+{ 
+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC U32 MEM_read32(const void* memPtr) 
+{ 
+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC U64 MEM_read64(const void* memPtr) 
+{ 
+    U64 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+#endif // MEM_FORCE_MEMORY_ACCESS 
+ 
+ 
+MEM_STATIC U16 MEM_readLE16(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read16(memPtr); 
+    else 
+    { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U16)(p[0] + (p[1]<<8)); 
+    } 
+} 
+ 
+MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val) 
+{ 
+    if (MEM_isLittleEndian()) 
+    { 
+        MEM_write16(memPtr, val); 
+    } 
+    else 
+    { 
+        BYTE* p = (BYTE*)memPtr; 
+        p[0] = (BYTE)val; 
+        p[1] = (BYTE)(val>>8); 
+    } 
+} 
+ 
+MEM_STATIC U32 MEM_readLE32(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read32(memPtr); 
+    else 
+    { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24)); 
+    } 
+} 
+ 
+MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32) 
+{ 
+    if (MEM_isLittleEndian()) 
+    { 
+        MEM_write32(memPtr, val32); 
+    } 
+    else 
+    { 
+        BYTE* p = (BYTE*)memPtr; 
+        p[0] = (BYTE)val32; 
+        p[1] = (BYTE)(val32>>8); 
+        p[2] = (BYTE)(val32>>16); 
+        p[3] = (BYTE)(val32>>24); 
+    } 
+} 
+ 
+MEM_STATIC U64 MEM_readLE64(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read64(memPtr); 
+    else 
+    { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24) 
+                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56)); 
+    } 
+} 
+ 
+MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64) 
+{ 
+    if (MEM_isLittleEndian()) 
+    { 
+        MEM_write64(memPtr, val64); 
+    } 
+    else 
+    { 
+        BYTE* p = (BYTE*)memPtr; 
+        p[0] = (BYTE)val64; 
+        p[1] = (BYTE)(val64>>8); 
+        p[2] = (BYTE)(val64>>16); 
+        p[3] = (BYTE)(val64>>24); 
+        p[4] = (BYTE)(val64>>32); 
+        p[5] = (BYTE)(val64>>40); 
+        p[6] = (BYTE)(val64>>48); 
+        p[7] = (BYTE)(val64>>56); 
+    } 
+} 
+ 
+MEM_STATIC size_t MEM_readLEST(const void* memPtr) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_readLE32(memPtr); 
+    else 
+        return (size_t)MEM_readLE64(memPtr); 
+} 
+ 
+MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val) 
+{ 
+    if (MEM_32bits()) 
+        MEM_writeLE32(memPtr, (U32)val); 
+    else 
+        MEM_writeLE64(memPtr, (U64)val); 
+} 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* MEM_H_MODULE */ 
+ 
+ 
+/* ****************************************************************** 
+   bitstream 
+   Part of NewGen Entropy library 
+   header file (to include) 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef BITSTREAM_H_MODULE 
+#define BITSTREAM_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* 
+*  This API consists of small unitary functions, which highly benefit from being inlined. 
+*  Since link-time-optimization is not available for all compilers, 
+*  these functions are defined into a .h to be included. 
+*/ 
+ 
+ 
+/********************************************** 
+*  bitStream decompression API (read backward) 
+**********************************************/ 
+typedef struct 
+{ 
+    size_t   bitContainer; 
+    unsigned bitsConsumed; 
+    const char* ptr; 
+    const char* start; 
+} BIT_DStream_t; 
+ 
+typedef enum { BIT_DStream_unfinished = 0, 
+               BIT_DStream_endOfBuffer = 1, 
+               BIT_DStream_completed = 2, 
+               BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */ 
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */ 
+ 
+MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize); 
+MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits); 
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD); 
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD); 
+ 
+ 
+/* 
+* Start by invoking BIT_initDStream(). 
+* A chunk of the bitStream is then stored into a local register. 
+* 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 manually filled from memory by the BIT_reloadDStream() method. 
+* A reload guarantee a minimum of ((8*sizeof(size_t))-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() 
+*/ 
+ 
+ 
+/****************************************** 
+*  unsafe API 
+******************************************/ 
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits); 
+/* faster, but works only if nbBits >= 1 */ 
+ 
+ 
+ 
+/**************************************************************** 
+*  Helper functions 
+****************************************************************/ 
+MEM_STATIC unsigned BIT_highbit32 (register U32 val) 
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
+    unsigned long r=0; 
+    _BitScanReverse ( &r, val ); 
+    return (unsigned) r; 
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */ 
+    return 31 - __builtin_clz (val); 
+#   else   /* Software version */ 
+    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 }; 
+    U32 v = val; 
+    unsigned r; 
+    v |= v >> 1; 
+    v |= v >> 2; 
+    v |= v >> 4; 
+    v |= v >> 8; 
+    v |= v >> 16; 
+    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27]; 
+    return r; 
+#   endif 
+} 
+ 
+ 
+ 
+/********************************************************** 
+* bitStream decoding 
+**********************************************************/ 
+ 
+/*!BIT_initDStream 
+*  Initialize a BIT_DStream_t. 
+*  @bitD : a pointer to an already allocated BIT_DStream_t structure 
+*  @srcBuffer must point at the beginning of a bitStream 
+*  @srcSize must be the exact size of the bitStream 
+*  @result : size of stream (== srcSize) or an errorCode if a problem is detected 
+*/ 
+MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize) 
+{ 
+    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); } 
+ 
+    if (srcSize >=  sizeof(size_t))   /* normal case */ 
+    { 
+        U32 contain32; 
+        bitD->start = (const char*)srcBuffer; 
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t); 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr); 
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1]; 
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */ 
+        bitD->bitsConsumed = 8 - BIT_highbit32(contain32); 
+    } 
+    else 
+    { 
+        U32 contain32; 
+        bitD->start = (const char*)srcBuffer; 
+        bitD->ptr   = bitD->start; 
+        bitD->bitContainer = *(const BYTE*)(bitD->start); 
+        switch(srcSize) 
+        { 
+            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16); 
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24); 
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32); 
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; 
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; 
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8; 
+            default:; 
+        } 
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1]; 
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */ 
+        bitD->bitsConsumed = 8 - BIT_highbit32(contain32); 
+        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8; 
+    } 
+ 
+    return srcSize; 
+} 
+ 
+/*!BIT_lookBits 
+ * Provides next n bits from local register 
+ * local register is not modified (bits are still present for next read/look) 
+ * On 32-bits, maxNbBits==25 
+ * On 64-bits, maxNbBits==57 
+ * @return : value extracted 
+ */ 
+MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1; 
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask); 
+} 
+ 
+/*! BIT_lookBitsFast : 
+*   unsafe version; only works only if nbBits >= 1 */ 
+MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1; 
+    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask); 
+} 
+ 
+MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    bitD->bitsConsumed += nbBits; 
+} 
+ 
+/*!BIT_readBits 
+ * Read next n bits from local register. 
+ * pay attention to not read more than nbBits contained into local register. 
+ * @return : extracted value. 
+ */ 
+MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t value = BIT_lookBits(bitD, nbBits); 
+    BIT_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+/*!BIT_readBitsFast : 
+*  unsafe version; only works only if nbBits >= 1 */ 
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t value = BIT_lookBitsFast(bitD, nbBits); 
+    BIT_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD) 
+{ 
+	if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */ 
+		return BIT_DStream_overflow; 
+ 
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) 
+    { 
+        bitD->ptr -= bitD->bitsConsumed >> 3; 
+        bitD->bitsConsumed &= 7; 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr); 
+        return BIT_DStream_unfinished; 
+    } 
+    if (bitD->ptr == bitD->start) 
+    { 
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer; 
+        return BIT_DStream_completed; 
+    } 
+    { 
+        U32 nbBytes = bitD->bitsConsumed >> 3; 
+        BIT_DStream_status result = BIT_DStream_unfinished; 
+        if (bitD->ptr - nbBytes < bitD->start) 
+        { 
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */ 
+            result = BIT_DStream_endOfBuffer; 
+        } 
+        bitD->ptr -= nbBytes; 
+        bitD->bitsConsumed -= nbBytes*8; 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */ 
+        return result; 
+    } 
+} 
+ 
+/*! BIT_endOfDStream 
+*   @return Tells if DStream has reached its exact end 
+*/ 
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream) 
+{ 
+    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8)); 
+} 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* BITSTREAM_H_MODULE */ 
+/* ****************************************************************** 
+   Error codes and messages 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef ERROR_H_MODULE 
+#define ERROR_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/****************************************** 
+*  Compiler-specific 
+******************************************/ 
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+#  define ERR_STATIC static inline 
+#elif defined(_MSC_VER) 
+#  define ERR_STATIC static __inline 
+#elif defined(__GNUC__) 
+#  define ERR_STATIC static __attribute__((unused)) 
+#else 
+#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */ 
+#endif 
+ 
+ 
+/****************************************** 
+*  Error Management 
+******************************************/ 
+#define PREFIX(name) ZSTD_error_##name 
+ 
+#define ERROR(name) (size_t)-PREFIX(name) 
+ 
+#define ERROR_LIST(ITEM) \ 
+        ITEM(PREFIX(No_Error)) ITEM(PREFIX(GENERIC)) \ 
+        ITEM(PREFIX(dstSize_tooSmall)) ITEM(PREFIX(srcSize_wrong)) \ 
+        ITEM(PREFIX(prefix_unknown)) ITEM(PREFIX(corruption_detected)) \ 
+        ITEM(PREFIX(tableLog_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooSmall)) \ 
+        ITEM(PREFIX(maxCode)) 
+ 
+#define ERROR_GENERATE_ENUM(ENUM) ENUM, 
+typedef enum { ERROR_LIST(ERROR_GENERATE_ENUM) } ERR_codes;  /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */ 
+ 
+#define ERROR_CONVERTTOSTRING(STRING) #STRING, 
+#define ERROR_GENERATE_STRING(EXPR) ERROR_CONVERTTOSTRING(EXPR) 
+static const char* ERR_strings[] = { ERROR_LIST(ERROR_GENERATE_STRING) }; 
+ 
+ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); } 
+ 
+ERR_STATIC const char* ERR_getErrorName(size_t code) 
+{ 
+    static const char* codeError = "Unspecified error code"; 
+    if (ERR_isError(code)) return ERR_strings[-(int)(code)]; 
+    return codeError; 
+} 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* ERROR_H_MODULE */ 
+/* 
+Constructor and Destructor of type FSE_CTable 
+    Note that its size depends on 'tableLog' and 'maxSymbolValue' */ 
+typedef unsigned FSE_CTable;   /* don't allocate that. It's just a way to be more restrictive than void* */ 
+typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */ 
+ 
+ 
+/* ****************************************************************** 
+   FSE : Finite State Entropy coder 
+   header file for static linking (only) 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/****************************************** 
+*  Static allocation 
+******************************************/ 
+/* FSE buffer bounds */ 
+#define FSE_NCOUNTBOUND 512 
+#define FSE_BLOCKBOUND(size) (size + (size>>7)) 
+#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */ 
+ 
+/* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */ 
+#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2)) 
+#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog)) 
+ 
+ 
+/****************************************** 
+*  FSE advanced API 
+******************************************/ 
+static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits); 
+/* build a fake FSE_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */ 
+ 
+static size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue); 
+/* build a fake FSE_DTable, designed to always generate the same symbolValue */ 
+ 
+ 
+/****************************************** 
+*  FSE symbol decompression API 
+******************************************/ 
+typedef struct 
+{ 
+    size_t      state; 
+    const void* table;   /* precise table may vary, depending on U16 */ 
+} FSE_DState_t; 
+ 
+ 
+static void     FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt); 
+ 
+static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD); 
+ 
+static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr); 
+ 
+/* 
+Let's now decompose FSE_decompress_usingDTable() into its unitary components. 
+You will decode FSE-encoded symbols from the bitStream, 
+and also any other bitFields you put in, **in reverse order**. 
+ 
+You will need a few variables to track your bitStream. They are : 
+ 
+BIT_DStream_t DStream;    // Stream context 
+FSE_DState_t  DState;     // State context. Multiple ones are possible 
+FSE_DTable*   DTablePtr;  // Decoding table, provided by FSE_buildDTable() 
+ 
+The first thing to do is to init the bitStream. 
+    errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize); 
+ 
+You should then retrieve your initial state(s) 
+(in reverse flushing order if you have several ones) : 
+    errorCode = FSE_initDState(&DState, &DStream, DTablePtr); 
+ 
+You can then decode your data, symbol after symbol. 
+For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'. 
+Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out). 
+    unsigned char symbol = FSE_decodeSymbol(&DState, &DStream); 
+ 
+You can retrieve any bitfield you eventually stored into the bitStream (in reverse order) 
+Note : maximum allowed nbBits is 25, for 32-bits compatibility 
+    size_t bitField = BIT_readBits(&DStream, nbBits); 
+ 
+All above operations only read from local register (which size depends on size_t). 
+Refueling the register from memory is manually performed by the reload method. 
+    endSignal = FSE_reloadDStream(&DStream); 
+ 
+BIT_reloadDStream() result tells if there is still some more data to read from DStream. 
+BIT_DStream_unfinished : there is still some data left into the DStream. 
+BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled. 
+BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed. 
+BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted. 
+ 
+When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop, 
+to properly detect the exact end of stream. 
+After each decoded symbol, check if DStream is fully consumed using this simple test : 
+    BIT_reloadDStream(&DStream) >= BIT_DStream_completed 
+ 
+When it's done, verify decompression is fully completed, by checking both DStream and the relevant states. 
+Checking if DStream has reached its end is performed by : 
+    BIT_endOfDStream(&DStream); 
+Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible. 
+    FSE_endOfDState(&DState); 
+*/ 
+ 
+ 
+/****************************************** 
+*  FSE unsafe API 
+******************************************/ 
+static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD); 
+/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */ 
+ 
+ 
+/****************************************** 
+*  Implementation of inline functions 
+******************************************/ 
+ 
+/* decompression */ 
+ 
+typedef struct { 
+    U16 tableLog; 
+    U16 fastMode; 
+} FSE_DTableHeader;   /* sizeof U32 */ 
+ 
+typedef struct 
+{ 
+    unsigned short newState; 
+    unsigned char  symbol; 
+    unsigned char  nbBits; 
+} FSE_decode_t;   /* size == U32 */ 
+ 
+MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt) 
+{ 
+    FSE_DTableHeader DTableH; 
+    memcpy(&DTableH, dt, sizeof(DTableH)); 
+    DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog); 
+    BIT_reloadDStream(bitD); 
+    DStatePtr->table = dt + 1; 
+} 
+ 
+MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) 
+{ 
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    const U32  nbBits = DInfo.nbBits; 
+    BYTE symbol = DInfo.symbol; 
+    size_t lowBits = BIT_readBits(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) 
+{ 
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    const U32 nbBits = DInfo.nbBits; 
+    BYTE symbol = DInfo.symbol; 
+    size_t lowBits = BIT_readBitsFast(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr) 
+{ 
+    return DStatePtr->state == 0; 
+} 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+/* ****************************************************************** 
+   Huff0 : Huffman coder, part of New Generation Entropy library 
+   header file for static linking (only) 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/****************************************** 
+*  Static allocation macros 
+******************************************/ 
+/* Huff0 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 Huff0's DTable */ 
+#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog))  /* nb Cells; use unsigned short for X2, unsigned int for X4 */ 
+#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 functions 
+******************************************/ 
+static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */ 
+static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */ 
+static size_t HUF_decompress4X6 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* quad-symbols decoder */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+/* 
+    zstd - standard compression library 
+    Header File 
+    Copyright (C) 2014-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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/* ************************************* 
+*  Includes 
+***************************************/ 
+#include <stddef.h>   /* size_t */ 
+ 
+ 
+/* ************************************* 
+*  Version 
+***************************************/ 
+#define ZSTD_VERSION_MAJOR    0    /* for breaking interface changes  */ 
+#define ZSTD_VERSION_MINOR    2    /* for new (non-breaking) interface capabilities */ 
+#define ZSTD_VERSION_RELEASE  2    /* for tweaks, bug-fixes, or development */ 
+#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE) 
+ 
+ 
+/* ************************************* 
+*  Advanced functions 
+***************************************/ 
+typedef struct ZSTD_CCtx_s ZSTD_CCtx;   /* incomplete type */ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+/* 
+    zstd - standard compression library 
+    Header File for static linking only 
+    Copyright (C) 2014-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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+ 
+/* The objects defined into this file should be considered experimental. 
+ * They are not labelled stable, as their prototype may change in the future. 
+ * You can use them for tests, provide feedback, or if you can endure risk of future changes. 
+ */ 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/* ************************************* 
+*  Streaming functions 
+***************************************/ 
+ 
+typedef struct ZSTD_DCtx_s ZSTD_DCtx; 
+ 
+/* 
+  Use above functions alternatively. 
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue(). 
+  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block. 
+  Result is the number of bytes regenerated within 'dst'. 
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header. 
+*/ 
+ 
+/* ************************************* 
+*  Prefix - version detection 
+***************************************/ 
+#define ZSTD_magicNumber 0xFD2FB522   /* v0.2 (current)*/ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+/* ****************************************************************** 
+   FSE : Finite State Entropy coder 
+   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 
+****************************************************************** */ 
+ 
+#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 
+ 
+ 
+/**************************************************************** 
+*  Byte symbol type 
+****************************************************************/ 
+#endif   /* !FSE_COMMONDEFS_ONLY */ 
+ 
+ 
+/**************************************************************** 
+*  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) */ 
+ 
+/**************************************************************** 
+*  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 
+ 
+ 
+/**************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#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 */ 
+ 
 #define FSE_DECODE_TYPE FSE_decode_t
-
-static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }
-
+ 
+static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; } 
+ 
 static size_t FSE_buildDTable
-(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
-{
-    void* ptr = dt+1;
-    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)ptr;
-    FSE_DTableHeader DTableH;
-    const U32 tableSize = 1 << tableLog;
-    const U32 tableMask = tableSize-1;
-    const U32 step = FSE_tableStep(tableSize);
-    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];
-    U32 position = 0;
-    U32 highThreshold = tableSize-1;
-    const S16 largeLimit= (S16)(1 << (tableLog-1));
-    U32 noLarge = 1;
-    U32 s;
-
-    /* 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 */
-    DTableH.tableLog = (U16)tableLog;
-    for (s=0; s<=maxSymbolValue; s++)
-    {
-        if (normalizedCounter[s]==-1)
-        {
-            tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;
-            symbolNext[s] = 1;
-        }
-        else
-        {
-            if (normalizedCounter[s] >= largeLimit) noLarge=0;
-            symbolNext[s] = normalizedCounter[s];
-        }
-    }
-
-    /* Spread symbols */
-    for (s=0; s<=maxSymbolValue; 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 i;
-        for (i=0; i<tableSize; i++)
-        {
-            FSE_FUNCTION_TYPE symbol = (FSE_FUNCTION_TYPE)(tableDecode[i].symbol);
-            U16 nextState = symbolNext[symbol]++;
-            tableDecode[i].nbBits = (BYTE) (tableLog - BIT_highbit32 ((U32)nextState) );
-            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize);
-        }
-    }
-
-    DTableH.fastMode = (U16)noLarge;
-    memcpy(dt, &DTableH, sizeof(DTableH));   /* memcpy(), to avoid strict aliasing warnings */
-    return 0;
-}
-
-
-#ifndef FSE_COMMONDEFS_ONLY
-/******************************************
-*  FSE helper functions
-******************************************/
-static unsigned FSE_isError(size_t code) { return ERR_isError(code); }
-
-
-/****************************************************************
-*  FSE NCount encoding-decoding
-****************************************************************/
-static short FSE_abs(short a)
-{
+(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) 
+{ 
+    void* ptr = dt+1; 
+    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)ptr; 
+    FSE_DTableHeader DTableH; 
+    const U32 tableSize = 1 << tableLog; 
+    const U32 tableMask = tableSize-1; 
+    const U32 step = FSE_tableStep(tableSize); 
+    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1]; 
+    U32 position = 0; 
+    U32 highThreshold = tableSize-1; 
+    const S16 largeLimit= (S16)(1 << (tableLog-1)); 
+    U32 noLarge = 1; 
+    U32 s; 
+ 
+    /* 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 */ 
+    DTableH.tableLog = (U16)tableLog; 
+    for (s=0; s<=maxSymbolValue; s++) 
+    { 
+        if (normalizedCounter[s]==-1) 
+        { 
+            tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s; 
+            symbolNext[s] = 1; 
+        } 
+        else 
+        { 
+            if (normalizedCounter[s] >= largeLimit) noLarge=0; 
+            symbolNext[s] = normalizedCounter[s]; 
+        } 
+    } 
+ 
+    /* Spread symbols */ 
+    for (s=0; s<=maxSymbolValue; 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 i; 
+        for (i=0; i<tableSize; i++) 
+        { 
+            FSE_FUNCTION_TYPE symbol = (FSE_FUNCTION_TYPE)(tableDecode[i].symbol); 
+            U16 nextState = symbolNext[symbol]++; 
+            tableDecode[i].nbBits = (BYTE) (tableLog - BIT_highbit32 ((U32)nextState) ); 
+            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize); 
+        } 
+    } 
+ 
+    DTableH.fastMode = (U16)noLarge; 
+    memcpy(dt, &DTableH, sizeof(DTableH));   /* memcpy(), to avoid strict aliasing warnings */ 
+    return 0; 
+} 
+ 
+ 
+#ifndef FSE_COMMONDEFS_ONLY 
+/****************************************** 
+*  FSE helper functions 
+******************************************/ 
+static unsigned FSE_isError(size_t code) { return ERR_isError(code); } 
+ 
+ 
+/**************************************************************** 
+*  FSE NCount encoding-decoding 
+****************************************************************/ 
+static short FSE_abs(short a) 
+{ 
     return (short)(a<0 ? -a : a);
-}
-
-static 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;
-        }
-        {
-            const short 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);
-            }
-        }
-    }
-    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;
-}
-
-
-/*********************************************************
-*  Decompression (Byte symbols)
-*********************************************************/
-static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
-{
-    void* ptr = dt;
-    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
-    FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */
-
-    DTableH->tableLog = 0;
-    DTableH->fastMode = 0;
-
-    cell->newState = 0;
-    cell->symbol = symbolValue;
-    cell->nbBits = 0;
-
-    return 0;
-}
-
-
-static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
-{
-    void* ptr = dt;
-    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
-    FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */
-    const unsigned tableSize = 1 << nbBits;
-    const unsigned tableMask = tableSize - 1;
-    const unsigned maxSymbolValue = tableMask;
-    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<=maxSymbolValue; 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;
-    size_t errorCode;
-
-    /* Init */
-    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 ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) )
-            break;
-
-        *op++ = FSE_GETSYMBOL(&state1);
-
-        if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) )
-            break;
-
-        *op++ = FSE_GETSYMBOL(&state2);
-    }
-
-    /* end ? */
-    if (BIT_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2))
-        return op-ostart;
-
-    if (op==omax) return ERROR(dstSize_tooSmall);   /* dst buffer is full, but cSrc unfinished */
-
-    return ERROR(corruption_detected);
-}
-
-
-static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
-                            const void* cSrc, size_t cSrcSize,
-                            const FSE_DTable* dt)
-{
-    FSE_DTableHeader DTableH;
-    memcpy(&DTableH, dt, sizeof(DTableH));
-
-    /* select fast mode (static) */
-    if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
-    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
-}
-
-
-static 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;
-    size_t errorCode;
-
-    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */
-
-    /* normal FSE decoding mode */
-    errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
-    if (FSE_isError(errorCode)) return errorCode;
-    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */
-    ip += errorCode;
-    cSrcSize -= errorCode;
-
-    errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);
-    if (FSE_isError(errorCode)) return errorCode;
-
-    /* always return, even if it is an error code */
-    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);
-}
-
-
-
-#endif   /* FSE_COMMONDEFS_ONLY */
-/* ******************************************************************
-   Huff0 : Huffman coder, part of New Generation Entropy library
-   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+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy
-    - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-
-/****************************************************************
-*  Compiler specifics
-****************************************************************/
-#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-/* inline is defined */
-#elif defined(_MSC_VER)
-#  define inline __inline
-#else
-#  define inline /* disable inline */
-#endif
-
-
-#ifdef _MSC_VER    /* Visual Studio */
-#  define FORCE_INLINE static __forceinline
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#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) */
-
-/****************************************************************
-*  Error Management
-****************************************************************/
-#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-
-
-/******************************************
-*  Helper functions
-******************************************/
-static unsigned HUF_isError(size_t code) { return ERR_isError(code); }
-
-#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
-
-
-
-/*********************************************************
-*  Huff0 : Huffman block decompression
-*********************************************************/
-typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2;   /* single-symbol decoding */
-
-typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4;  /* double-symbols decoding */
-
-typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
-
-/*! HUF_readStats
-    Read compact Huffman tree, saved by HUF_writeCTable
-    @huffWeight : destination buffer
-    @return : size read from `src`
-*/
-static size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                            U32* nbSymbolsPtr, U32* tableLogPtr,
-                            const void* src, size_t srcSize)
-{
-    U32 weightTotal;
-    U32 tableLog;
-    const BYTE* ip = (const BYTE*) src;
-    size_t iSize = ip[0];
-    size_t oSize;
-    U32 n;
-
-    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */
-
-    if (iSize >= 128)  /* special header */
-    {
-        if (iSize >= (242))   /* RLE */
-        {
-            static int 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;
-            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;
-    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) */
-    tableLog = BIT_highbit32(weightTotal) + 1;
-    if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
-    {
-        U32 total = 1 << tableLog;
-        U32 rest = total - weightTotal;
-        U32 verif = 1 << BIT_highbit32(rest);
-        U32 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);
-    *tableLogPtr = tableLog;
-    return iSize+1;
-}
-
-
-/**************************/
-/* single-symbol decoding */
-/**************************/
-
-static size_t HUF_readDTableX2 (U16* DTable, const void* src, size_t srcSize)
-{
-    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1];
-    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];   /* large enough for values from 0 to 16 */
-    U32 tableLog = 0;
-    const BYTE* ip = (const BYTE*) src;
-    size_t iSize = ip[0];
-    U32 nbSymbols = 0;
-    U32 n;
-    U32 nextRankStart;
-    void* ptr = DTable+1;
-    HUF_DEltX2* const dt = (HUF_DEltX2*)ptr;
-
-    HUF_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */
-    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
-    if (HUF_isError(iSize)) return iSize;
-
-    /* check result */
-    if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge);   /* DTable is too small */
-    DTable[0] = (U16)tableLog;   /* maybe should separate sizeof DTable, as allocated, from used size of DTable, in case of DTable re-use */
-
-    /* Prepare ranks */
-    nextRankStart = 0;
-    for (n=1; n<=tableLog; n++)
-    {
-        U32 current = nextRankStart;
-        nextRankStart += (rankVal[n] << (n-1));
-        rankVal[n] = current;
-    }
-
-    /* fill DTable */
-    for (n=0; n<nbSymbols; n++)
-    {
-        const U32 w = huffWeight[n];
-        const U32 length = (1 << w) >> 1;
-        U32 i;
-        HUF_DEltX2 D;
-        D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);
-        for (i = rankVal[w]; i < rankVal[w] + length; i++)
-            dt[i] = D;
-        rankVal[w] += length;
-    }
-
-    return iSize;
-}
-
-static BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog)
-{
-        const size_t val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
-        const BYTE c = dt[val].byte;
-        BIT_skipBits(Dstream, dt[val].nbBits);
-        return c;
-}
-
-#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
-    *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog)
-
-#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
-    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
-        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
-
-#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
-    if (MEM_64bits()) \
-        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
-
-static inline size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 4 symbols at a time */
-    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4))
-    {
-        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
-        HUF_DECODE_SYMBOLX2_1(p, bitDPtr);
-        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
-        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-    }
-
-    /* closer to the end */
-    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd))
-        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-
-    /* no more data to retrieve from bitstream, hence no need to reload */
-    while (p < pEnd)
-        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-
-    return pEnd-pStart;
-}
-
-
-static size_t HUF_decompress4X2_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const U16* DTable)
-{
-    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
-
-    {
-        const BYTE* const istart = (const BYTE*) cSrc;
-        BYTE* const ostart = (BYTE*) dst;
-        BYTE* const oend = ostart + dstSize;
-
-        const void* ptr = DTable;
-        const HUF_DEltX2* const dt = ((const HUF_DEltX2*)ptr) +1;
-        const U32 dtLog = DTable[0];
-        size_t errorCode;
-
-        /* Init */
-        BIT_DStream_t bitD1;
-        BIT_DStream_t bitD2;
-        BIT_DStream_t bitD3;
-        BIT_DStream_t bitD4;
-        const size_t length1 = MEM_readLE16(istart);
-        const size_t length2 = MEM_readLE16(istart+2);
-        const size_t length3 = MEM_readLE16(istart+4);
-        size_t length4;
-        const BYTE* const istart1 = istart + 6;  /* jumpTable */
-        const BYTE* const istart2 = istart1 + length1;
-        const BYTE* const istart3 = istart2 + length2;
-        const BYTE* const istart4 = istart3 + length3;
-        const size_t segmentSize = (dstSize+3) / 4;
-        BYTE* const opStart2 = ostart + segmentSize;
-        BYTE* const opStart3 = opStart2 + segmentSize;
-        BYTE* const opStart4 = opStart3 + segmentSize;
-        BYTE* op1 = ostart;
-        BYTE* op2 = opStart2;
-        BYTE* op3 = opStart3;
-        BYTE* op4 = opStart4;
-        U32 endSignal;
-
-        length4 = cSrcSize - (length1 + length2 + length3 + 6);
-        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
-        errorCode = BIT_initDStream(&bitD1, istart1, length1);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD2, istart2, length2);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD3, istart3, length3);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD4, istart4, length4);
-        if (HUF_isError(errorCode)) return errorCode;
-
-        /* 16-32 symbols per loop (4-8 symbols per stream) */
-        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
-        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )
-        {
-            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
-            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
-            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
-            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
-            HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
-            HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
-            HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
-            HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
-            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
-            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
-            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
-            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
-            HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
-            HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
-            HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
-            HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
-
-            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
-        }
-
-        /* check corruption */
-        if (op1 > opStart2) return ERROR(corruption_detected);
-        if (op2 > opStart3) return ERROR(corruption_detected);
-        if (op3 > opStart4) return ERROR(corruption_detected);
-        /* note : op4 supposed already verified within main loop */
-
-        /* finish bitStreams one by one */
-        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
-        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
-        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
-        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
-
-        /* check */
-        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
-        if (!endSignal) return ERROR(corruption_detected);
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
-
-static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-    size_t errorCode;
-
-    errorCode = HUF_readDTableX2 (DTable, cSrc, cSrcSize);
-    if (HUF_isError(errorCode)) return errorCode;
-    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += errorCode;
-    cSrcSize -= errorCode;
-
-    return HUF_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
-}
-
-
-/***************************/
-/* double-symbols decoding */
-/***************************/
-
-static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed,
-                           const U32* rankValOrigin, const int minWeight,
-                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
-                           U32 nbBitsBaseline, U16 baseSeq)
-{
-    HUF_DEltX4 DElt;
-    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];
-    U32 s;
-
-    /* get pre-calculated rankVal */
-    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
-
-    /* fill skipped values */
-    if (minWeight>1)
-    {
-        U32 i, skipSize = rankVal[minWeight];
-        MEM_writeLE16(&(DElt.sequence), baseSeq);
-        DElt.nbBits   = (BYTE)(consumed);
-        DElt.length   = 1;
-        for (i = 0; i < skipSize; i++)
-            DTable[i] = DElt;
-    }
-
-    /* fill DTable */
-    for (s=0; s<sortedListSize; s++)   /* note : sortedSymbols already skipped */
-    {
-        const U32 symbol = sortedSymbols[s].symbol;
-        const U32 weight = sortedSymbols[s].weight;
-        const U32 nbBits = nbBitsBaseline - weight;
-        const U32 length = 1 << (sizeLog-nbBits);
-        const U32 start = rankVal[weight];
-        U32 i = start;
-        const U32 end = start + length;
-
-        MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
-        DElt.nbBits = (BYTE)(nbBits + consumed);
-        DElt.length = 2;
-        do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */
-
-        rankVal[weight] += length;
-    }
-}
-
-typedef U32 rankVal_t[HUF_ABSOLUTEMAX_TABLELOG][HUF_ABSOLUTEMAX_TABLELOG + 1];
-
-static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog,
-                           const sortedSymbol_t* sortedList, const U32 sortedListSize,
-                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
-                           const U32 nbBitsBaseline)
-{
-    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];
-    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */
-    const U32 minBits  = nbBitsBaseline - maxWeight;
-    U32 s;
-
-    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
-
-    /* fill DTable */
-    for (s=0; s<sortedListSize; s++)
-    {
-        const U16 symbol = sortedList[s].symbol;
-        const U32 weight = sortedList[s].weight;
-        const U32 nbBits = nbBitsBaseline - weight;
-        const U32 start = rankVal[weight];
-        const U32 length = 1 << (targetLog-nbBits);
-
-        if (targetLog-nbBits >= minBits)   /* enough room for a second symbol */
-        {
-            U32 sortedRank;
-            int minWeight = nbBits + scaleLog;
-            if (minWeight < 1) minWeight = 1;
-            sortedRank = rankStart[minWeight];
-            HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,
-                           rankValOrigin[nbBits], minWeight,
-                           sortedList+sortedRank, sortedListSize-sortedRank,
-                           nbBitsBaseline, symbol);
-        }
-        else
-        {
-            U32 i;
-            const U32 end = start + length;
-            HUF_DEltX4 DElt;
-
-            MEM_writeLE16(&(DElt.sequence), symbol);
-            DElt.nbBits   = (BYTE)(nbBits);
-            DElt.length   = 1;
-            for (i = start; i < end; i++)
-                DTable[i] = DElt;
-        }
-        rankVal[weight] += length;
-    }
-}
-
-static size_t HUF_readDTableX4 (U32* DTable, const void* src, size_t srcSize)
-{
-    BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1];
-    sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1];
-    U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 };
-    U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 };
-    U32* const rankStart = rankStart0+1;
-    rankVal_t rankVal;
-    U32 tableLog, maxW, sizeOfSort, nbSymbols;
-    const U32 memLog = DTable[0];
-    const BYTE* ip = (const BYTE*) src;
-    size_t iSize = ip[0];
-    void* ptr = DTable;
-    HUF_DEltX4* const dt = ((HUF_DEltX4*)ptr) + 1;
-
-    HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */
-    if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);
-    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
-    if (HUF_isError(iSize)) return iSize;
-
-    /* check result */
-    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
-
-    /* find maxWeight */
-    for (maxW = tableLog; rankStats[maxW]==0; maxW--)
-        {if (!maxW) return ERROR(GENERIC); }  /* necessarily finds a solution before maxW==0 */
-
-    /* Get start index of each weight */
-    {
-        U32 w, nextRankStart = 0;
-        for (w=1; w<=maxW; w++)
-        {
-            U32 current = nextRankStart;
-            nextRankStart += rankStats[w];
-            rankStart[w] = current;
-        }
-        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
-        sizeOfSort = nextRankStart;
-    }
-
-    /* sort symbols by weight */
-    {
-        U32 s;
-        for (s=0; s<nbSymbols; s++)
-        {
-            U32 w = weightList[s];
-            U32 r = rankStart[w]++;
-            sortedSymbol[r].symbol = (BYTE)s;
-            sortedSymbol[r].weight = (BYTE)w;
-        }
-        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
-    }
-
-	/* Build rankVal */
-    {
-        const U32 minBits = tableLog+1 - maxW;
-        U32 nextRankVal = 0;
-        U32 w, consumed;
-        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */
-        U32* rankVal0 = rankVal[0];
-        for (w=1; w<=maxW; w++)
-        {
-            U32 current = nextRankVal;
-            nextRankVal += rankStats[w] << (w+rescale);
-            rankVal0[w] = current;
-        }
-        for (consumed = minBits; consumed <= memLog - minBits; consumed++)
-        {
-            U32* rankValPtr = rankVal[consumed];
-            for (w = 1; w <= maxW; w++)
-            {
-                rankValPtr[w] = rankVal0[w] >> consumed;
-            }
-        }
-    }
-
-    HUF_fillDTableX4(dt, memLog,
-                   sortedSymbol, sizeOfSort,
-                   rankStart0, rankVal, maxW,
-                   tableLog+1);
-
-    return iSize;
-}
-
-
-static U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)
-{
-    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    memcpy(op, dt+val, 2);
-    BIT_skipBits(DStream, dt[val].nbBits);
-    return dt[val].length;
-}
-
-static U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)
-{
-    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    memcpy(op, dt+val, 1);
-    if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);
-    else
-    {
-        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8))
-        {
-            BIT_skipBits(DStream, dt[val].nbBits);
-            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
-                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
-        }
-    }
-    return 1;
-}
-
-
-#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \
-    ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-#define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \
-    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
-        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-#define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \
-    if (MEM_64bits()) \
-        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-static inline size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 8 symbols at a time */
-    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd-7))
-    {
-        HUF_DECODE_SYMBOLX4_2(p, bitDPtr);
-        HUF_DECODE_SYMBOLX4_1(p, bitDPtr);
-        HUF_DECODE_SYMBOLX4_2(p, bitDPtr);
-        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);
-    }
-
-    /* closer to the end */
-    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-2))
-        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);
-
-    while (p <= pEnd-2)
-        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
-
-    if (p < pEnd)
-        p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);
-
-    return p-pStart;
-}
-
-
-
-static size_t HUF_decompress4X4_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const U32* DTable)
-{
-    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
-
-    {
-        const BYTE* const istart = (const BYTE*) cSrc;
-        BYTE* const ostart = (BYTE*) dst;
-        BYTE* const oend = ostart + dstSize;
-
-        const void* ptr = DTable;
-        const HUF_DEltX4* const dt = ((const HUF_DEltX4*)ptr) +1;
-        const U32 dtLog = DTable[0];
-        size_t errorCode;
-
-        /* Init */
-        BIT_DStream_t bitD1;
-        BIT_DStream_t bitD2;
-        BIT_DStream_t bitD3;
-        BIT_DStream_t bitD4;
-        const size_t length1 = MEM_readLE16(istart);
-        const size_t length2 = MEM_readLE16(istart+2);
-        const size_t length3 = MEM_readLE16(istart+4);
-        size_t length4;
-        const BYTE* const istart1 = istart + 6;  /* jumpTable */
-        const BYTE* const istart2 = istart1 + length1;
-        const BYTE* const istart3 = istart2 + length2;
-        const BYTE* const istart4 = istart3 + length3;
-        const size_t segmentSize = (dstSize+3) / 4;
-        BYTE* const opStart2 = ostart + segmentSize;
-        BYTE* const opStart3 = opStart2 + segmentSize;
-        BYTE* const opStart4 = opStart3 + segmentSize;
-        BYTE* op1 = ostart;
-        BYTE* op2 = opStart2;
-        BYTE* op3 = opStart3;
-        BYTE* op4 = opStart4;
-        U32 endSignal;
-
-        length4 = cSrcSize - (length1 + length2 + length3 + 6);
-        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
-        errorCode = BIT_initDStream(&bitD1, istart1, length1);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD2, istart2, length2);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD3, istart3, length3);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD4, istart4, length4);
-        if (HUF_isError(errorCode)) return errorCode;
-
-        /* 16-32 symbols per loop (4-8 symbols per stream) */
-        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
-        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )
-        {
-            HUF_DECODE_SYMBOLX4_2(op1, &bitD1);
-            HUF_DECODE_SYMBOLX4_2(op2, &bitD2);
-            HUF_DECODE_SYMBOLX4_2(op3, &bitD3);
-            HUF_DECODE_SYMBOLX4_2(op4, &bitD4);
-            HUF_DECODE_SYMBOLX4_1(op1, &bitD1);
-            HUF_DECODE_SYMBOLX4_1(op2, &bitD2);
-            HUF_DECODE_SYMBOLX4_1(op3, &bitD3);
-            HUF_DECODE_SYMBOLX4_1(op4, &bitD4);
-            HUF_DECODE_SYMBOLX4_2(op1, &bitD1);
-            HUF_DECODE_SYMBOLX4_2(op2, &bitD2);
-            HUF_DECODE_SYMBOLX4_2(op3, &bitD3);
-            HUF_DECODE_SYMBOLX4_2(op4, &bitD4);
-            HUF_DECODE_SYMBOLX4_0(op1, &bitD1);
-            HUF_DECODE_SYMBOLX4_0(op2, &bitD2);
-            HUF_DECODE_SYMBOLX4_0(op3, &bitD3);
-            HUF_DECODE_SYMBOLX4_0(op4, &bitD4);
-
-            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
-        }
-
-        /* check corruption */
-        if (op1 > opStart2) return ERROR(corruption_detected);
-        if (op2 > opStart3) return ERROR(corruption_detected);
-        if (op3 > opStart4) return ERROR(corruption_detected);
-        /* note : op4 supposed already verified within main loop */
-
-        /* finish bitStreams one by one */
-        HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);
-        HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);
-        HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);
-        HUF_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog);
-
-        /* check */
-        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
-        if (!endSignal) return ERROR(corruption_detected);
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
-
-static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t hSize = HUF_readDTableX4 (DTable, cSrc, cSrcSize);
-    if (HUF_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize;
-    cSrcSize -= hSize;
-
-    return HUF_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
-}
-
-
-/**********************************/
-/* quad-symbol decoding           */
-/**********************************/
-typedef struct { BYTE nbBits; BYTE nbBytes; } HUF_DDescX6;
-typedef union { BYTE byte[4]; U32 sequence; } HUF_DSeqX6;
-
-/* recursive, up to level 3; may benefit from <template>-like strategy to nest each level inline */
-static void HUF_fillDTableX6LevelN(HUF_DDescX6* DDescription, HUF_DSeqX6* DSequence, int sizeLog,
-                           const rankVal_t rankValOrigin, const U32 consumed, const int minWeight, const U32 maxWeight,
-                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize, const U32* rankStart,
-                           const U32 nbBitsBaseline, HUF_DSeqX6 baseSeq, HUF_DDescX6 DDesc)
-{
-    const int scaleLog = nbBitsBaseline - sizeLog;   /* note : targetLog >= (nbBitsBaseline-1), hence scaleLog <= 1 */
-    const int minBits  = nbBitsBaseline - maxWeight;
-    const U32 level = DDesc.nbBytes;
-    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];
-    U32 symbolStartPos, s;
-
-    /* local rankVal, will be modified */
-    memcpy(rankVal, rankValOrigin[consumed], sizeof(rankVal));
-
-    /* fill skipped values */
-    if (minWeight>1)
-    {
-        U32 i;
-        const U32 skipSize = rankVal[minWeight];
-        for (i = 0; i < skipSize; i++)
-        {
-            DSequence[i] = baseSeq;
-            DDescription[i] = DDesc;
-        }
-    }
-
-    /* fill DTable */
-    DDesc.nbBytes++;
-    symbolStartPos = rankStart[minWeight];
-    for (s=symbolStartPos; s<sortedListSize; s++)
-    {
-        const BYTE symbol = sortedSymbols[s].symbol;
-        const U32  weight = sortedSymbols[s].weight;   /* >= 1 (sorted) */
-        const int  nbBits = nbBitsBaseline - weight;   /* >= 1 (by construction) */
-        const int  totalBits = consumed+nbBits;
-        const U32  start  = rankVal[weight];
-        const U32  length = 1 << (sizeLog-nbBits);
-        baseSeq.byte[level] = symbol;
-        DDesc.nbBits = (BYTE)totalBits;
-
-        if ((level<3) && (sizeLog-totalBits >= minBits))   /* enough room for another symbol */
-        {
-            int nextMinWeight = totalBits + scaleLog;
-            if (nextMinWeight < 1) nextMinWeight = 1;
-            HUF_fillDTableX6LevelN(DDescription+start, DSequence+start, sizeLog-nbBits,
-                           rankValOrigin, totalBits, nextMinWeight, maxWeight,
-                           sortedSymbols, sortedListSize, rankStart,
-                           nbBitsBaseline, baseSeq, DDesc);   /* recursive (max : level 3) */
-        }
-        else
-        {
-            U32 i;
-            const U32 end = start + length;
-            for (i = start; i < end; i++)
-            {
-                DDescription[i] = DDesc;
-                DSequence[i] = baseSeq;
-            }
-        }
-        rankVal[weight] += length;
-    }
-}
-
-
-/* note : same preparation as X4 */
-static size_t HUF_readDTableX6 (U32* DTable, const void* src, size_t srcSize)
-{
-    BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1];
-    sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1];
-    U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 };
-    U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 };
-    U32* const rankStart = rankStart0+1;
-    U32 tableLog, maxW, sizeOfSort, nbSymbols;
-    rankVal_t rankVal;
-    const U32 memLog = DTable[0];
-    const BYTE* ip = (const BYTE*) src;
-    size_t iSize = ip[0];
-
-    if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);
-    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
-    if (HUF_isError(iSize)) return iSize;
-
-    /* check result */
-    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable is too small */
-
-    /* find maxWeight */
-    for (maxW = tableLog; rankStats[maxW]==0; maxW--)
-        { if (!maxW) return ERROR(GENERIC); }  /* necessarily finds a solution before maxW==0 */
-
-
-    /* Get start index of each weight */
-    {
-        U32 w, nextRankStart = 0;
-        for (w=1; w<=maxW; w++)
-        {
-            U32 current = nextRankStart;
-            nextRankStart += rankStats[w];
-            rankStart[w] = current;
-        }
-        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
-        sizeOfSort = nextRankStart;
-    }
-
-    /* sort symbols by weight */
-    {
-        U32 s;
-        for (s=0; s<nbSymbols; s++)
-        {
-            U32 w = weightList[s];
-            U32 r = rankStart[w]++;
-            sortedSymbol[r].symbol = (BYTE)s;
-            sortedSymbol[r].weight = (BYTE)w;
-        }
-        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
-    }
-
-	/* Build rankVal */
-    {
-        const U32 minBits = tableLog+1 - maxW;
-        U32 nextRankVal = 0;
-        U32 w, consumed;
-        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */
-        U32* rankVal0 = rankVal[0];
-        for (w=1; w<=maxW; w++)
-        {
-            U32 current = nextRankVal;
-            nextRankVal += rankStats[w] << (w+rescale);
-            rankVal0[w] = current;
-        }
-        for (consumed = minBits; consumed <= memLog - minBits; consumed++)
-        {
-            U32* rankValPtr = rankVal[consumed];
-            for (w = 1; w <= maxW; w++)
-            {
-                rankValPtr[w] = rankVal0[w] >> consumed;
-            }
-        }
-    }
-
-
-    /* fill tables */
-    {
-        void* ptr = DTable+1;
-        HUF_DDescX6* DDescription = (HUF_DDescX6*)(ptr);
-        void* dSeqStart = DTable + 1 + ((size_t)1<<(memLog-1));
-        HUF_DSeqX6* DSequence = (HUF_DSeqX6*)(dSeqStart);
-        HUF_DSeqX6 DSeq;
-        HUF_DDescX6 DDesc;
-        DSeq.sequence = 0;
-        DDesc.nbBits = 0;
-        DDesc.nbBytes = 0;
-        HUF_fillDTableX6LevelN(DDescription, DSequence, memLog,
-                       (const U32 (*)[HUF_ABSOLUTEMAX_TABLELOG + 1])rankVal, 0, 1, maxW,
-                       sortedSymbol, sizeOfSort, rankStart0,
-                       tableLog+1, DSeq, DDesc);
-    }
-
-    return iSize;
-}
-
-
-static U32 HUF_decodeSymbolX6(void* op, BIT_DStream_t* DStream, const HUF_DDescX6* dd, const HUF_DSeqX6* ds, const U32 dtLog)
-{
-    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    memcpy(op, ds+val, sizeof(HUF_DSeqX6));
-    BIT_skipBits(DStream, dd[val].nbBits);
-    return dd[val].nbBytes;
-}
-
-static U32 HUF_decodeLastSymbolsX6(void* op, const U32 maxL, BIT_DStream_t* DStream,
-                                  const HUF_DDescX6* dd, const HUF_DSeqX6* ds, const U32 dtLog)
-{
-    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    U32 length = dd[val].nbBytes;
-    if (length <= maxL)
-    {
-        memcpy(op, ds+val, length);
-        BIT_skipBits(DStream, dd[val].nbBits);
-        return length;
-    }
-    memcpy(op, ds+val, maxL);
-    if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8))
-    {
-        BIT_skipBits(DStream, dd[val].nbBits);
-        if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
-            DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
-    }
-    return maxL;
-}
-
-
-#define HUF_DECODE_SYMBOLX6_0(ptr, DStreamPtr) \
-    ptr += HUF_decodeSymbolX6(ptr, DStreamPtr, dd, ds, dtLog)
-
-#define HUF_DECODE_SYMBOLX6_1(ptr, DStreamPtr) \
-    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
-        HUF_DECODE_SYMBOLX6_0(ptr, DStreamPtr)
-
-#define HUF_DECODE_SYMBOLX6_2(ptr, DStreamPtr) \
-    if (MEM_64bits()) \
-        HUF_DECODE_SYMBOLX6_0(ptr, DStreamPtr)
-
-static inline size_t HUF_decodeStreamX6(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const U32* DTable, const U32 dtLog)
-{
-    const void* ddPtr = DTable+1;
-    const HUF_DDescX6* dd = (const HUF_DDescX6*)(ddPtr);
-    const void* dsPtr = DTable + 1 + ((size_t)1<<(dtLog-1));
-    const HUF_DSeqX6* ds = (const HUF_DSeqX6*)(dsPtr);
-    BYTE* const pStart = p;
-
-    /* up to 16 symbols at a time */
-    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-16))
-    {
-        HUF_DECODE_SYMBOLX6_2(p, bitDPtr);
-        HUF_DECODE_SYMBOLX6_1(p, bitDPtr);
-        HUF_DECODE_SYMBOLX6_2(p, bitDPtr);
-        HUF_DECODE_SYMBOLX6_0(p, bitDPtr);
-    }
-
-    /* closer to the end, up to 4 symbols at a time */
-    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4))
-        HUF_DECODE_SYMBOLX6_0(p, bitDPtr);
-
-    while (p <= pEnd-4)
-        HUF_DECODE_SYMBOLX6_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
-
-    while (p < pEnd)
-        p += HUF_decodeLastSymbolsX6(p, (U32)(pEnd-p), bitDPtr, dd, ds, dtLog);
-
-    return p-pStart;
-}
-
-
-
-static size_t HUF_decompress4X6_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const U32* DTable)
-{
-    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
-
-    {
-        const BYTE* const istart = (const BYTE*) cSrc;
-        BYTE* const ostart = (BYTE*) dst;
-        BYTE* const oend = ostart + dstSize;
-
-        const U32 dtLog = DTable[0];
-        const void* ddPtr = DTable+1;
-        const HUF_DDescX6* dd = (const HUF_DDescX6*)(ddPtr);
-        const void* dsPtr = DTable + 1 + ((size_t)1<<(dtLog-1));
-        const HUF_DSeqX6* ds = (const HUF_DSeqX6*)(dsPtr);
-        size_t errorCode;
-
-        /* Init */
-        BIT_DStream_t bitD1;
-        BIT_DStream_t bitD2;
-        BIT_DStream_t bitD3;
-        BIT_DStream_t bitD4;
-        const size_t length1 = MEM_readLE16(istart);
-        const size_t length2 = MEM_readLE16(istart+2);
-        const size_t length3 = MEM_readLE16(istart+4);
-        size_t length4;
-        const BYTE* const istart1 = istart + 6;  /* jumpTable */
-        const BYTE* const istart2 = istart1 + length1;
-        const BYTE* const istart3 = istart2 + length2;
-        const BYTE* const istart4 = istart3 + length3;
-        const size_t segmentSize = (dstSize+3) / 4;
-        BYTE* const opStart2 = ostart + segmentSize;
-        BYTE* const opStart3 = opStart2 + segmentSize;
-        BYTE* const opStart4 = opStart3 + segmentSize;
-        BYTE* op1 = ostart;
-        BYTE* op2 = opStart2;
-        BYTE* op3 = opStart3;
-        BYTE* op4 = opStart4;
-        U32 endSignal;
-
-        length4 = cSrcSize - (length1 + length2 + length3 + 6);
-        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
-        errorCode = BIT_initDStream(&bitD1, istart1, length1);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD2, istart2, length2);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD3, istart3, length3);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD4, istart4, length4);
-        if (HUF_isError(errorCode)) return errorCode;
-
-        /* 16-64 symbols per loop (4-16 symbols per stream) */
-        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
-        for ( ; (op3 <= opStart4) && (endSignal==BIT_DStream_unfinished) && (op4<=(oend-16)) ; )
-        {
-            HUF_DECODE_SYMBOLX6_2(op1, &bitD1);
-            HUF_DECODE_SYMBOLX6_2(op2, &bitD2);
-            HUF_DECODE_SYMBOLX6_2(op3, &bitD3);
-            HUF_DECODE_SYMBOLX6_2(op4, &bitD4);
-            HUF_DECODE_SYMBOLX6_1(op1, &bitD1);
-            HUF_DECODE_SYMBOLX6_1(op2, &bitD2);
-            HUF_DECODE_SYMBOLX6_1(op3, &bitD3);
-            HUF_DECODE_SYMBOLX6_1(op4, &bitD4);
-            HUF_DECODE_SYMBOLX6_2(op1, &bitD1);
-            HUF_DECODE_SYMBOLX6_2(op2, &bitD2);
-            HUF_DECODE_SYMBOLX6_2(op3, &bitD3);
-            HUF_DECODE_SYMBOLX6_2(op4, &bitD4);
-            HUF_DECODE_SYMBOLX6_0(op1, &bitD1);
-            HUF_DECODE_SYMBOLX6_0(op2, &bitD2);
-            HUF_DECODE_SYMBOLX6_0(op3, &bitD3);
-            HUF_DECODE_SYMBOLX6_0(op4, &bitD4);
-
-            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
-        }
-
-        /* check corruption */
-        if (op1 > opStart2) return ERROR(corruption_detected);
-        if (op2 > opStart3) return ERROR(corruption_detected);
-        if (op3 > opStart4) return ERROR(corruption_detected);
-        /* note : op4 supposed already verified within main loop */
-
-        /* finish bitStreams one by one */
-        HUF_decodeStreamX6(op1, &bitD1, opStart2, DTable, dtLog);
-        HUF_decodeStreamX6(op2, &bitD2, opStart3, DTable, dtLog);
-        HUF_decodeStreamX6(op3, &bitD3, opStart4, DTable, dtLog);
-        HUF_decodeStreamX6(op4, &bitD4, oend,     DTable, dtLog);
-
-        /* check */
-        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
-        if (!endSignal) return ERROR(corruption_detected);
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
-
-static size_t HUF_decompress4X6 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUF_CREATE_STATIC_DTABLEX6(DTable, HUF_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t hSize = HUF_readDTableX6 (DTable, cSrc, cSrcSize);
-    if (HUF_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize;
-    cSrcSize -= hSize;
-
-    return HUF_decompress4X6_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
-}
-
-
-/**********************************/
-/* Generic decompression selector */
-/**********************************/
-
-typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
-static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] =
-{
-    /* single, double, quad */
-    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */
-    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */
-    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */
-    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */
-    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */
-    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */
-    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */
-    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */
-    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */
-    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */
-    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */
-    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */
-    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */
-    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */
-    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */
-    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */
-};
-
-typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
-
-static size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    static const decompressionAlgo decompress[3] = { HUF_decompress4X2, HUF_decompress4X4, HUF_decompress4X6 };
-    /* estimate decompression time */
-    U32 Q;
-    const U32 D256 = (U32)(dstSize >> 8);
-    U32 Dtime[3];
-    U32 algoNb = 0;
-    int n;
-
-    /* validation checks */
-    if (dstSize == 0) return ERROR(dstSize_tooSmall);
-    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
-    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
-    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
-
-    /* decoder timing evaluation */
-    Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */
-    for (n=0; n<3; n++)
-        Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256);
-
-    Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */
-
-    if (Dtime[1] < Dtime[0]) algoNb = 1;
-    if (Dtime[2] < Dtime[algoNb]) algoNb = 2;
-
-    return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
-
-    //return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize);   /* multi-streams single-symbol decoding */
-    //return HUF_decompress4X4(dst, dstSize, cSrc, cSrcSize);   /* multi-streams double-symbols decoding */
-    //return HUF_decompress4X6(dst, dstSize, cSrc, cSrcSize);   /* multi-streams quad-symbols decoding */
-}
-/*
-    zstd - standard compression library
-    Copyright (C) 2014-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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-
-/* ***************************************************************
-*  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
-*/
-#define ZSTD_MEMORY_USAGE 17
-
-/*!
- * HEAPMODE :
- * Select how default compression functions will allocate memory for their hash table,
- * in memory stack (0, fastest), or in memory heap (1, requires malloc())
- * Note that compression context is fairly large, as a consequence heap memory is recommended.
- */
-#ifndef ZSTD_HEAPMODE
-#  define ZSTD_HEAPMODE 1
-#endif /* ZSTD_HEAPMODE */
-
-/*!
-*  LEGACY_SUPPORT :
-*  decompressor can decode older formats (starting from Zstd 0.1+)
-*/
-#ifndef ZSTD_LEGACY_SUPPORT
-#  define ZSTD_LEGACY_SUPPORT 1
-#endif
-
-
-/* *******************************************************
-*  Includes
-*********************************************************/
-#include <stdlib.h>      /* calloc */
-#include <string.h>      /* memcpy, memmove */
-#include <stdio.h>       /* debug : printf */
-
-
-/* *******************************************************
-*  Compiler specifics
-*********************************************************/
-#ifdef __AVX2__
-#  include <immintrin.h>   /* AVX2 intrinsics */
-#endif
-
-#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 : 4324)        /* disable: C4324: padded structure */
-#else
-#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#  ifdef __GNUC__
-#    define FORCE_INLINE static inline __attribute__((always_inline))
-#  else
-#    define FORCE_INLINE static inline
-#  endif
-#endif
-
-
-/* *******************************************************
-*  Constants
-*********************************************************/
-#define HASH_LOG (ZSTD_MEMORY_USAGE - 2)
-#define HASH_TABLESIZE (1 << HASH_LOG)
-#define HASH_MASK (HASH_TABLESIZE - 1)
-
-#define KNUTH 2654435761
-
-#define BIT7 128
-#define BIT6  64
-#define BIT5  32
-#define BIT4  16
-#define BIT1   2
-#define BIT0   1
-
-#define KB *(1 <<10)
-#define MB *(1 <<20)
-#define GB *(1U<<30)
-
-#define BLOCKSIZE (128 KB)                 /* define, for static allocation */
-#define MIN_SEQUENCES_SIZE (2 /*seqNb*/ + 2 /*dumps*/ + 3 /*seqTables*/ + 1 /*bitStream*/)
-#define MIN_CBLOCK_SIZE (3 /*litCSize*/ + MIN_SEQUENCES_SIZE)
-#define IS_RAW BIT0
-#define IS_RLE BIT1
-
-#define WORKPLACESIZE (BLOCKSIZE*3)
-#define MINMATCH 4
-#define MLbits   7
-#define LLbits   6
-#define Offbits  5
-#define MaxML  ((1<<MLbits )-1)
-#define MaxLL  ((1<<LLbits )-1)
-#define MaxOff   31
-#define LitFSELog  11
-#define MLFSELog   10
-#define LLFSELog   10
-#define OffFSELog   9
-#define MAX(a,b) ((a)<(b)?(b):(a))
-#define MaxSeq MAX(MaxLL, MaxML)
-
-#define LITERAL_NOENTROPY 63
-#define COMMAND_NOENTROPY 7   /* to remove */
-
-static const size_t ZSTD_blockHeaderSize = 3;
-static const size_t ZSTD_frameHeaderSize = 4;
-
-
-/* *******************************************************
-*  Memory operations
-**********************************************************/
-static void   ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
-
-static void   ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
-
-#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; }
-
-/*! ZSTD_wildcopy : custom version of memcpy(), can copy up to 7-8 bytes too many */
-static void ZSTD_wildcopy(void* dst, const void* src, size_t length)
-{
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + length;
-    do COPY8(op, ip) while (op < oend);
-}
-
-
-/* **************************************
-*  Local structures
-****************************************/
-typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;
-
-typedef struct
-{
-    blockType_t blockType;
-    U32 origSize;
-} blockProperties_t;
-
-typedef struct {
-    void* buffer;
-    U32*  offsetStart;
-    U32*  offset;
-    BYTE* offCodeStart;
-    BYTE* offCode;
-    BYTE* litStart;
-    BYTE* lit;
-    BYTE* litLengthStart;
-    BYTE* litLength;
-    BYTE* matchLengthStart;
-    BYTE* matchLength;
-    BYTE* dumpsStart;
-    BYTE* dumps;
-} seqStore_t;
-
-
-/* *************************************
-*  Error Management
-***************************************/
-/*! ZSTD_isError
-*   tells if a return value is an error code */
-static unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }
-
-
-/* *************************************
-*  Function body to include
-***************************************/
-static size_t ZSTD_read_ARCH(const void* p) { size_t r; memcpy(&r, p, sizeof(r)); return r; }
-
-MEM_STATIC unsigned ZSTD_NbCommonBytes (register size_t val)
-{
-    if (MEM_isLittleEndian())
-    {
-        if (MEM_64bits())
-        {
-#       if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r = 0;
-            _BitScanForward64( &r, (U64)val );
-            return (int)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (__builtin_ctzll((U64)val) >> 3);
-#       else
-            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 };
-            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];
-#       endif
-        }
-        else /* 32 bits */
-        {
-#       if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r;
-            _BitScanForward( &r, (U32)val );
-            return (int)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (__builtin_ctz((U32)val) >> 3);
-#       else
-            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 };
-            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
-#       endif
-        }
-    }
-    else   /* Big Endian CPU */
-    {
-        if (MEM_32bits())
-        {
-#       if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r = 0;
-            _BitScanReverse64( &r, val );
-            return (unsigned)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (__builtin_clzll(val) >> 3);
-#       else
-            unsigned r;
-            const unsigned n32 = sizeof(size_t)*4;   /* calculate this way due to compiler complaining in 32-bits mode */
-            if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; }
-            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
-            r += (!val);
-            return r;
-#       endif
-        }
-        else /* 32 bits */
-        {
-#       if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r = 0;
-            _BitScanReverse( &r, (unsigned long)val );
-            return (unsigned)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (__builtin_clz((U32)val) >> 3);
-#       else
-            unsigned r;
-            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
-            r += (!val);
-            return r;
-#       endif
-        }
-    }
-}
-
-
-MEM_STATIC size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
-{
-    const BYTE* const pStart = pIn;
-
-    while ((pIn<pInLimit-(sizeof(size_t)-1)))
-    {
-        size_t diff = ZSTD_read_ARCH(pMatch) ^ ZSTD_read_ARCH(pIn);
-        if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; }
-        pIn += ZSTD_NbCommonBytes(diff);
-        return (size_t)(pIn - pStart);
-    }
-
-    if (MEM_32bits()) if ((pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; }
-    if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; }
-    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
-    return (size_t)(pIn - pStart);
-}
-
-
-/* *************************************************************
-*   Decompression section
-***************************************************************/
-struct ZSTD_DCtx_s
-{
-    U32 LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)];
-    U32 OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)];
-    U32 MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)];
-    void* previousDstEnd;
-    void* base;
-    size_t expected;
-    blockType_t bType;
-    U32 phase;
-    const BYTE* litPtr;
-    size_t litBufSize;
-    size_t litSize;
-    BYTE litBuffer[BLOCKSIZE + 8 /* margin for wildcopy */];
-};   /* typedef'd to ZSTD_Dctx within "zstd_static.h" */
-
-
-static size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
-{
-    const BYTE* const in = (const BYTE* const)src;
-    BYTE headerFlags;
-    U32 cSize;
-
-    if (srcSize < 3) return ERROR(srcSize_wrong);
-
-    headerFlags = *in;
-    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);
-
-    bpPtr->blockType = (blockType_t)(headerFlags >> 6);
-    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;
-
-    if (bpPtr->blockType == bt_end) return 0;
-    if (bpPtr->blockType == bt_rle) return 1;
-    return cSize;
-}
-
-static size_t ZSTD_copyUncompressedBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall);
-    memcpy(dst, src, srcSize);
-    return srcSize;
-}
-
-
-/** ZSTD_decompressLiterals
-    @return : nb of bytes read from src, or an error code*/
-static size_t ZSTD_decompressLiterals(void* dst, size_t* maxDstSizePtr,
-                                const void* src, size_t srcSize)
-{
-    const BYTE* ip = (const BYTE*)src;
-
-    const size_t litSize = (MEM_readLE32(src) & 0x1FFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
-    const size_t litCSize = (MEM_readLE32(ip+2) & 0xFFFFFF) >> 5;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
-
-    if (litSize > *maxDstSizePtr) return ERROR(corruption_detected);
-    if (litCSize + 5 > srcSize) return ERROR(corruption_detected);
-
-    if (HUF_isError(HUF_decompress(dst, litSize, ip+5, litCSize))) return ERROR(corruption_detected);
-
-    *maxDstSizePtr = litSize;
-    return litCSize + 5;
-}
-
-
-/** ZSTD_decodeLiteralsBlock
-    @return : nb of bytes read from src (< srcSize )*/
-static size_t ZSTD_decodeLiteralsBlock(void* ctx,
-                          const void* src, size_t srcSize)
-{
-    ZSTD_DCtx* dctx = (ZSTD_DCtx*)ctx;
-    const BYTE* const istart = (const BYTE* const)src;
-
-    /* any compressed block with literals segment must be at least this size */
-    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
-
-    switch(*istart & 3)
-    {
-    default:
-    case 0:
-        {
-            size_t litSize = BLOCKSIZE;
-            const size_t readSize = ZSTD_decompressLiterals(dctx->litBuffer, &litSize, src, srcSize);
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litBufSize = BLOCKSIZE;
-            dctx->litSize = litSize;
-            return readSize;   /* works if it's an error too */
-        }
-    case IS_RAW:
-        {
-            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
-            if (litSize > srcSize-11)   /* risk of reading too far with wildcopy */
-            {
-				if (litSize > srcSize-3) return ERROR(corruption_detected);
-				memcpy(dctx->litBuffer, istart, litSize);
-				dctx->litPtr = dctx->litBuffer;
-				dctx->litBufSize = BLOCKSIZE;
-				dctx->litSize = litSize;
-				return litSize+3;
-			}
-			/* direct reference into compressed stream */
-            dctx->litPtr = istart+3;
-            dctx->litBufSize = srcSize-3;
-            dctx->litSize = litSize;
-            return litSize+3;
-        }
-    case IS_RLE:
-        {
-            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
-            if (litSize > BLOCKSIZE) return ERROR(corruption_detected);
-            memset(dctx->litBuffer, istart[3], litSize);
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litBufSize = BLOCKSIZE;
-            dctx->litSize = litSize;
-            return 4;
-        }
-    }
-}
-
-
-static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,
-                         FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb,
-                         const void* src, size_t srcSize)
-{
-    const BYTE* const istart = (const BYTE* const)src;
-    const BYTE* ip = istart;
-    const BYTE* const iend = istart + srcSize;
-    U32 LLtype, Offtype, MLtype;
-    U32 LLlog, Offlog, MLlog;
-    size_t dumpsLength;
-
-    /* check */
-    if (srcSize < 5) return ERROR(srcSize_wrong);
-
-    /* SeqHead */
-    *nbSeq = MEM_readLE16(ip); ip+=2;
-    LLtype  = *ip >> 6;
-    Offtype = (*ip >> 4) & 3;
-    MLtype  = (*ip >> 2) & 3;
-    if (*ip & 2)
-    {
-        dumpsLength  = ip[2];
-        dumpsLength += ip[1] << 8;
-        ip += 3;
-    }
-    else
-    {
-        dumpsLength  = ip[1];
-        dumpsLength += (ip[0] & 1) << 8;
-        ip += 2;
-    }
-    *dumpsPtr = ip;
-    ip += dumpsLength;
-    *dumpsLengthPtr = dumpsLength;
-
-    /* check */
-    if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */
-
-    /* sequences */
-    {
-        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL and MaxOff */
-        size_t headerSize;
-
-        /* Build DTables */
-        switch(LLtype)
-        {
-        U32 max;
-        case bt_rle :
-            LLlog = 0;
-            FSE_buildDTable_rle(DTableLL, *ip++); break;
-        case bt_raw :
-            LLlog = LLbits;
-            FSE_buildDTable_raw(DTableLL, LLbits); break;
-        default :
-            max = MaxLL;
-            headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);
-            if (FSE_isError(headerSize)) return ERROR(GENERIC);
-            if (LLlog > LLFSELog) return ERROR(corruption_detected);
-            ip += headerSize;
-            FSE_buildDTable(DTableLL, norm, max, LLlog);
-        }
-
-        switch(Offtype)
-        {
-        U32 max;
-        case bt_rle :
-            Offlog = 0;
-            if (ip > iend-2) return ERROR(srcSize_wrong);   /* min : "raw", hence no header, but at least xxLog bits */
-            FSE_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */
-            break;
-        case bt_raw :
-            Offlog = Offbits;
-            FSE_buildDTable_raw(DTableOffb, Offbits); break;
-        default :
-            max = MaxOff;
-            headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);
-            if (FSE_isError(headerSize)) return ERROR(GENERIC);
-            if (Offlog > OffFSELog) return ERROR(corruption_detected);
-            ip += headerSize;
-            FSE_buildDTable(DTableOffb, norm, max, Offlog);
-        }
-
-        switch(MLtype)
-        {
-        U32 max;
-        case bt_rle :
-            MLlog = 0;
-            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */
-            FSE_buildDTable_rle(DTableML, *ip++); break;
-        case bt_raw :
-            MLlog = MLbits;
-            FSE_buildDTable_raw(DTableML, MLbits); break;
-        default :
-            max = MaxML;
-            headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);
-            if (FSE_isError(headerSize)) return ERROR(GENERIC);
-            if (MLlog > MLFSELog) return ERROR(corruption_detected);
-            ip += headerSize;
-            FSE_buildDTable(DTableML, norm, max, MLlog);
-        }
-    }
-
-    return ip-istart;
-}
-
-
-typedef struct {
-    size_t litLength;
-    size_t offset;
-    size_t matchLength;
-} seq_t;
-
-typedef struct {
-    BIT_DStream_t DStream;
-    FSE_DState_t stateLL;
-    FSE_DState_t stateOffb;
-    FSE_DState_t stateML;
-    size_t prevOffset;
-    const BYTE* dumps;
-    const BYTE* dumpsEnd;
-} seqState_t;
-
-
-static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState)
-{
-    size_t litLength;
-    size_t prevOffset;
-    size_t offset;
-    size_t matchLength;
-    const BYTE* dumps = seqState->dumps;
-    const BYTE* const de = seqState->dumpsEnd;
-
-    /* Literal length */
-    litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream));
-    prevOffset = litLength ? seq->offset : seqState->prevOffset;
-    seqState->prevOffset = seq->offset;
-    if (litLength == MaxLL)
-    {
-        U32 add = *dumps++;
-        if (add < 255) litLength += add;
-        else
-        {
-            litLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */
-            dumps += 3;
-        }
-        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */
-    }
-
-    /* Offset */
-    {
-        static const size_t offsetPrefix[MaxOff+1] = {  /* note : size_t faster than U32 */
-                1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256,
-                512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
-                524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 };
-        U32 offsetCode, nbBits;
-        offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream));   /* <= maxOff, by table construction */
-        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));
-        nbBits = offsetCode - 1;
-        if (offsetCode==0) nbBits = 0;   /* cmove */
-        offset = offsetPrefix[offsetCode] + BIT_readBits(&(seqState->DStream), nbBits);
-        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));
-        if (offsetCode==0) offset = prevOffset;   /* cmove */
-    }
-
-    /* MatchLength */
-    matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream));
-    if (matchLength == MaxML)
-    {
-        U32 add = *dumps++;
-        if (add < 255) matchLength += add;
-        else
-        {
-            matchLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */
-            dumps += 3;
-        }
-        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */
-    }
-    matchLength += MINMATCH;
-
-    /* save result */
-    seq->litLength = litLength;
-    seq->offset = offset;
-    seq->matchLength = matchLength;
-    seqState->dumps = dumps;
-}
-
-
-static size_t ZSTD_execSequence(BYTE* op,
-                                seq_t sequence,
-                                const BYTE** litPtr, const BYTE* const litLimit,
-                                BYTE* const base, BYTE* const oend)
-{
-    static const int dec32table[] = {0, 1, 2, 1, 4, 4, 4, 4};   /* added */
-    static const int dec64table[] = {8, 8, 8, 7, 8, 9,10,11};   /* substracted */
-    const BYTE* const ostart = op;
-    BYTE* const oLitEnd = op + sequence.litLength;
-    BYTE* const oMatchEnd = op + sequence.litLength + sequence.matchLength;   /* risk : address space overflow (32-bits) */
-    BYTE* const oend_8 = oend-8;
-    const BYTE* const litEnd = *litPtr + sequence.litLength;
-
-    /* checks */
-    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */
-    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */
-    if (litEnd > litLimit-8) return ERROR(corruption_detected);   /* overRead beyond lit buffer */
-
-    /* copy Literals */
-    ZSTD_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */
-    op = oLitEnd;
-    *litPtr = litEnd;   /* update for next sequence */
-
-    /* copy Match */
-    {
-        const BYTE* match = op - sequence.offset;
-
-        /* check */
-        if (sequence.offset > (size_t)op) return ERROR(corruption_detected);   /* address space overflow test (this test seems kept by clang optimizer) */
-        //if (match > op) return ERROR(corruption_detected);   /* address space overflow test (is clang optimizer removing this test ?) */
-        if (match < base) return ERROR(corruption_detected);
-
-        /* close range match, overlap */
-        if (sequence.offset < 8)
-        {
-            const int dec64 = dec64table[sequence.offset];
-            op[0] = match[0];
-            op[1] = match[1];
-            op[2] = match[2];
-            op[3] = match[3];
-            match += dec32table[sequence.offset];
-            ZSTD_copy4(op+4, match);
-            match -= dec64;
-        }
-        else
-        {
-            ZSTD_copy8(op, match);
-        }
-        op += 8; match += 8;
-
-        if (oMatchEnd > oend-12)
-        {
-            if (op < oend_8)
-            {
-                ZSTD_wildcopy(op, match, oend_8 - op);
-                match += oend_8 - op;
-                op = oend_8;
-            }
-            while (op < oMatchEnd) *op++ = *match++;
-        }
-        else
-        {
-            ZSTD_wildcopy(op, match, sequence.matchLength-8);   /* works even if matchLength < 8 */
-        }
-    }
-
-    return oMatchEnd - ostart;
-}
-
-static size_t ZSTD_decompressSequences(
-                               void* ctx,
-                               void* dst, size_t maxDstSize,
-                         const void* seqStart, size_t seqSize)
-{
-    ZSTD_DCtx* dctx = (ZSTD_DCtx*)ctx;
-    const BYTE* ip = (const BYTE*)seqStart;
-    const BYTE* const iend = ip + seqSize;
-    BYTE* const ostart = (BYTE* const)dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + maxDstSize;
-    size_t errorCode, dumpsLength;
-    const BYTE* litPtr = dctx->litPtr;
-    const BYTE* const litMax = litPtr + dctx->litBufSize;
-    const BYTE* const litEnd = litPtr + dctx->litSize;
-    int nbSeq;
-    const BYTE* dumps;
-    U32* DTableLL = dctx->LLTable;
-    U32* DTableML = dctx->MLTable;
-    U32* DTableOffb = dctx->OffTable;
-    BYTE* const base = (BYTE*) (dctx->base);
-
-    /* Build Decoding Tables */
-    errorCode = ZSTD_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,
-                                      DTableLL, DTableML, DTableOffb,
-                                      ip, iend-ip);
-    if (ZSTD_isError(errorCode)) return errorCode;
-    ip += errorCode;
-
-    /* Regen sequences */
-    {
-        seq_t sequence;
-        seqState_t seqState;
-
-        memset(&sequence, 0, sizeof(sequence));
-        seqState.dumps = dumps;
-        seqState.dumpsEnd = dumps + dumpsLength;
-        seqState.prevOffset = 1;
-        errorCode = BIT_initDStream(&(seqState.DStream), ip, iend-ip);
-        if (ERR_isError(errorCode)) return ERROR(corruption_detected);
-        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
-        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
-        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
-
-        for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (nbSeq>0) ; )
-        {
-            size_t oneSeqSize;
-            nbSeq--;
-            ZSTD_decodeSequence(&sequence, &seqState);
-            oneSeqSize = ZSTD_execSequence(op, sequence, &litPtr, litMax, base, oend);
-            if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
-            op += oneSeqSize;
-        }
-
-        /* check if reached exact end */
-        if ( !BIT_endOfDStream(&(seqState.DStream)) ) return ERROR(corruption_detected);   /* requested too much : data is corrupted */
-        if (nbSeq<0) return ERROR(corruption_detected);   /* requested too many sequences : data is corrupted */
-
-        /* last literal segment */
-        {
-            size_t lastLLSize = litEnd - litPtr;
-            if (litPtr > litEnd) return ERROR(corruption_detected);
-            if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);
-            if (op != litPtr) memmove(op, litPtr, lastLLSize);
-            op += lastLLSize;
-        }
-    }
-
-    return op-ostart;
-}
-
-
-static size_t ZSTD_decompressBlock(
-                            void* ctx,
-                            void* dst, size_t maxDstSize,
-                      const void* src, size_t srcSize)
-{
-    /* blockType == blockCompressed */
-    const BYTE* ip = (const BYTE*)src;
-
-    /* Decode literals sub-block */
-    size_t litCSize = ZSTD_decodeLiteralsBlock(ctx, src, srcSize);
-    if (ZSTD_isError(litCSize)) return litCSize;
-    ip += litCSize;
-    srcSize -= litCSize;
-
-    return ZSTD_decompressSequences(ctx, dst, maxDstSize, ip, srcSize);
-}
-
-
-static size_t ZSTD_decompressDCtx(void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    const BYTE* ip = (const BYTE*)src;
-    const BYTE* iend = ip + srcSize;
-    BYTE* const ostart = (BYTE* const)dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + maxDstSize;
-    size_t remainingSize = srcSize;
-    U32 magicNumber;
-    blockProperties_t blockProperties;
-
-    /* Frame Header */
-    if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
-    magicNumber = MEM_readLE32(src);
-    if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);
-    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize;
-
-    /* Loop on each block */
-    while (1)
-    {
-        size_t decodedSize=0;
-        size_t cBlockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties);
-        if (ZSTD_isError(cBlockSize)) return cBlockSize;
-
-        ip += ZSTD_blockHeaderSize;
-        remainingSize -= ZSTD_blockHeaderSize;
-        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);
-
-        switch(blockProperties.blockType)
-        {
-        case bt_compressed:
-            decodedSize = ZSTD_decompressBlock(ctx, op, oend-op, ip, cBlockSize);
-            break;
-        case bt_raw :
-            decodedSize = ZSTD_copyUncompressedBlock(op, oend-op, ip, cBlockSize);
-            break;
-        case bt_rle :
-            return ERROR(GENERIC);   /* not yet supported */
-            break;
-        case bt_end :
-            /* end of frame */
-            if (remainingSize) return ERROR(srcSize_wrong);
-            break;
-        default:
-            return ERROR(GENERIC);   /* impossible */
-        }
-        if (cBlockSize == 0) break;   /* bt_end */
-
-        if (ZSTD_isError(decodedSize)) return decodedSize;
-        op += decodedSize;
-        ip += cBlockSize;
-        remainingSize -= cBlockSize;
-    }
-
-    return op-ostart;
-}
-
-static size_t ZSTD_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    ZSTD_DCtx ctx;
-    ctx.base = dst;
-    return ZSTD_decompressDCtx(&ctx, dst, maxDstSize, src, srcSize);
-}
-
-
-/*******************************
-*  Streaming Decompression API
-*******************************/
-
-static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx)
-{
-    dctx->expected = ZSTD_frameHeaderSize;
-    dctx->phase = 0;
-    dctx->previousDstEnd = NULL;
-    dctx->base = NULL;
-    return 0;
-}
-
-static ZSTD_DCtx* ZSTD_createDCtx(void)
-{
-    ZSTD_DCtx* dctx = (ZSTD_DCtx*)malloc(sizeof(ZSTD_DCtx));
-    if (dctx==NULL) return NULL;
-    ZSTD_resetDCtx(dctx);
-    return dctx;
-}
-
-static size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
-{
-    free(dctx);
-    return 0;
-}
-
-static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx)
-{
-    return dctx->expected;
-}
-
-static size_t ZSTD_decompressContinue(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    /* Sanity check */
-    if (srcSize != ctx->expected) return ERROR(srcSize_wrong);
-    if (dst != ctx->previousDstEnd)  /* not contiguous */
-        ctx->base = dst;
-
-    /* Decompress : frame header */
-    if (ctx->phase == 0)
-    {
-        /* Check frame magic header */
-        U32 magicNumber = MEM_readLE32(src);
-        if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);
-        ctx->phase = 1;
-        ctx->expected = ZSTD_blockHeaderSize;
-        return 0;
-    }
-
-    /* Decompress : block header */
-    if (ctx->phase == 1)
-    {
-        blockProperties_t bp;
-        size_t blockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
-        if (ZSTD_isError(blockSize)) return blockSize;
-        if (bp.blockType == bt_end)
-        {
-            ctx->expected = 0;
-            ctx->phase = 0;
-        }
-        else
-        {
-            ctx->expected = blockSize;
-            ctx->bType = bp.blockType;
-            ctx->phase = 2;
-        }
-
-        return 0;
-    }
-
-    /* Decompress : block content */
-    {
-        size_t rSize;
-        switch(ctx->bType)
-        {
-        case bt_compressed:
-            rSize = ZSTD_decompressBlock(ctx, dst, maxDstSize, src, srcSize);
-            break;
-        case bt_raw :
-            rSize = ZSTD_copyUncompressedBlock(dst, maxDstSize, src, srcSize);
-            break;
-        case bt_rle :
-            return ERROR(GENERIC);   /* not yet handled */
-            break;
-        case bt_end :   /* should never happen (filtered at phase 1) */
-            rSize = 0;
-            break;
-        default:
-            return ERROR(GENERIC);
-        }
-        ctx->phase = 1;
-        ctx->expected = ZSTD_blockHeaderSize;
-        ctx->previousDstEnd = (void*)( ((char*)dst) + rSize);
-        return rSize;
-    }
-
-}
-
-
-/* wrapper layer */
-
-unsigned ZSTDv02_isError(size_t code)
-{
-	return ZSTD_isError(code);
-}
-
-size_t ZSTDv02_decompress( void* dst, size_t maxOriginalSize,
-                     const void* src, size_t compressedSize)
-{
-	return ZSTD_decompress(dst, maxOriginalSize, src, compressedSize);
-}
-
-ZSTDv02_Dctx* ZSTDv02_createDCtx(void)
-{
-	return (ZSTDv02_Dctx*)ZSTD_createDCtx();
-}
-
-size_t ZSTDv02_freeDCtx(ZSTDv02_Dctx* dctx)
-{
-	return ZSTD_freeDCtx((ZSTD_DCtx*)dctx);
-}
-
-size_t ZSTDv02_resetDCtx(ZSTDv02_Dctx* dctx)
-{
-	return ZSTD_resetDCtx((ZSTD_DCtx*)dctx);
-}
-
-size_t ZSTDv02_nextSrcSizeToDecompress(ZSTDv02_Dctx* dctx)
-{
-	return ZSTD_nextSrcSizeToDecompress((ZSTD_DCtx*)dctx);
-}
-
-size_t ZSTDv02_decompressContinue(ZSTDv02_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-	return ZSTD_decompressContinue((ZSTD_DCtx*)dctx, dst, maxDstSize, src, srcSize);
-}
+} 
+ 
+static 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; 
+        } 
+        { 
+            const short 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); 
+            } 
+        } 
+    } 
+    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; 
+} 
+ 
+ 
+/********************************************************* 
+*  Decompression (Byte symbols) 
+*********************************************************/ 
+static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue) 
+{ 
+    void* ptr = dt; 
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; 
+    FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */ 
+ 
+    DTableH->tableLog = 0; 
+    DTableH->fastMode = 0; 
+ 
+    cell->newState = 0; 
+    cell->symbol = symbolValue; 
+    cell->nbBits = 0; 
+ 
+    return 0; 
+} 
+ 
+ 
+static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits) 
+{ 
+    void* ptr = dt; 
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; 
+    FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */ 
+    const unsigned tableSize = 1 << nbBits; 
+    const unsigned tableMask = tableSize - 1; 
+    const unsigned maxSymbolValue = tableMask; 
+    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<=maxSymbolValue; 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; 
+    size_t errorCode; 
+ 
+    /* Init */ 
+    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 ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) ) 
+            break; 
+ 
+        *op++ = FSE_GETSYMBOL(&state1); 
+ 
+        if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) ) 
+            break; 
+ 
+        *op++ = FSE_GETSYMBOL(&state2); 
+    } 
+ 
+    /* end ? */ 
+    if (BIT_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2)) 
+        return op-ostart; 
+ 
+    if (op==omax) return ERROR(dstSize_tooSmall);   /* dst buffer is full, but cSrc unfinished */ 
+ 
+    return ERROR(corruption_detected); 
+} 
+ 
+ 
+static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize, 
+                            const void* cSrc, size_t cSrcSize, 
+                            const FSE_DTable* dt) 
+{ 
+    FSE_DTableHeader DTableH; 
+    memcpy(&DTableH, dt, sizeof(DTableH)); 
+ 
+    /* select fast mode (static) */ 
+    if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1); 
+    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0); 
+} 
+ 
+ 
+static 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; 
+    size_t errorCode; 
+ 
+    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */ 
+ 
+    /* normal FSE decoding mode */ 
+    errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize); 
+    if (FSE_isError(errorCode)) return errorCode; 
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */ 
+    ip += errorCode; 
+    cSrcSize -= errorCode; 
+ 
+    errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog); 
+    if (FSE_isError(errorCode)) return errorCode; 
+ 
+    /* always return, even if it is an error code */ 
+    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt); 
+} 
+ 
+ 
+ 
+#endif   /* FSE_COMMONDEFS_ONLY */ 
+/* ****************************************************************** 
+   Huff0 : Huffman coder, part of New Generation Entropy library 
+   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+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+ 
+/**************************************************************** 
+*  Compiler specifics 
+****************************************************************/ 
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+/* inline is defined */ 
+#elif defined(_MSC_VER) 
+#  define inline __inline 
+#else 
+#  define inline /* disable inline */ 
+#endif 
+ 
+ 
+#ifdef _MSC_VER    /* Visual Studio */ 
+#  define FORCE_INLINE static __forceinline 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#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) */ 
+ 
+/**************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */ 
+ 
+ 
+/****************************************** 
+*  Helper functions 
+******************************************/ 
+static unsigned HUF_isError(size_t code) { return ERR_isError(code); } 
+ 
+#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 
+ 
+ 
+ 
+/********************************************************* 
+*  Huff0 : Huffman block decompression 
+*********************************************************/ 
+typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2;   /* single-symbol decoding */ 
+ 
+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4;  /* double-symbols decoding */ 
+ 
+typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t; 
+ 
+/*! HUF_readStats 
+    Read compact Huffman tree, saved by HUF_writeCTable 
+    @huffWeight : destination buffer 
+    @return : size read from `src` 
+*/ 
+static size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats, 
+                            U32* nbSymbolsPtr, U32* tableLogPtr, 
+                            const void* src, size_t srcSize) 
+{ 
+    U32 weightTotal; 
+    U32 tableLog; 
+    const BYTE* ip = (const BYTE*) src; 
+    size_t iSize = ip[0]; 
+    size_t oSize; 
+    U32 n; 
+ 
+    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    if (iSize >= 128)  /* special header */ 
+    { 
+        if (iSize >= (242))   /* RLE */ 
+        { 
+            static int 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; 
+            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; 
+    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) */ 
+    tableLog = BIT_highbit32(weightTotal) + 1; 
+    if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected); 
+    { 
+        U32 total = 1 << tableLog; 
+        U32 rest = total - weightTotal; 
+        U32 verif = 1 << BIT_highbit32(rest); 
+        U32 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); 
+    *tableLogPtr = tableLog; 
+    return iSize+1; 
+} 
+ 
+ 
+/**************************/ 
+/* single-symbol decoding */ 
+/**************************/ 
+ 
+static size_t HUF_readDTableX2 (U16* DTable, const void* src, size_t srcSize) 
+{ 
+    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1]; 
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];   /* large enough for values from 0 to 16 */ 
+    U32 tableLog = 0; 
+    const BYTE* ip = (const BYTE*) src; 
+    size_t iSize = ip[0]; 
+    U32 nbSymbols = 0; 
+    U32 n; 
+    U32 nextRankStart; 
+    void* ptr = DTable+1; 
+    HUF_DEltX2* const dt = (HUF_DEltX2*)ptr; 
+ 
+    HUF_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */ 
+    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    iSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize); 
+    if (HUF_isError(iSize)) return iSize; 
+ 
+    /* check result */ 
+    if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge);   /* DTable is too small */ 
+    DTable[0] = (U16)tableLog;   /* maybe should separate sizeof DTable, as allocated, from used size of DTable, in case of DTable re-use */ 
+ 
+    /* Prepare ranks */ 
+    nextRankStart = 0; 
+    for (n=1; n<=tableLog; n++) 
+    { 
+        U32 current = nextRankStart; 
+        nextRankStart += (rankVal[n] << (n-1)); 
+        rankVal[n] = current; 
+    } 
+ 
+    /* fill DTable */ 
+    for (n=0; n<nbSymbols; n++) 
+    { 
+        const U32 w = huffWeight[n]; 
+        const U32 length = (1 << w) >> 1; 
+        U32 i; 
+        HUF_DEltX2 D; 
+        D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w); 
+        for (i = rankVal[w]; i < rankVal[w] + length; i++) 
+            dt[i] = D; 
+        rankVal[w] += length; 
+    } 
+ 
+    return iSize; 
+} 
+ 
+static BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog) 
+{ 
+        const size_t val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */ 
+        const BYTE c = dt[val].byte; 
+        BIT_skipBits(Dstream, dt[val].nbBits); 
+        return c; 
+} 
+ 
+#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \ 
+    *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog) 
+ 
+#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \ 
+    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \ 
+        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) 
+ 
+#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \ 
+    if (MEM_64bits()) \ 
+        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) 
+ 
+static inline size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog) 
+{ 
+    BYTE* const pStart = p; 
+ 
+    /* up to 4 symbols at a time */ 
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4)) 
+    { 
+        HUF_DECODE_SYMBOLX2_2(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX2_1(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX2_2(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr); 
+    } 
+ 
+    /* closer to the end */ 
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd)) 
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr); 
+ 
+    /* no more data to retrieve from bitstream, hence no need to reload */ 
+    while (p < pEnd) 
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr); 
+ 
+    return pEnd-pStart; 
+} 
+ 
+ 
+static size_t HUF_decompress4X2_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const U16* DTable) 
+{ 
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */ 
+ 
+    { 
+        const BYTE* const istart = (const BYTE*) cSrc; 
+        BYTE* const ostart = (BYTE*) dst; 
+        BYTE* const oend = ostart + dstSize; 
+ 
+        const void* ptr = DTable; 
+        const HUF_DEltX2* const dt = ((const HUF_DEltX2*)ptr) +1; 
+        const U32 dtLog = DTable[0]; 
+        size_t errorCode; 
+ 
+        /* Init */ 
+        BIT_DStream_t bitD1; 
+        BIT_DStream_t bitD2; 
+        BIT_DStream_t bitD3; 
+        BIT_DStream_t bitD4; 
+        const size_t length1 = MEM_readLE16(istart); 
+        const size_t length2 = MEM_readLE16(istart+2); 
+        const size_t length3 = MEM_readLE16(istart+4); 
+        size_t length4; 
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */ 
+        const BYTE* const istart2 = istart1 + length1; 
+        const BYTE* const istart3 = istart2 + length2; 
+        const BYTE* const istart4 = istart3 + length3; 
+        const size_t segmentSize = (dstSize+3) / 4; 
+        BYTE* const opStart2 = ostart + segmentSize; 
+        BYTE* const opStart3 = opStart2 + segmentSize; 
+        BYTE* const opStart4 = opStart3 + segmentSize; 
+        BYTE* op1 = ostart; 
+        BYTE* op2 = opStart2; 
+        BYTE* op3 = opStart3; 
+        BYTE* op4 = opStart4; 
+        U32 endSignal; 
+ 
+        length4 = cSrcSize - (length1 + length2 + length3 + 6); 
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */ 
+        errorCode = BIT_initDStream(&bitD1, istart1, length1); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD2, istart2, length2); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD3, istart3, length3); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD4, istart4, length4); 
+        if (HUF_isError(errorCode)) return errorCode; 
+ 
+        /* 16-32 symbols per loop (4-8 symbols per stream) */ 
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); 
+        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; ) 
+        { 
+            HUF_DECODE_SYMBOLX2_2(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX2_2(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX2_2(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX2_2(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX2_1(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX2_1(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX2_1(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX2_1(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX2_2(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX2_2(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX2_2(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX2_2(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX2_0(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX2_0(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX2_0(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX2_0(op4, &bitD4); 
+ 
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); 
+        } 
+ 
+        /* check corruption */ 
+        if (op1 > opStart2) return ERROR(corruption_detected); 
+        if (op2 > opStart3) return ERROR(corruption_detected); 
+        if (op3 > opStart4) return ERROR(corruption_detected); 
+        /* note : op4 supposed already verified within main loop */ 
+ 
+        /* finish bitStreams one by one */ 
+        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog); 
+        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog); 
+        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog); 
+        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog); 
+ 
+        /* check */ 
+        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4); 
+        if (!endSignal) return ERROR(corruption_detected); 
+ 
+        /* decoded size */ 
+        return dstSize; 
+    } 
+} 
+ 
+ 
+static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+    size_t errorCode; 
+ 
+    errorCode = HUF_readDTableX2 (DTable, cSrc, cSrcSize); 
+    if (HUF_isError(errorCode)) return errorCode; 
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += errorCode; 
+    cSrcSize -= errorCode; 
+ 
+    return HUF_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable); 
+} 
+ 
+ 
+/***************************/ 
+/* double-symbols decoding */ 
+/***************************/ 
+ 
+static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed, 
+                           const U32* rankValOrigin, const int minWeight, 
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize, 
+                           U32 nbBitsBaseline, U16 baseSeq) 
+{ 
+    HUF_DEltX4 DElt; 
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1]; 
+    U32 s; 
+ 
+    /* get pre-calculated rankVal */ 
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal)); 
+ 
+    /* fill skipped values */ 
+    if (minWeight>1) 
+    { 
+        U32 i, skipSize = rankVal[minWeight]; 
+        MEM_writeLE16(&(DElt.sequence), baseSeq); 
+        DElt.nbBits   = (BYTE)(consumed); 
+        DElt.length   = 1; 
+        for (i = 0; i < skipSize; i++) 
+            DTable[i] = DElt; 
+    } 
+ 
+    /* fill DTable */ 
+    for (s=0; s<sortedListSize; s++)   /* note : sortedSymbols already skipped */ 
+    { 
+        const U32 symbol = sortedSymbols[s].symbol; 
+        const U32 weight = sortedSymbols[s].weight; 
+        const U32 nbBits = nbBitsBaseline - weight; 
+        const U32 length = 1 << (sizeLog-nbBits); 
+        const U32 start = rankVal[weight]; 
+        U32 i = start; 
+        const U32 end = start + length; 
+ 
+        MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8))); 
+        DElt.nbBits = (BYTE)(nbBits + consumed); 
+        DElt.length = 2; 
+        do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */ 
+ 
+        rankVal[weight] += length; 
+    } 
+} 
+ 
+typedef U32 rankVal_t[HUF_ABSOLUTEMAX_TABLELOG][HUF_ABSOLUTEMAX_TABLELOG + 1]; 
+ 
+static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog, 
+                           const sortedSymbol_t* sortedList, const U32 sortedListSize, 
+                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight, 
+                           const U32 nbBitsBaseline) 
+{ 
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1]; 
+    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */ 
+    const U32 minBits  = nbBitsBaseline - maxWeight; 
+    U32 s; 
+ 
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal)); 
+ 
+    /* fill DTable */ 
+    for (s=0; s<sortedListSize; s++) 
+    { 
+        const U16 symbol = sortedList[s].symbol; 
+        const U32 weight = sortedList[s].weight; 
+        const U32 nbBits = nbBitsBaseline - weight; 
+        const U32 start = rankVal[weight]; 
+        const U32 length = 1 << (targetLog-nbBits); 
+ 
+        if (targetLog-nbBits >= minBits)   /* enough room for a second symbol */ 
+        { 
+            U32 sortedRank; 
+            int minWeight = nbBits + scaleLog; 
+            if (minWeight < 1) minWeight = 1; 
+            sortedRank = rankStart[minWeight]; 
+            HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits, 
+                           rankValOrigin[nbBits], minWeight, 
+                           sortedList+sortedRank, sortedListSize-sortedRank, 
+                           nbBitsBaseline, symbol); 
+        } 
+        else 
+        { 
+            U32 i; 
+            const U32 end = start + length; 
+            HUF_DEltX4 DElt; 
+ 
+            MEM_writeLE16(&(DElt.sequence), symbol); 
+            DElt.nbBits   = (BYTE)(nbBits); 
+            DElt.length   = 1; 
+            for (i = start; i < end; i++) 
+                DTable[i] = DElt; 
+        } 
+        rankVal[weight] += length; 
+    } 
+} 
+ 
+static size_t HUF_readDTableX4 (U32* DTable, const void* src, size_t srcSize) 
+{ 
+    BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1]; 
+    sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1]; 
+    U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 }; 
+    U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 }; 
+    U32* const rankStart = rankStart0+1; 
+    rankVal_t rankVal; 
+    U32 tableLog, maxW, sizeOfSort, nbSymbols; 
+    const U32 memLog = DTable[0]; 
+    const BYTE* ip = (const BYTE*) src; 
+    size_t iSize = ip[0]; 
+    void* ptr = DTable; 
+    HUF_DEltX4* const dt = ((HUF_DEltX4*)ptr) + 1; 
+ 
+    HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */ 
+    if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge); 
+    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize); 
+    if (HUF_isError(iSize)) return iSize; 
+ 
+    /* check result */ 
+    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */ 
+ 
+    /* find maxWeight */ 
+    for (maxW = tableLog; rankStats[maxW]==0; maxW--) 
+        {if (!maxW) return ERROR(GENERIC); }  /* necessarily finds a solution before maxW==0 */ 
+ 
+    /* Get start index of each weight */ 
+    { 
+        U32 w, nextRankStart = 0; 
+        for (w=1; w<=maxW; w++) 
+        { 
+            U32 current = nextRankStart; 
+            nextRankStart += rankStats[w]; 
+            rankStart[w] = current; 
+        } 
+        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/ 
+        sizeOfSort = nextRankStart; 
+    } 
+ 
+    /* sort symbols by weight */ 
+    { 
+        U32 s; 
+        for (s=0; s<nbSymbols; s++) 
+        { 
+            U32 w = weightList[s]; 
+            U32 r = rankStart[w]++; 
+            sortedSymbol[r].symbol = (BYTE)s; 
+            sortedSymbol[r].weight = (BYTE)w; 
+        } 
+        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */ 
+    } 
+ 
+	/* Build rankVal */ 
+    { 
+        const U32 minBits = tableLog+1 - maxW; 
+        U32 nextRankVal = 0; 
+        U32 w, consumed; 
+        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */ 
+        U32* rankVal0 = rankVal[0]; 
+        for (w=1; w<=maxW; w++) 
+        { 
+            U32 current = nextRankVal; 
+            nextRankVal += rankStats[w] << (w+rescale); 
+            rankVal0[w] = current; 
+        } 
+        for (consumed = minBits; consumed <= memLog - minBits; consumed++) 
+        { 
+            U32* rankValPtr = rankVal[consumed]; 
+            for (w = 1; w <= maxW; w++) 
+            { 
+                rankValPtr[w] = rankVal0[w] >> consumed; 
+            } 
+        } 
+    } 
+ 
+    HUF_fillDTableX4(dt, memLog, 
+                   sortedSymbol, sizeOfSort, 
+                   rankStart0, rankVal, maxW, 
+                   tableLog+1); 
+ 
+    return iSize; 
+} 
+ 
+ 
+static U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog) 
+{ 
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    memcpy(op, dt+val, 2); 
+    BIT_skipBits(DStream, dt[val].nbBits); 
+    return dt[val].length; 
+} 
+ 
+static U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog) 
+{ 
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    memcpy(op, dt+val, 1); 
+    if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits); 
+    else 
+    { 
+        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) 
+        { 
+            BIT_skipBits(DStream, dt[val].nbBits); 
+            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8)) 
+                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */ 
+        } 
+    } 
+    return 1; 
+} 
+ 
+ 
+#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \ 
+    ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+#define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \ 
+    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \ 
+        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+#define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \ 
+    if (MEM_64bits()) \ 
+        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+static inline size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog) 
+{ 
+    BYTE* const pStart = p; 
+ 
+    /* up to 8 symbols at a time */ 
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd-7)) 
+    { 
+        HUF_DECODE_SYMBOLX4_2(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX4_1(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX4_2(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr); 
+    } 
+ 
+    /* closer to the end */ 
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-2)) 
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr); 
+ 
+    while (p <= pEnd-2) 
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */ 
+ 
+    if (p < pEnd) 
+        p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog); 
+ 
+    return p-pStart; 
+} 
+ 
+ 
+ 
+static size_t HUF_decompress4X4_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const U32* DTable) 
+{ 
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */ 
+ 
+    { 
+        const BYTE* const istart = (const BYTE*) cSrc; 
+        BYTE* const ostart = (BYTE*) dst; 
+        BYTE* const oend = ostart + dstSize; 
+ 
+        const void* ptr = DTable; 
+        const HUF_DEltX4* const dt = ((const HUF_DEltX4*)ptr) +1; 
+        const U32 dtLog = DTable[0]; 
+        size_t errorCode; 
+ 
+        /* Init */ 
+        BIT_DStream_t bitD1; 
+        BIT_DStream_t bitD2; 
+        BIT_DStream_t bitD3; 
+        BIT_DStream_t bitD4; 
+        const size_t length1 = MEM_readLE16(istart); 
+        const size_t length2 = MEM_readLE16(istart+2); 
+        const size_t length3 = MEM_readLE16(istart+4); 
+        size_t length4; 
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */ 
+        const BYTE* const istart2 = istart1 + length1; 
+        const BYTE* const istart3 = istart2 + length2; 
+        const BYTE* const istart4 = istart3 + length3; 
+        const size_t segmentSize = (dstSize+3) / 4; 
+        BYTE* const opStart2 = ostart + segmentSize; 
+        BYTE* const opStart3 = opStart2 + segmentSize; 
+        BYTE* const opStart4 = opStart3 + segmentSize; 
+        BYTE* op1 = ostart; 
+        BYTE* op2 = opStart2; 
+        BYTE* op3 = opStart3; 
+        BYTE* op4 = opStart4; 
+        U32 endSignal; 
+ 
+        length4 = cSrcSize - (length1 + length2 + length3 + 6); 
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */ 
+        errorCode = BIT_initDStream(&bitD1, istart1, length1); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD2, istart2, length2); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD3, istart3, length3); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD4, istart4, length4); 
+        if (HUF_isError(errorCode)) return errorCode; 
+ 
+        /* 16-32 symbols per loop (4-8 symbols per stream) */ 
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); 
+        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; ) 
+        { 
+            HUF_DECODE_SYMBOLX4_2(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX4_2(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX4_2(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX4_2(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX4_1(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX4_1(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX4_1(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX4_1(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX4_2(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX4_2(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX4_2(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX4_2(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX4_0(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX4_0(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX4_0(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX4_0(op4, &bitD4); 
+ 
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); 
+        } 
+ 
+        /* check corruption */ 
+        if (op1 > opStart2) return ERROR(corruption_detected); 
+        if (op2 > opStart3) return ERROR(corruption_detected); 
+        if (op3 > opStart4) return ERROR(corruption_detected); 
+        /* note : op4 supposed already verified within main loop */ 
+ 
+        /* finish bitStreams one by one */ 
+        HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog); 
+        HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog); 
+        HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog); 
+        HUF_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog); 
+ 
+        /* check */ 
+        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4); 
+        if (!endSignal) return ERROR(corruption_detected); 
+ 
+        /* decoded size */ 
+        return dstSize; 
+    } 
+} 
+ 
+ 
+static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
+    size_t hSize = HUF_readDTableX4 (DTable, cSrc, cSrcSize); 
+    if (HUF_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; 
+    cSrcSize -= hSize; 
+ 
+    return HUF_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable); 
+} 
+ 
+ 
+/**********************************/ 
+/* quad-symbol decoding           */ 
+/**********************************/ 
+typedef struct { BYTE nbBits; BYTE nbBytes; } HUF_DDescX6; 
+typedef union { BYTE byte[4]; U32 sequence; } HUF_DSeqX6; 
+ 
+/* recursive, up to level 3; may benefit from <template>-like strategy to nest each level inline */ 
+static void HUF_fillDTableX6LevelN(HUF_DDescX6* DDescription, HUF_DSeqX6* DSequence, int sizeLog, 
+                           const rankVal_t rankValOrigin, const U32 consumed, const int minWeight, const U32 maxWeight, 
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize, const U32* rankStart, 
+                           const U32 nbBitsBaseline, HUF_DSeqX6 baseSeq, HUF_DDescX6 DDesc) 
+{ 
+    const int scaleLog = nbBitsBaseline - sizeLog;   /* note : targetLog >= (nbBitsBaseline-1), hence scaleLog <= 1 */ 
+    const int minBits  = nbBitsBaseline - maxWeight; 
+    const U32 level = DDesc.nbBytes; 
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1]; 
+    U32 symbolStartPos, s; 
+ 
+    /* local rankVal, will be modified */ 
+    memcpy(rankVal, rankValOrigin[consumed], sizeof(rankVal)); 
+ 
+    /* fill skipped values */ 
+    if (minWeight>1) 
+    { 
+        U32 i; 
+        const U32 skipSize = rankVal[minWeight]; 
+        for (i = 0; i < skipSize; i++) 
+        { 
+            DSequence[i] = baseSeq; 
+            DDescription[i] = DDesc; 
+        } 
+    } 
+ 
+    /* fill DTable */ 
+    DDesc.nbBytes++; 
+    symbolStartPos = rankStart[minWeight]; 
+    for (s=symbolStartPos; s<sortedListSize; s++) 
+    { 
+        const BYTE symbol = sortedSymbols[s].symbol; 
+        const U32  weight = sortedSymbols[s].weight;   /* >= 1 (sorted) */ 
+        const int  nbBits = nbBitsBaseline - weight;   /* >= 1 (by construction) */ 
+        const int  totalBits = consumed+nbBits; 
+        const U32  start  = rankVal[weight]; 
+        const U32  length = 1 << (sizeLog-nbBits); 
+        baseSeq.byte[level] = symbol; 
+        DDesc.nbBits = (BYTE)totalBits; 
+ 
+        if ((level<3) && (sizeLog-totalBits >= minBits))   /* enough room for another symbol */ 
+        { 
+            int nextMinWeight = totalBits + scaleLog; 
+            if (nextMinWeight < 1) nextMinWeight = 1; 
+            HUF_fillDTableX6LevelN(DDescription+start, DSequence+start, sizeLog-nbBits, 
+                           rankValOrigin, totalBits, nextMinWeight, maxWeight, 
+                           sortedSymbols, sortedListSize, rankStart, 
+                           nbBitsBaseline, baseSeq, DDesc);   /* recursive (max : level 3) */ 
+        } 
+        else 
+        { 
+            U32 i; 
+            const U32 end = start + length; 
+            for (i = start; i < end; i++) 
+            { 
+                DDescription[i] = DDesc; 
+                DSequence[i] = baseSeq; 
+            } 
+        } 
+        rankVal[weight] += length; 
+    } 
+} 
+ 
+ 
+/* note : same preparation as X4 */ 
+static size_t HUF_readDTableX6 (U32* DTable, const void* src, size_t srcSize) 
+{ 
+    BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1]; 
+    sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1]; 
+    U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 }; 
+    U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 }; 
+    U32* const rankStart = rankStart0+1; 
+    U32 tableLog, maxW, sizeOfSort, nbSymbols; 
+    rankVal_t rankVal; 
+    const U32 memLog = DTable[0]; 
+    const BYTE* ip = (const BYTE*) src; 
+    size_t iSize = ip[0]; 
+ 
+    if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge); 
+    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize); 
+    if (HUF_isError(iSize)) return iSize; 
+ 
+    /* check result */ 
+    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable is too small */ 
+ 
+    /* find maxWeight */ 
+    for (maxW = tableLog; rankStats[maxW]==0; maxW--) 
+        { if (!maxW) return ERROR(GENERIC); }  /* necessarily finds a solution before maxW==0 */ 
+ 
+ 
+    /* Get start index of each weight */ 
+    { 
+        U32 w, nextRankStart = 0; 
+        for (w=1; w<=maxW; w++) 
+        { 
+            U32 current = nextRankStart; 
+            nextRankStart += rankStats[w]; 
+            rankStart[w] = current; 
+        } 
+        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/ 
+        sizeOfSort = nextRankStart; 
+    } 
+ 
+    /* sort symbols by weight */ 
+    { 
+        U32 s; 
+        for (s=0; s<nbSymbols; s++) 
+        { 
+            U32 w = weightList[s]; 
+            U32 r = rankStart[w]++; 
+            sortedSymbol[r].symbol = (BYTE)s; 
+            sortedSymbol[r].weight = (BYTE)w; 
+        } 
+        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */ 
+    } 
+ 
+	/* Build rankVal */ 
+    { 
+        const U32 minBits = tableLog+1 - maxW; 
+        U32 nextRankVal = 0; 
+        U32 w, consumed; 
+        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */ 
+        U32* rankVal0 = rankVal[0]; 
+        for (w=1; w<=maxW; w++) 
+        { 
+            U32 current = nextRankVal; 
+            nextRankVal += rankStats[w] << (w+rescale); 
+            rankVal0[w] = current; 
+        } 
+        for (consumed = minBits; consumed <= memLog - minBits; consumed++) 
+        { 
+            U32* rankValPtr = rankVal[consumed]; 
+            for (w = 1; w <= maxW; w++) 
+            { 
+                rankValPtr[w] = rankVal0[w] >> consumed; 
+            } 
+        } 
+    } 
+ 
+ 
+    /* fill tables */ 
+    { 
+        void* ptr = DTable+1; 
+        HUF_DDescX6* DDescription = (HUF_DDescX6*)(ptr); 
+        void* dSeqStart = DTable + 1 + ((size_t)1<<(memLog-1)); 
+        HUF_DSeqX6* DSequence = (HUF_DSeqX6*)(dSeqStart); 
+        HUF_DSeqX6 DSeq; 
+        HUF_DDescX6 DDesc; 
+        DSeq.sequence = 0; 
+        DDesc.nbBits = 0; 
+        DDesc.nbBytes = 0; 
+        HUF_fillDTableX6LevelN(DDescription, DSequence, memLog, 
+                       (const U32 (*)[HUF_ABSOLUTEMAX_TABLELOG + 1])rankVal, 0, 1, maxW, 
+                       sortedSymbol, sizeOfSort, rankStart0, 
+                       tableLog+1, DSeq, DDesc); 
+    } 
+ 
+    return iSize; 
+} 
+ 
+ 
+static U32 HUF_decodeSymbolX6(void* op, BIT_DStream_t* DStream, const HUF_DDescX6* dd, const HUF_DSeqX6* ds, const U32 dtLog) 
+{ 
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    memcpy(op, ds+val, sizeof(HUF_DSeqX6)); 
+    BIT_skipBits(DStream, dd[val].nbBits); 
+    return dd[val].nbBytes; 
+} 
+ 
+static U32 HUF_decodeLastSymbolsX6(void* op, const U32 maxL, BIT_DStream_t* DStream, 
+                                  const HUF_DDescX6* dd, const HUF_DSeqX6* ds, const U32 dtLog) 
+{ 
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    U32 length = dd[val].nbBytes; 
+    if (length <= maxL) 
+    { 
+        memcpy(op, ds+val, length); 
+        BIT_skipBits(DStream, dd[val].nbBits); 
+        return length; 
+    } 
+    memcpy(op, ds+val, maxL); 
+    if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) 
+    { 
+        BIT_skipBits(DStream, dd[val].nbBits); 
+        if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8)) 
+            DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */ 
+    } 
+    return maxL; 
+} 
+ 
+ 
+#define HUF_DECODE_SYMBOLX6_0(ptr, DStreamPtr) \ 
+    ptr += HUF_decodeSymbolX6(ptr, DStreamPtr, dd, ds, dtLog) 
+ 
+#define HUF_DECODE_SYMBOLX6_1(ptr, DStreamPtr) \ 
+    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \ 
+        HUF_DECODE_SYMBOLX6_0(ptr, DStreamPtr) 
+ 
+#define HUF_DECODE_SYMBOLX6_2(ptr, DStreamPtr) \ 
+    if (MEM_64bits()) \ 
+        HUF_DECODE_SYMBOLX6_0(ptr, DStreamPtr) 
+ 
+static inline size_t HUF_decodeStreamX6(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const U32* DTable, const U32 dtLog) 
+{ 
+    const void* ddPtr = DTable+1; 
+    const HUF_DDescX6* dd = (const HUF_DDescX6*)(ddPtr); 
+    const void* dsPtr = DTable + 1 + ((size_t)1<<(dtLog-1)); 
+    const HUF_DSeqX6* ds = (const HUF_DSeqX6*)(dsPtr); 
+    BYTE* const pStart = p; 
+ 
+    /* up to 16 symbols at a time */ 
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-16)) 
+    { 
+        HUF_DECODE_SYMBOLX6_2(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX6_1(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX6_2(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX6_0(p, bitDPtr); 
+    } 
+ 
+    /* closer to the end, up to 4 symbols at a time */ 
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4)) 
+        HUF_DECODE_SYMBOLX6_0(p, bitDPtr); 
+ 
+    while (p <= pEnd-4) 
+        HUF_DECODE_SYMBOLX6_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */ 
+ 
+    while (p < pEnd) 
+        p += HUF_decodeLastSymbolsX6(p, (U32)(pEnd-p), bitDPtr, dd, ds, dtLog); 
+ 
+    return p-pStart; 
+} 
+ 
+ 
+ 
+static size_t HUF_decompress4X6_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const U32* DTable) 
+{ 
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */ 
+ 
+    { 
+        const BYTE* const istart = (const BYTE*) cSrc; 
+        BYTE* const ostart = (BYTE*) dst; 
+        BYTE* const oend = ostart + dstSize; 
+ 
+        const U32 dtLog = DTable[0]; 
+        const void* ddPtr = DTable+1; 
+        const HUF_DDescX6* dd = (const HUF_DDescX6*)(ddPtr); 
+        const void* dsPtr = DTable + 1 + ((size_t)1<<(dtLog-1)); 
+        const HUF_DSeqX6* ds = (const HUF_DSeqX6*)(dsPtr); 
+        size_t errorCode; 
+ 
+        /* Init */ 
+        BIT_DStream_t bitD1; 
+        BIT_DStream_t bitD2; 
+        BIT_DStream_t bitD3; 
+        BIT_DStream_t bitD4; 
+        const size_t length1 = MEM_readLE16(istart); 
+        const size_t length2 = MEM_readLE16(istart+2); 
+        const size_t length3 = MEM_readLE16(istart+4); 
+        size_t length4; 
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */ 
+        const BYTE* const istart2 = istart1 + length1; 
+        const BYTE* const istart3 = istart2 + length2; 
+        const BYTE* const istart4 = istart3 + length3; 
+        const size_t segmentSize = (dstSize+3) / 4; 
+        BYTE* const opStart2 = ostart + segmentSize; 
+        BYTE* const opStart3 = opStart2 + segmentSize; 
+        BYTE* const opStart4 = opStart3 + segmentSize; 
+        BYTE* op1 = ostart; 
+        BYTE* op2 = opStart2; 
+        BYTE* op3 = opStart3; 
+        BYTE* op4 = opStart4; 
+        U32 endSignal; 
+ 
+        length4 = cSrcSize - (length1 + length2 + length3 + 6); 
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */ 
+        errorCode = BIT_initDStream(&bitD1, istart1, length1); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD2, istart2, length2); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD3, istart3, length3); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD4, istart4, length4); 
+        if (HUF_isError(errorCode)) return errorCode; 
+ 
+        /* 16-64 symbols per loop (4-16 symbols per stream) */ 
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); 
+        for ( ; (op3 <= opStart4) && (endSignal==BIT_DStream_unfinished) && (op4<=(oend-16)) ; ) 
+        { 
+            HUF_DECODE_SYMBOLX6_2(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX6_2(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX6_2(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX6_2(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX6_1(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX6_1(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX6_1(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX6_1(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX6_2(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX6_2(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX6_2(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX6_2(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX6_0(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX6_0(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX6_0(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX6_0(op4, &bitD4); 
+ 
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); 
+        } 
+ 
+        /* check corruption */ 
+        if (op1 > opStart2) return ERROR(corruption_detected); 
+        if (op2 > opStart3) return ERROR(corruption_detected); 
+        if (op3 > opStart4) return ERROR(corruption_detected); 
+        /* note : op4 supposed already verified within main loop */ 
+ 
+        /* finish bitStreams one by one */ 
+        HUF_decodeStreamX6(op1, &bitD1, opStart2, DTable, dtLog); 
+        HUF_decodeStreamX6(op2, &bitD2, opStart3, DTable, dtLog); 
+        HUF_decodeStreamX6(op3, &bitD3, opStart4, DTable, dtLog); 
+        HUF_decodeStreamX6(op4, &bitD4, oend,     DTable, dtLog); 
+ 
+        /* check */ 
+        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4); 
+        if (!endSignal) return ERROR(corruption_detected); 
+ 
+        /* decoded size */ 
+        return dstSize; 
+    } 
+} 
+ 
+ 
+static size_t HUF_decompress4X6 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUF_CREATE_STATIC_DTABLEX6(DTable, HUF_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
+    size_t hSize = HUF_readDTableX6 (DTable, cSrc, cSrcSize); 
+    if (HUF_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; 
+    cSrcSize -= hSize; 
+ 
+    return HUF_decompress4X6_usingDTable (dst, dstSize, ip, cSrcSize, DTable); 
+} 
+ 
+ 
+/**********************************/ 
+/* Generic decompression selector */ 
+/**********************************/ 
+ 
+typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t; 
+static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] = 
+{ 
+    /* single, double, quad */ 
+    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */ 
+    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */ 
+    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */ 
+    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */ 
+    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */ 
+    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */ 
+    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */ 
+    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */ 
+    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */ 
+    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */ 
+    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */ 
+    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */ 
+    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */ 
+    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */ 
+    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */ 
+    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */ 
+}; 
+ 
+typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); 
+ 
+static size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    static const decompressionAlgo decompress[3] = { HUF_decompress4X2, HUF_decompress4X4, HUF_decompress4X6 }; 
+    /* estimate decompression time */ 
+    U32 Q; 
+    const U32 D256 = (U32)(dstSize >> 8); 
+    U32 Dtime[3]; 
+    U32 algoNb = 0; 
+    int n; 
+ 
+    /* validation checks */ 
+    if (dstSize == 0) return ERROR(dstSize_tooSmall); 
+    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */ 
+    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */ 
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */ 
+ 
+    /* decoder timing evaluation */ 
+    Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */ 
+    for (n=0; n<3; n++) 
+        Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256); 
+ 
+    Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */ 
+ 
+    if (Dtime[1] < Dtime[0]) algoNb = 1; 
+    if (Dtime[2] < Dtime[algoNb]) algoNb = 2; 
+ 
+    return decompress[algoNb](dst, dstSize, cSrc, cSrcSize); 
+ 
+    //return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize);   /* multi-streams single-symbol decoding */ 
+    //return HUF_decompress4X4(dst, dstSize, cSrc, cSrcSize);   /* multi-streams double-symbols decoding */ 
+    //return HUF_decompress4X6(dst, dstSize, cSrc, cSrcSize);   /* multi-streams quad-symbols decoding */ 
+} 
+/* 
+    zstd - standard compression library 
+    Copyright (C) 2014-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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+ 
+/* *************************************************************** 
+*  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 
+*/ 
+#define ZSTD_MEMORY_USAGE 17 
+ 
+/*! 
+ * HEAPMODE : 
+ * Select how default compression functions will allocate memory for their hash table, 
+ * in memory stack (0, fastest), or in memory heap (1, requires malloc()) 
+ * Note that compression context is fairly large, as a consequence heap memory is recommended. 
+ */ 
+#ifndef ZSTD_HEAPMODE 
+#  define ZSTD_HEAPMODE 1 
+#endif /* ZSTD_HEAPMODE */ 
+ 
+/*! 
+*  LEGACY_SUPPORT : 
+*  decompressor can decode older formats (starting from Zstd 0.1+) 
+*/ 
+#ifndef ZSTD_LEGACY_SUPPORT 
+#  define ZSTD_LEGACY_SUPPORT 1 
+#endif 
+ 
+ 
+/* ******************************************************* 
+*  Includes 
+*********************************************************/ 
+#include <stdlib.h>      /* calloc */ 
+#include <string.h>      /* memcpy, memmove */ 
+#include <stdio.h>       /* debug : printf */ 
+ 
+ 
+/* ******************************************************* 
+*  Compiler specifics 
+*********************************************************/ 
+#ifdef __AVX2__ 
+#  include <immintrin.h>   /* AVX2 intrinsics */ 
+#endif 
+ 
+#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 : 4324)        /* disable: C4324: padded structure */ 
+#else 
+#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) 
+#  ifdef __GNUC__ 
+#    define FORCE_INLINE static inline __attribute__((always_inline)) 
+#  else 
+#    define FORCE_INLINE static inline 
+#  endif 
+#endif 
+ 
+ 
+/* ******************************************************* 
+*  Constants 
+*********************************************************/ 
+#define HASH_LOG (ZSTD_MEMORY_USAGE - 2) 
+#define HASH_TABLESIZE (1 << HASH_LOG) 
+#define HASH_MASK (HASH_TABLESIZE - 1) 
+ 
+#define KNUTH 2654435761 
+ 
+#define BIT7 128 
+#define BIT6  64 
+#define BIT5  32 
+#define BIT4  16 
+#define BIT1   2 
+#define BIT0   1 
+ 
+#define KB *(1 <<10) 
+#define MB *(1 <<20) 
+#define GB *(1U<<30) 
+ 
+#define BLOCKSIZE (128 KB)                 /* define, for static allocation */ 
+#define MIN_SEQUENCES_SIZE (2 /*seqNb*/ + 2 /*dumps*/ + 3 /*seqTables*/ + 1 /*bitStream*/) 
+#define MIN_CBLOCK_SIZE (3 /*litCSize*/ + MIN_SEQUENCES_SIZE) 
+#define IS_RAW BIT0 
+#define IS_RLE BIT1 
+ 
+#define WORKPLACESIZE (BLOCKSIZE*3) 
+#define MINMATCH 4 
+#define MLbits   7 
+#define LLbits   6 
+#define Offbits  5 
+#define MaxML  ((1<<MLbits )-1) 
+#define MaxLL  ((1<<LLbits )-1) 
+#define MaxOff   31 
+#define LitFSELog  11 
+#define MLFSELog   10 
+#define LLFSELog   10 
+#define OffFSELog   9 
+#define MAX(a,b) ((a)<(b)?(b):(a)) 
+#define MaxSeq MAX(MaxLL, MaxML) 
+ 
+#define LITERAL_NOENTROPY 63 
+#define COMMAND_NOENTROPY 7   /* to remove */ 
+ 
+static const size_t ZSTD_blockHeaderSize = 3; 
+static const size_t ZSTD_frameHeaderSize = 4; 
+ 
+ 
+/* ******************************************************* 
+*  Memory operations 
+**********************************************************/ 
+static void   ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); } 
+ 
+static void   ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); } 
+ 
+#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; } 
+ 
+/*! ZSTD_wildcopy : custom version of memcpy(), can copy up to 7-8 bytes too many */ 
+static void ZSTD_wildcopy(void* dst, const void* src, size_t length) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + length; 
+    do COPY8(op, ip) while (op < oend); 
+} 
+ 
+ 
+/* ************************************** 
+*  Local structures 
+****************************************/ 
+typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t; 
+ 
+typedef struct 
+{ 
+    blockType_t blockType; 
+    U32 origSize; 
+} blockProperties_t; 
+ 
+typedef struct { 
+    void* buffer; 
+    U32*  offsetStart; 
+    U32*  offset; 
+    BYTE* offCodeStart; 
+    BYTE* offCode; 
+    BYTE* litStart; 
+    BYTE* lit; 
+    BYTE* litLengthStart; 
+    BYTE* litLength; 
+    BYTE* matchLengthStart; 
+    BYTE* matchLength; 
+    BYTE* dumpsStart; 
+    BYTE* dumps; 
+} seqStore_t; 
+ 
+ 
+/* ************************************* 
+*  Error Management 
+***************************************/ 
+/*! ZSTD_isError 
+*   tells if a return value is an error code */ 
+static unsigned ZSTD_isError(size_t code) { return ERR_isError(code); } 
+ 
+ 
+/* ************************************* 
+*  Function body to include 
+***************************************/ 
+static size_t ZSTD_read_ARCH(const void* p) { size_t r; memcpy(&r, p, sizeof(r)); return r; } 
+ 
+MEM_STATIC unsigned ZSTD_NbCommonBytes (register size_t val) 
+{ 
+    if (MEM_isLittleEndian()) 
+    { 
+        if (MEM_64bits()) 
+        { 
+#       if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            unsigned long r = 0; 
+            _BitScanForward64( &r, (U64)val ); 
+            return (int)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            return (__builtin_ctzll((U64)val) >> 3); 
+#       else 
+            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 }; 
+            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58]; 
+#       endif 
+        } 
+        else /* 32 bits */ 
+        { 
+#       if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            unsigned long r; 
+            _BitScanForward( &r, (U32)val ); 
+            return (int)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            return (__builtin_ctz((U32)val) >> 3); 
+#       else 
+            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 }; 
+            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27]; 
+#       endif 
+        } 
+    } 
+    else   /* Big Endian CPU */ 
+    { 
+        if (MEM_32bits()) 
+        { 
+#       if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            unsigned long r = 0; 
+            _BitScanReverse64( &r, val ); 
+            return (unsigned)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            return (__builtin_clzll(val) >> 3); 
+#       else 
+            unsigned r; 
+            const unsigned n32 = sizeof(size_t)*4;   /* calculate this way due to compiler complaining in 32-bits mode */ 
+            if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; } 
+            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; } 
+            r += (!val); 
+            return r; 
+#       endif 
+        } 
+        else /* 32 bits */ 
+        { 
+#       if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            unsigned long r = 0; 
+            _BitScanReverse( &r, (unsigned long)val ); 
+            return (unsigned)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            return (__builtin_clz((U32)val) >> 3); 
+#       else 
+            unsigned r; 
+            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; } 
+            r += (!val); 
+            return r; 
+#       endif 
+        } 
+    } 
+} 
+ 
+ 
+MEM_STATIC size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit) 
+{ 
+    const BYTE* const pStart = pIn; 
+ 
+    while ((pIn<pInLimit-(sizeof(size_t)-1))) 
+    { 
+        size_t diff = ZSTD_read_ARCH(pMatch) ^ ZSTD_read_ARCH(pIn); 
+        if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; } 
+        pIn += ZSTD_NbCommonBytes(diff); 
+        return (size_t)(pIn - pStart); 
+    } 
+ 
+    if (MEM_32bits()) if ((pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; } 
+    if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; } 
+    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++; 
+    return (size_t)(pIn - pStart); 
+} 
+ 
+ 
+/* ************************************************************* 
+*   Decompression section 
+***************************************************************/ 
+struct ZSTD_DCtx_s 
+{ 
+    U32 LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)]; 
+    U32 OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)]; 
+    U32 MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)]; 
+    void* previousDstEnd; 
+    void* base; 
+    size_t expected; 
+    blockType_t bType; 
+    U32 phase; 
+    const BYTE* litPtr; 
+    size_t litBufSize; 
+    size_t litSize; 
+    BYTE litBuffer[BLOCKSIZE + 8 /* margin for wildcopy */]; 
+};   /* typedef'd to ZSTD_Dctx within "zstd_static.h" */ 
+ 
+ 
+static size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr) 
+{ 
+    const BYTE* const in = (const BYTE* const)src; 
+    BYTE headerFlags; 
+    U32 cSize; 
+ 
+    if (srcSize < 3) return ERROR(srcSize_wrong); 
+ 
+    headerFlags = *in; 
+    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16); 
+ 
+    bpPtr->blockType = (blockType_t)(headerFlags >> 6); 
+    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0; 
+ 
+    if (bpPtr->blockType == bt_end) return 0; 
+    if (bpPtr->blockType == bt_rle) return 1; 
+    return cSize; 
+} 
+ 
+static size_t ZSTD_copyUncompressedBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall); 
+    memcpy(dst, src, srcSize); 
+    return srcSize; 
+} 
+ 
+ 
+/** ZSTD_decompressLiterals 
+    @return : nb of bytes read from src, or an error code*/ 
+static size_t ZSTD_decompressLiterals(void* dst, size_t* maxDstSizePtr, 
+                                const void* src, size_t srcSize) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+ 
+    const size_t litSize = (MEM_readLE32(src) & 0x1FFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */ 
+    const size_t litCSize = (MEM_readLE32(ip+2) & 0xFFFFFF) >> 5;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */ 
+ 
+    if (litSize > *maxDstSizePtr) return ERROR(corruption_detected); 
+    if (litCSize + 5 > srcSize) return ERROR(corruption_detected); 
+ 
+    if (HUF_isError(HUF_decompress(dst, litSize, ip+5, litCSize))) return ERROR(corruption_detected); 
+ 
+    *maxDstSizePtr = litSize; 
+    return litCSize + 5; 
+} 
+ 
+ 
+/** ZSTD_decodeLiteralsBlock 
+    @return : nb of bytes read from src (< srcSize )*/ 
+static size_t ZSTD_decodeLiteralsBlock(void* ctx, 
+                          const void* src, size_t srcSize) 
+{ 
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)ctx; 
+    const BYTE* const istart = (const BYTE* const)src; 
+ 
+    /* any compressed block with literals segment must be at least this size */ 
+    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected); 
+ 
+    switch(*istart & 3) 
+    { 
+    default: 
+    case 0: 
+        { 
+            size_t litSize = BLOCKSIZE; 
+            const size_t readSize = ZSTD_decompressLiterals(dctx->litBuffer, &litSize, src, srcSize); 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litBufSize = BLOCKSIZE; 
+            dctx->litSize = litSize; 
+            return readSize;   /* works if it's an error too */ 
+        } 
+    case IS_RAW: 
+        { 
+            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */ 
+            if (litSize > srcSize-11)   /* risk of reading too far with wildcopy */ 
+            { 
+				if (litSize > srcSize-3) return ERROR(corruption_detected); 
+				memcpy(dctx->litBuffer, istart, litSize); 
+				dctx->litPtr = dctx->litBuffer; 
+				dctx->litBufSize = BLOCKSIZE; 
+				dctx->litSize = litSize; 
+				return litSize+3; 
+			} 
+			/* direct reference into compressed stream */ 
+            dctx->litPtr = istart+3; 
+            dctx->litBufSize = srcSize-3; 
+            dctx->litSize = litSize; 
+            return litSize+3; 
+        } 
+    case IS_RLE: 
+        { 
+            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */ 
+            if (litSize > BLOCKSIZE) return ERROR(corruption_detected); 
+            memset(dctx->litBuffer, istart[3], litSize); 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litBufSize = BLOCKSIZE; 
+            dctx->litSize = litSize; 
+            return 4; 
+        } 
+    } 
+} 
+ 
+ 
+static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr, 
+                         FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb, 
+                         const void* src, size_t srcSize) 
+{ 
+    const BYTE* const istart = (const BYTE* const)src; 
+    const BYTE* ip = istart; 
+    const BYTE* const iend = istart + srcSize; 
+    U32 LLtype, Offtype, MLtype; 
+    U32 LLlog, Offlog, MLlog; 
+    size_t dumpsLength; 
+ 
+    /* check */ 
+    if (srcSize < 5) return ERROR(srcSize_wrong); 
+ 
+    /* SeqHead */ 
+    *nbSeq = MEM_readLE16(ip); ip+=2; 
+    LLtype  = *ip >> 6; 
+    Offtype = (*ip >> 4) & 3; 
+    MLtype  = (*ip >> 2) & 3; 
+    if (*ip & 2) 
+    { 
+        dumpsLength  = ip[2]; 
+        dumpsLength += ip[1] << 8; 
+        ip += 3; 
+    } 
+    else 
+    { 
+        dumpsLength  = ip[1]; 
+        dumpsLength += (ip[0] & 1) << 8; 
+        ip += 2; 
+    } 
+    *dumpsPtr = ip; 
+    ip += dumpsLength; 
+    *dumpsLengthPtr = dumpsLength; 
+ 
+    /* check */ 
+    if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */ 
+ 
+    /* sequences */ 
+    { 
+        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL and MaxOff */ 
+        size_t headerSize; 
+ 
+        /* Build DTables */ 
+        switch(LLtype) 
+        { 
+        U32 max; 
+        case bt_rle : 
+            LLlog = 0; 
+            FSE_buildDTable_rle(DTableLL, *ip++); break; 
+        case bt_raw : 
+            LLlog = LLbits; 
+            FSE_buildDTable_raw(DTableLL, LLbits); break; 
+        default : 
+            max = MaxLL; 
+            headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip); 
+            if (FSE_isError(headerSize)) return ERROR(GENERIC); 
+            if (LLlog > LLFSELog) return ERROR(corruption_detected); 
+            ip += headerSize; 
+            FSE_buildDTable(DTableLL, norm, max, LLlog); 
+        } 
+ 
+        switch(Offtype) 
+        { 
+        U32 max; 
+        case bt_rle : 
+            Offlog = 0; 
+            if (ip > iend-2) return ERROR(srcSize_wrong);   /* min : "raw", hence no header, but at least xxLog bits */ 
+            FSE_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */ 
+            break; 
+        case bt_raw : 
+            Offlog = Offbits; 
+            FSE_buildDTable_raw(DTableOffb, Offbits); break; 
+        default : 
+            max = MaxOff; 
+            headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip); 
+            if (FSE_isError(headerSize)) return ERROR(GENERIC); 
+            if (Offlog > OffFSELog) return ERROR(corruption_detected); 
+            ip += headerSize; 
+            FSE_buildDTable(DTableOffb, norm, max, Offlog); 
+        } 
+ 
+        switch(MLtype) 
+        { 
+        U32 max; 
+        case bt_rle : 
+            MLlog = 0; 
+            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */ 
+            FSE_buildDTable_rle(DTableML, *ip++); break; 
+        case bt_raw : 
+            MLlog = MLbits; 
+            FSE_buildDTable_raw(DTableML, MLbits); break; 
+        default : 
+            max = MaxML; 
+            headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip); 
+            if (FSE_isError(headerSize)) return ERROR(GENERIC); 
+            if (MLlog > MLFSELog) return ERROR(corruption_detected); 
+            ip += headerSize; 
+            FSE_buildDTable(DTableML, norm, max, MLlog); 
+        } 
+    } 
+ 
+    return ip-istart; 
+} 
+ 
+ 
+typedef struct { 
+    size_t litLength; 
+    size_t offset; 
+    size_t matchLength; 
+} seq_t; 
+ 
+typedef struct { 
+    BIT_DStream_t DStream; 
+    FSE_DState_t stateLL; 
+    FSE_DState_t stateOffb; 
+    FSE_DState_t stateML; 
+    size_t prevOffset; 
+    const BYTE* dumps; 
+    const BYTE* dumpsEnd; 
+} seqState_t; 
+ 
+ 
+static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState) 
+{ 
+    size_t litLength; 
+    size_t prevOffset; 
+    size_t offset; 
+    size_t matchLength; 
+    const BYTE* dumps = seqState->dumps; 
+    const BYTE* const de = seqState->dumpsEnd; 
+ 
+    /* Literal length */ 
+    litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream)); 
+    prevOffset = litLength ? seq->offset : seqState->prevOffset; 
+    seqState->prevOffset = seq->offset; 
+    if (litLength == MaxLL) 
+    { 
+        U32 add = *dumps++; 
+        if (add < 255) litLength += add; 
+        else 
+        { 
+            litLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */ 
+            dumps += 3; 
+        } 
+        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */ 
+    } 
+ 
+    /* Offset */ 
+    { 
+        static const size_t offsetPrefix[MaxOff+1] = {  /* note : size_t faster than U32 */ 
+                1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256, 
+                512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 
+                524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 }; 
+        U32 offsetCode, nbBits; 
+        offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream));   /* <= maxOff, by table construction */ 
+        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream)); 
+        nbBits = offsetCode - 1; 
+        if (offsetCode==0) nbBits = 0;   /* cmove */ 
+        offset = offsetPrefix[offsetCode] + BIT_readBits(&(seqState->DStream), nbBits); 
+        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream)); 
+        if (offsetCode==0) offset = prevOffset;   /* cmove */ 
+    } 
+ 
+    /* MatchLength */ 
+    matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream)); 
+    if (matchLength == MaxML) 
+    { 
+        U32 add = *dumps++; 
+        if (add < 255) matchLength += add; 
+        else 
+        { 
+            matchLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */ 
+            dumps += 3; 
+        } 
+        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */ 
+    } 
+    matchLength += MINMATCH; 
+ 
+    /* save result */ 
+    seq->litLength = litLength; 
+    seq->offset = offset; 
+    seq->matchLength = matchLength; 
+    seqState->dumps = dumps; 
+} 
+ 
+ 
+static size_t ZSTD_execSequence(BYTE* op, 
+                                seq_t sequence, 
+                                const BYTE** litPtr, const BYTE* const litLimit, 
+                                BYTE* const base, BYTE* const oend) 
+{ 
+    static const int dec32table[] = {0, 1, 2, 1, 4, 4, 4, 4};   /* added */ 
+    static const int dec64table[] = {8, 8, 8, 7, 8, 9,10,11};   /* substracted */ 
+    const BYTE* const ostart = op; 
+    BYTE* const oLitEnd = op + sequence.litLength; 
+    BYTE* const oMatchEnd = op + sequence.litLength + sequence.matchLength;   /* risk : address space overflow (32-bits) */ 
+    BYTE* const oend_8 = oend-8; 
+    const BYTE* const litEnd = *litPtr + sequence.litLength; 
+ 
+    /* checks */ 
+    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */ 
+    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */ 
+    if (litEnd > litLimit-8) return ERROR(corruption_detected);   /* overRead beyond lit buffer */ 
+ 
+    /* copy Literals */ 
+    ZSTD_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */ 
+    op = oLitEnd; 
+    *litPtr = litEnd;   /* update for next sequence */ 
+ 
+    /* copy Match */ 
+    { 
+        const BYTE* match = op - sequence.offset; 
+ 
+        /* check */ 
+        if (sequence.offset > (size_t)op) return ERROR(corruption_detected);   /* address space overflow test (this test seems kept by clang optimizer) */ 
+        //if (match > op) return ERROR(corruption_detected);   /* address space overflow test (is clang optimizer removing this test ?) */ 
+        if (match < base) return ERROR(corruption_detected); 
+ 
+        /* close range match, overlap */ 
+        if (sequence.offset < 8) 
+        { 
+            const int dec64 = dec64table[sequence.offset]; 
+            op[0] = match[0]; 
+            op[1] = match[1]; 
+            op[2] = match[2]; 
+            op[3] = match[3]; 
+            match += dec32table[sequence.offset]; 
+            ZSTD_copy4(op+4, match); 
+            match -= dec64; 
+        } 
+        else 
+        { 
+            ZSTD_copy8(op, match); 
+        } 
+        op += 8; match += 8; 
+ 
+        if (oMatchEnd > oend-12) 
+        { 
+            if (op < oend_8) 
+            { 
+                ZSTD_wildcopy(op, match, oend_8 - op); 
+                match += oend_8 - op; 
+                op = oend_8; 
+            } 
+            while (op < oMatchEnd) *op++ = *match++; 
+        } 
+        else 
+        { 
+            ZSTD_wildcopy(op, match, sequence.matchLength-8);   /* works even if matchLength < 8 */ 
+        } 
+    } 
+ 
+    return oMatchEnd - ostart; 
+} 
+ 
+static size_t ZSTD_decompressSequences( 
+                               void* ctx, 
+                               void* dst, size_t maxDstSize, 
+                         const void* seqStart, size_t seqSize) 
+{ 
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)ctx; 
+    const BYTE* ip = (const BYTE*)seqStart; 
+    const BYTE* const iend = ip + seqSize; 
+    BYTE* const ostart = (BYTE* const)dst; 
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + maxDstSize; 
+    size_t errorCode, dumpsLength; 
+    const BYTE* litPtr = dctx->litPtr; 
+    const BYTE* const litMax = litPtr + dctx->litBufSize; 
+    const BYTE* const litEnd = litPtr + dctx->litSize; 
+    int nbSeq; 
+    const BYTE* dumps; 
+    U32* DTableLL = dctx->LLTable; 
+    U32* DTableML = dctx->MLTable; 
+    U32* DTableOffb = dctx->OffTable; 
+    BYTE* const base = (BYTE*) (dctx->base); 
+ 
+    /* Build Decoding Tables */ 
+    errorCode = ZSTD_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength, 
+                                      DTableLL, DTableML, DTableOffb, 
+                                      ip, iend-ip); 
+    if (ZSTD_isError(errorCode)) return errorCode; 
+    ip += errorCode; 
+ 
+    /* Regen sequences */ 
+    { 
+        seq_t sequence; 
+        seqState_t seqState; 
+ 
+        memset(&sequence, 0, sizeof(sequence)); 
+        seqState.dumps = dumps; 
+        seqState.dumpsEnd = dumps + dumpsLength; 
+        seqState.prevOffset = 1; 
+        errorCode = BIT_initDStream(&(seqState.DStream), ip, iend-ip); 
+        if (ERR_isError(errorCode)) return ERROR(corruption_detected); 
+        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL); 
+        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb); 
+        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML); 
+ 
+        for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (nbSeq>0) ; ) 
+        { 
+            size_t oneSeqSize; 
+            nbSeq--; 
+            ZSTD_decodeSequence(&sequence, &seqState); 
+            oneSeqSize = ZSTD_execSequence(op, sequence, &litPtr, litMax, base, oend); 
+            if (ZSTD_isError(oneSeqSize)) return oneSeqSize; 
+            op += oneSeqSize; 
+        } 
+ 
+        /* check if reached exact end */ 
+        if ( !BIT_endOfDStream(&(seqState.DStream)) ) return ERROR(corruption_detected);   /* requested too much : data is corrupted */ 
+        if (nbSeq<0) return ERROR(corruption_detected);   /* requested too many sequences : data is corrupted */ 
+ 
+        /* last literal segment */ 
+        { 
+            size_t lastLLSize = litEnd - litPtr; 
+            if (litPtr > litEnd) return ERROR(corruption_detected); 
+            if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall); 
+            if (op != litPtr) memmove(op, litPtr, lastLLSize); 
+            op += lastLLSize; 
+        } 
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+static size_t ZSTD_decompressBlock( 
+                            void* ctx, 
+                            void* dst, size_t maxDstSize, 
+                      const void* src, size_t srcSize) 
+{ 
+    /* blockType == blockCompressed */ 
+    const BYTE* ip = (const BYTE*)src; 
+ 
+    /* Decode literals sub-block */ 
+    size_t litCSize = ZSTD_decodeLiteralsBlock(ctx, src, srcSize); 
+    if (ZSTD_isError(litCSize)) return litCSize; 
+    ip += litCSize; 
+    srcSize -= litCSize; 
+ 
+    return ZSTD_decompressSequences(ctx, dst, maxDstSize, ip, srcSize); 
+} 
+ 
+ 
+static size_t ZSTD_decompressDCtx(void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    const BYTE* iend = ip + srcSize; 
+    BYTE* const ostart = (BYTE* const)dst; 
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + maxDstSize; 
+    size_t remainingSize = srcSize; 
+    U32 magicNumber; 
+    blockProperties_t blockProperties; 
+ 
+    /* Frame Header */ 
+    if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong); 
+    magicNumber = MEM_readLE32(src); 
+    if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown); 
+    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize; 
+ 
+    /* Loop on each block */ 
+    while (1) 
+    { 
+        size_t decodedSize=0; 
+        size_t cBlockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties); 
+        if (ZSTD_isError(cBlockSize)) return cBlockSize; 
+ 
+        ip += ZSTD_blockHeaderSize; 
+        remainingSize -= ZSTD_blockHeaderSize; 
+        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong); 
+ 
+        switch(blockProperties.blockType) 
+        { 
+        case bt_compressed: 
+            decodedSize = ZSTD_decompressBlock(ctx, op, oend-op, ip, cBlockSize); 
+            break; 
+        case bt_raw : 
+            decodedSize = ZSTD_copyUncompressedBlock(op, oend-op, ip, cBlockSize); 
+            break; 
+        case bt_rle : 
+            return ERROR(GENERIC);   /* not yet supported */ 
+            break; 
+        case bt_end : 
+            /* end of frame */ 
+            if (remainingSize) return ERROR(srcSize_wrong); 
+            break; 
+        default: 
+            return ERROR(GENERIC);   /* impossible */ 
+        } 
+        if (cBlockSize == 0) break;   /* bt_end */ 
+ 
+        if (ZSTD_isError(decodedSize)) return decodedSize; 
+        op += decodedSize; 
+        ip += cBlockSize; 
+        remainingSize -= cBlockSize; 
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+static size_t ZSTD_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    ZSTD_DCtx ctx; 
+    ctx.base = dst; 
+    return ZSTD_decompressDCtx(&ctx, dst, maxDstSize, src, srcSize); 
+} 
+ 
+ 
+/******************************* 
+*  Streaming Decompression API 
+*******************************/ 
+ 
+static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx) 
+{ 
+    dctx->expected = ZSTD_frameHeaderSize; 
+    dctx->phase = 0; 
+    dctx->previousDstEnd = NULL; 
+    dctx->base = NULL; 
+    return 0; 
+} 
+ 
+static ZSTD_DCtx* ZSTD_createDCtx(void) 
+{ 
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)malloc(sizeof(ZSTD_DCtx)); 
+    if (dctx==NULL) return NULL; 
+    ZSTD_resetDCtx(dctx); 
+    return dctx; 
+} 
+ 
+static size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx) 
+{ 
+    free(dctx); 
+    return 0; 
+} 
+ 
+static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) 
+{ 
+    return dctx->expected; 
+} 
+ 
+static size_t ZSTD_decompressContinue(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    /* Sanity check */ 
+    if (srcSize != ctx->expected) return ERROR(srcSize_wrong); 
+    if (dst != ctx->previousDstEnd)  /* not contiguous */ 
+        ctx->base = dst; 
+ 
+    /* Decompress : frame header */ 
+    if (ctx->phase == 0) 
+    { 
+        /* Check frame magic header */ 
+        U32 magicNumber = MEM_readLE32(src); 
+        if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown); 
+        ctx->phase = 1; 
+        ctx->expected = ZSTD_blockHeaderSize; 
+        return 0; 
+    } 
+ 
+    /* Decompress : block header */ 
+    if (ctx->phase == 1) 
+    { 
+        blockProperties_t bp; 
+        size_t blockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp); 
+        if (ZSTD_isError(blockSize)) return blockSize; 
+        if (bp.blockType == bt_end) 
+        { 
+            ctx->expected = 0; 
+            ctx->phase = 0; 
+        } 
+        else 
+        { 
+            ctx->expected = blockSize; 
+            ctx->bType = bp.blockType; 
+            ctx->phase = 2; 
+        } 
+ 
+        return 0; 
+    } 
+ 
+    /* Decompress : block content */ 
+    { 
+        size_t rSize; 
+        switch(ctx->bType) 
+        { 
+        case bt_compressed: 
+            rSize = ZSTD_decompressBlock(ctx, dst, maxDstSize, src, srcSize); 
+            break; 
+        case bt_raw : 
+            rSize = ZSTD_copyUncompressedBlock(dst, maxDstSize, src, srcSize); 
+            break; 
+        case bt_rle : 
+            return ERROR(GENERIC);   /* not yet handled */ 
+            break; 
+        case bt_end :   /* should never happen (filtered at phase 1) */ 
+            rSize = 0; 
+            break; 
+        default: 
+            return ERROR(GENERIC); 
+        } 
+        ctx->phase = 1; 
+        ctx->expected = ZSTD_blockHeaderSize; 
+        ctx->previousDstEnd = (void*)( ((char*)dst) + rSize); 
+        return rSize; 
+    } 
+ 
+} 
+ 
+ 
+/* wrapper layer */ 
+ 
+unsigned ZSTDv02_isError(size_t code) 
+{ 
+	return ZSTD_isError(code); 
+} 
+ 
+size_t ZSTDv02_decompress( void* dst, size_t maxOriginalSize, 
+                     const void* src, size_t compressedSize) 
+{ 
+	return ZSTD_decompress(dst, maxOriginalSize, src, compressedSize); 
+} 
+ 
+ZSTDv02_Dctx* ZSTDv02_createDCtx(void) 
+{ 
+	return (ZSTDv02_Dctx*)ZSTD_createDCtx(); 
+} 
+ 
+size_t ZSTDv02_freeDCtx(ZSTDv02_Dctx* dctx) 
+{ 
+	return ZSTD_freeDCtx((ZSTD_DCtx*)dctx); 
+} 
+ 
+size_t ZSTDv02_resetDCtx(ZSTDv02_Dctx* dctx) 
+{ 
+	return ZSTD_resetDCtx((ZSTD_DCtx*)dctx); 
+} 
+ 
+size_t ZSTDv02_nextSrcSizeToDecompress(ZSTDv02_Dctx* dctx) 
+{ 
+	return ZSTD_nextSrcSizeToDecompress((ZSTD_DCtx*)dctx); 
+} 
+ 
+size_t ZSTDv02_decompressContinue(ZSTDv02_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+	return ZSTD_decompressContinue((ZSTD_DCtx*)dctx, dst, maxDstSize, src, srcSize); 
+} 
diff --git a/contrib/libs/zstd06/legacy/zstd_v02.h b/contrib/libs/zstd06/legacy/zstd_v02.h
index 462ea1e303..12be124985 100644
--- a/contrib/libs/zstd06/legacy/zstd_v02.h
+++ b/contrib/libs/zstd06/legacy/zstd_v02.h
@@ -1,100 +1,100 @@
 #include <contrib/libs/zstd06/renames.h>
-/*
-    zstd_v02 - decoder for 0.2 format
-    Header File
-    Copyright (C) 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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-#pragma once
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* *************************************
-*  Includes
-***************************************/
-#include <stddef.h>   /* size_t */
-
-
-/* *************************************
-*  Simple one-step function
-***************************************/
-/**
-ZSTDv02_decompress() : decompress ZSTD frames compliant with v0.2.x format
-    compressedSize : is the exact source size
-    maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated.
-                      It must be equal or larger than originalSize, otherwise decompression will fail.
-    return : the number of bytes decompressed into destination buffer (originalSize)
-             or an errorCode if it fails (which can be tested using ZSTDv01_isError())
-*/
-size_t ZSTDv02_decompress( void* dst, size_t maxOriginalSize,
-                     const void* src, size_t compressedSize);
-
-/**
-ZSTDv02_isError() : tells if the result of ZSTDv02_decompress() is an error
-*/
-unsigned ZSTDv02_isError(size_t code);
-
-
-/* *************************************
-*  Advanced functions
-***************************************/
-typedef struct ZSTDv02_Dctx_s ZSTDv02_Dctx;
-ZSTDv02_Dctx* ZSTDv02_createDCtx(void);
-size_t ZSTDv02_freeDCtx(ZSTDv02_Dctx* dctx);
-
-size_t ZSTDv02_decompressDCtx(void* ctx,
-                              void* dst, size_t maxOriginalSize,
-                        const void* src, size_t compressedSize);
-
-/* *************************************
-*  Streaming functions
-***************************************/
-size_t ZSTDv02_resetDCtx(ZSTDv02_Dctx* dctx);
-
-size_t ZSTDv02_nextSrcSizeToDecompress(ZSTDv02_Dctx* dctx);
-size_t ZSTDv02_decompressContinue(ZSTDv02_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
-/**
-  Use above functions alternatively.
-  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
-  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
-  Result is the number of bytes regenerated within 'dst'.
-  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
-*/
-
-/* *************************************
-*  Prefix - version detection
-***************************************/
-#define ZSTDv02_magicNumber 0xFD2FB522   /* v0.2 */
-
-
-#if defined (__cplusplus)
-}
-#endif
+/* 
+    zstd_v02 - decoder for 0.2 format 
+    Header File 
+    Copyright (C) 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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+#pragma once 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/* ************************************* 
+*  Includes 
+***************************************/ 
+#include <stddef.h>   /* size_t */ 
+ 
+ 
+/* ************************************* 
+*  Simple one-step function 
+***************************************/ 
+/** 
+ZSTDv02_decompress() : decompress ZSTD frames compliant with v0.2.x format 
+    compressedSize : is the exact source size 
+    maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated. 
+                      It must be equal or larger than originalSize, otherwise decompression will fail. 
+    return : the number of bytes decompressed into destination buffer (originalSize) 
+             or an errorCode if it fails (which can be tested using ZSTDv01_isError()) 
+*/ 
+size_t ZSTDv02_decompress( void* dst, size_t maxOriginalSize, 
+                     const void* src, size_t compressedSize); 
+ 
+/** 
+ZSTDv02_isError() : tells if the result of ZSTDv02_decompress() is an error 
+*/ 
+unsigned ZSTDv02_isError(size_t code); 
+ 
+ 
+/* ************************************* 
+*  Advanced functions 
+***************************************/ 
+typedef struct ZSTDv02_Dctx_s ZSTDv02_Dctx; 
+ZSTDv02_Dctx* ZSTDv02_createDCtx(void); 
+size_t ZSTDv02_freeDCtx(ZSTDv02_Dctx* dctx); 
+ 
+size_t ZSTDv02_decompressDCtx(void* ctx, 
+                              void* dst, size_t maxOriginalSize, 
+                        const void* src, size_t compressedSize); 
+ 
+/* ************************************* 
+*  Streaming functions 
+***************************************/ 
+size_t ZSTDv02_resetDCtx(ZSTDv02_Dctx* dctx); 
+ 
+size_t ZSTDv02_nextSrcSizeToDecompress(ZSTDv02_Dctx* dctx); 
+size_t ZSTDv02_decompressContinue(ZSTDv02_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize); 
+/** 
+  Use above functions alternatively. 
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue(). 
+  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block. 
+  Result is the number of bytes regenerated within 'dst'. 
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header. 
+*/ 
+ 
+/* ************************************* 
+*  Prefix - version detection 
+***************************************/ 
+#define ZSTDv02_magicNumber 0xFD2FB522   /* v0.2 */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
diff --git a/contrib/libs/zstd06/legacy/zstd_v03.c b/contrib/libs/zstd06/legacy/zstd_v03.c
index f06b47fdc1..8a30ecd35c 100644
--- a/contrib/libs/zstd06/legacy/zstd_v03.c
+++ b/contrib/libs/zstd06/legacy/zstd_v03.c
@@ -1,3389 +1,3389 @@
-/* ******************************************************************
-   Error codes and messages
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef ERROR_H_MODULE
-#define ERROR_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-#include <stddef.h>    /* size_t, ptrdiff_t */
-#include "zstd_v03.h"
-
-/******************************************
-*  Compiler-specific
-******************************************/
-#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#  define ERR_STATIC static inline
-#elif defined(_MSC_VER)
-#  define ERR_STATIC static __inline
-#elif defined(__GNUC__)
-#  define ERR_STATIC static __attribute__((unused))
-#else
-#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
-#endif
-
-
-/******************************************
-*  Error Management
-******************************************/
-#define PREFIX(name) ZSTD_error_##name
-
-#define ERROR(name) (size_t)-PREFIX(name)
-
-#define ERROR_LIST(ITEM) \
-        ITEM(PREFIX(No_Error)) ITEM(PREFIX(GENERIC)) \
-        ITEM(PREFIX(memory_allocation)) \
-        ITEM(PREFIX(dstSize_tooSmall)) ITEM(PREFIX(srcSize_wrong)) \
-        ITEM(PREFIX(prefix_unknown)) ITEM(PREFIX(corruption_detected)) \
-        ITEM(PREFIX(tableLog_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooSmall)) \
-        ITEM(PREFIX(maxCode))
-
-#define ERROR_GENERATE_ENUM(ENUM) ENUM,
-typedef enum { ERROR_LIST(ERROR_GENERATE_ENUM) } ERR_codes;  /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */
-
-#define ERROR_CONVERTTOSTRING(STRING) #STRING,
-#define ERROR_GENERATE_STRING(EXPR) ERROR_CONVERTTOSTRING(EXPR)
-
-ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* ERROR_H_MODULE */
-
-
-/* ******************************************************************
-   mem.h
-   low-level memory access routines
-   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
-****************************************************************** */
-#ifndef MEM_H_MODULE
-#define MEM_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/******************************************
-*  Includes
-******************************************/
-#include <stddef.h>    /* size_t, ptrdiff_t */
-#include <string.h>    /* memcpy */
-
-
-/******************************************
-*  Compiler-specific
-******************************************/
-#if defined(__GNUC__)
-#  define MEM_STATIC static __attribute__((unused))
-#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#  define MEM_STATIC static inline
-#elif defined(_MSC_VER)
-#  define MEM_STATIC static __inline
-#else
-#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
-#endif
-
-
-/****************************************************************
-*  Basic Types
-*****************************************************************/
-#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-# include <stdint.h>
-  typedef  uint8_t BYTE;
-  typedef uint16_t U16;
-  typedef  int16_t S16;
-  typedef uint32_t U32;
-  typedef  int32_t S32;
-  typedef uint64_t U64;
-  typedef  int64_t S64;
-#else
-  typedef unsigned char       BYTE;
-  typedef unsigned short      U16;
-  typedef   signed short      S16;
-  typedef unsigned int        U32;
-  typedef   signed int        S32;
-  typedef unsigned long long  U64;
-  typedef   signed long long  S64;
-#endif
-
-
-/****************************************************************
-*  Memory I/O
-*****************************************************************/
-/* MEM_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 is portable but violate C standard.
- *            It can generate buggy code on targets generating assembly depending on alignment.
- *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
- * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
- * Prefer these methods in priority order (0 > 1 > 2)
- */
-#ifndef MEM_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 MEM_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 MEM_FORCE_MEMORY_ACCESS 1
-#  endif
-#endif
-
-MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }
-MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }
-
-MEM_STATIC unsigned MEM_isLittleEndian(void)
-{
-    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
-    return one.c[0];
-}
-
-#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)
-
-/* violates C standard on structure alignment.
-Only use if no other choice to achieve best performance on target platform */
-MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
-MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
-MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
-MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
-MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }
-
-#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_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 { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign;
-
-MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
-MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
-MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
-MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; }
-MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign*)memPtr)->u64 = value; }
-
-#else
-
-/* default method, safe and standard.
-   can sometimes prove slower */
-
-MEM_STATIC U16 MEM_read16(const void* memPtr)
-{
-    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC U32 MEM_read32(const void* memPtr)
-{
-    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC U64 MEM_read64(const void* memPtr)
-{
-    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-MEM_STATIC void MEM_write32(void* memPtr, U32 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-MEM_STATIC void MEM_write64(void* memPtr, U64 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-#endif // MEM_FORCE_MEMORY_ACCESS
-
-
-MEM_STATIC U16 MEM_readLE16(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read16(memPtr);
-    else
-    {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U16)(p[0] + (p[1]<<8));
-    }
-}
-
-MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
-{
-    if (MEM_isLittleEndian())
-    {
-        MEM_write16(memPtr, val);
-    }
-    else
-    {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE)val;
-        p[1] = (BYTE)(val>>8);
-    }
-}
-
-MEM_STATIC U32 MEM_readLE32(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read32(memPtr);
-    else
-    {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));
-    }
-}
-
-MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)
-{
-    if (MEM_isLittleEndian())
-    {
-        MEM_write32(memPtr, val32);
-    }
-    else
-    {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE)val32;
-        p[1] = (BYTE)(val32>>8);
-        p[2] = (BYTE)(val32>>16);
-        p[3] = (BYTE)(val32>>24);
-    }
-}
-
-MEM_STATIC U64 MEM_readLE64(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read64(memPtr);
-    else
-    {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)
-                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));
-    }
-}
-
-MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)
-{
-    if (MEM_isLittleEndian())
-    {
-        MEM_write64(memPtr, val64);
-    }
-    else
-    {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE)val64;
-        p[1] = (BYTE)(val64>>8);
-        p[2] = (BYTE)(val64>>16);
-        p[3] = (BYTE)(val64>>24);
-        p[4] = (BYTE)(val64>>32);
-        p[5] = (BYTE)(val64>>40);
-        p[6] = (BYTE)(val64>>48);
-        p[7] = (BYTE)(val64>>56);
-    }
-}
-
-MEM_STATIC size_t MEM_readLEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readLE32(memPtr);
-    else
-        return (size_t)MEM_readLE64(memPtr);
-}
-
-MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val)
-{
-    if (MEM_32bits())
-        MEM_writeLE32(memPtr, (U32)val);
-    else
-        MEM_writeLE64(memPtr, (U64)val);
-}
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* MEM_H_MODULE */
-
-
-/* ******************************************************************
-   bitstream
-   Part of NewGen Entropy library
-   header file (to include)
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef BITSTREAM_H_MODULE
-#define BITSTREAM_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/*
-*  This API consists of small unitary functions, which highly benefit from being inlined.
-*  Since link-time-optimization is not available for all compilers,
-*  these functions are defined into a .h to be included.
-*/
-
-
-/**********************************************
-*  bitStream decompression API (read backward)
-**********************************************/
-typedef struct
-{
-    size_t   bitContainer;
-    unsigned bitsConsumed;
-    const char* ptr;
-    const char* start;
-} BIT_DStream_t;
-
-typedef enum { BIT_DStream_unfinished = 0,
-               BIT_DStream_endOfBuffer = 1,
-               BIT_DStream_completed = 2,
-               BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */
-               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
-
-MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
-MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
-MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
-MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
-
-
-/*
-* Start by invoking BIT_initDStream().
-* A chunk of the bitStream is then stored into a local register.
-* 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 manually filled from memory by the BIT_reloadDStream() method.
-* A reload guarantee a minimum of ((8*sizeof(size_t))-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()
-*/
-
-
-/******************************************
-*  unsafe API
-******************************************/
-MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
-/* faster, but works only if nbBits >= 1 */
-
-
-
-/****************************************************************
-*  Helper functions
-****************************************************************/
-MEM_STATIC unsigned BIT_highbit32 (register U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
-    unsigned long r=0;
-    _BitScanReverse ( &r, val );
-    return (unsigned) r;
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
-    return 31 - __builtin_clz (val);
-#   else   /* Software version */
-    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
-    U32 v = val;
-    unsigned r;
-    v |= v >> 1;
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
-    return r;
-#   endif
-}
-
-
-
-/**********************************************************
-* bitStream decoding
-**********************************************************/
-
-/*!BIT_initDStream
-*  Initialize a BIT_DStream_t.
-*  @bitD : a pointer to an already allocated BIT_DStream_t structure
-*  @srcBuffer must point at the beginning of a bitStream
-*  @srcSize must be the exact size of the bitStream
-*  @result : size of stream (== srcSize) or an errorCode if a problem is detected
-*/
-MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
-{
-    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
-
-    if (srcSize >=  sizeof(size_t))   /* normal case */
-    {
-        U32 contain32;
-        bitD->start = (const char*)srcBuffer;
-        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t);
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);
-        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
-        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
-        bitD->bitsConsumed = 8 - BIT_highbit32(contain32);
-    }
-    else
-    {
-        U32 contain32;
-        bitD->start = (const char*)srcBuffer;
-        bitD->ptr   = bitD->start;
-        bitD->bitContainer = *(const BYTE*)(bitD->start);
-        switch(srcSize)
-        {
-            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);
-            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);
-            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);
-            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;
-            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;
-            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8;
-            default:;
-        }
-        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
-        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
-        bitD->bitsConsumed = 8 - BIT_highbit32(contain32);
-        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;
-    }
-
-    return srcSize;
-}
-
-/*!BIT_lookBits
- * Provides next n bits from local register
- * local register is not modified (bits are still present for next read/look)
- * On 32-bits, maxNbBits==25
- * On 64-bits, maxNbBits==57
- * @return : value extracted
- */
-MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)
-{
-    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
-    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
-}
-
-/*! BIT_lookBitsFast :
-*   unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits)
-{
-    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
-    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);
-}
-
-MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
-{
-    bitD->bitsConsumed += nbBits;
-}
-
-/*!BIT_readBits
- * Read next n bits from local register.
- * pay attention to not read more than nbBits contained into local register.
- * @return : extracted value.
- */
-MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
-{
-    size_t value = BIT_lookBits(bitD, nbBits);
-    BIT_skipBits(bitD, nbBits);
-    return value;
-}
-
-/*!BIT_readBitsFast :
-*  unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)
-{
-    size_t value = BIT_lookBitsFast(bitD, nbBits);
-    BIT_skipBits(bitD, nbBits);
-    return value;
-}
-
-MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
-{
-	if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
-		return BIT_DStream_overflow;
-
-    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer))
-    {
-        bitD->ptr -= bitD->bitsConsumed >> 3;
-        bitD->bitsConsumed &= 7;
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);
-        return BIT_DStream_unfinished;
-    }
-    if (bitD->ptr == bitD->start)
-    {
-        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
-        return BIT_DStream_completed;
-    }
-    {
-        U32 nbBytes = bitD->bitsConsumed >> 3;
-        BIT_DStream_status result = BIT_DStream_unfinished;
-        if (bitD->ptr - nbBytes < bitD->start)
-        {
-            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
-            result = BIT_DStream_endOfBuffer;
-        }
-        bitD->ptr -= nbBytes;
-        bitD->bitsConsumed -= nbBytes*8;
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
-        return result;
-    }
-}
-
-/*! BIT_endOfDStream
-*   @return Tells if DStream has reached its exact end
-*/
-MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
-{
-    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
-}
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* BITSTREAM_H_MODULE */
-/* ******************************************************************
-   Error codes and messages
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef ERROR_H_MODULE
-#define ERROR_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/******************************************
-*  Compiler-specific
-******************************************/
-#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#  define ERR_STATIC static inline
-#elif defined(_MSC_VER)
-#  define ERR_STATIC static __inline
-#elif defined(__GNUC__)
-#  define ERR_STATIC static __attribute__((unused))
-#else
-#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
-#endif
-
-
-/******************************************
-*  Error Management
-******************************************/
-#define PREFIX(name) ZSTD_error_##name
-
-#define ERROR(name) (size_t)-PREFIX(name)
-
-#define ERROR_LIST(ITEM) \
-        ITEM(PREFIX(No_Error)) ITEM(PREFIX(GENERIC)) \
-        ITEM(PREFIX(dstSize_tooSmall)) ITEM(PREFIX(srcSize_wrong)) \
-        ITEM(PREFIX(prefix_unknown)) ITEM(PREFIX(corruption_detected)) \
-        ITEM(PREFIX(tableLog_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooSmall)) \
-        ITEM(PREFIX(maxCode))
-
-#define ERROR_GENERATE_ENUM(ENUM) ENUM,
-typedef enum { ERROR_LIST(ERROR_GENERATE_ENUM) } ERR_codes;  /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */
-
-#define ERROR_CONVERTTOSTRING(STRING) #STRING,
-#define ERROR_GENERATE_STRING(EXPR) ERROR_CONVERTTOSTRING(EXPR)
-static const char* ERR_strings[] = { ERROR_LIST(ERROR_GENERATE_STRING) };
-
-ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }
-
-ERR_STATIC const char* ERR_getErrorName(size_t code)
-{
-    static const char* codeError = "Unspecified error code";
-    if (ERR_isError(code)) return ERR_strings[-(int)(code)];
-    return codeError;
-}
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* ERROR_H_MODULE */
-/*
-Constructor and Destructor of type FSE_CTable
-    Note that its size depends on 'tableLog' and 'maxSymbolValue' */
-typedef unsigned FSE_CTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
-typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
-
-
-/* ******************************************************************
-   FSE : Finite State Entropy coder
-   header file for static linking (only)
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/******************************************
-*  Static allocation
-******************************************/
-/* FSE buffer bounds */
-#define FSE_NCOUNTBOUND 512
-#define FSE_BLOCKBOUND(size) (size + (size>>7))
-#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
-
-/* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */
-#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))
-#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
-
-
-/******************************************
-*  FSE advanced API
-******************************************/
-static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);
-/* build a fake FSE_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */
-
-static size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);
-/* build a fake FSE_DTable, designed to always generate the same symbolValue */
-
-
-/******************************************
-*  FSE symbol decompression API
-******************************************/
-typedef struct
-{
-    size_t      state;
-    const void* table;   /* precise table may vary, depending on U16 */
-} FSE_DState_t;
-
-
-static void     FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);
-
-static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
-
-static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
-
-/*
-Let's now decompose FSE_decompress_usingDTable() into its unitary components.
-You will decode FSE-encoded symbols from the bitStream,
-and also any other bitFields you put in, **in reverse order**.
-
-You will need a few variables to track your bitStream. They are :
-
-BIT_DStream_t DStream;    // Stream context
-FSE_DState_t  DState;     // State context. Multiple ones are possible
-FSE_DTable*   DTablePtr;  // Decoding table, provided by FSE_buildDTable()
-
-The first thing to do is to init the bitStream.
-    errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize);
-
-You should then retrieve your initial state(s)
-(in reverse flushing order if you have several ones) :
-    errorCode = FSE_initDState(&DState, &DStream, DTablePtr);
-
-You can then decode your data, symbol after symbol.
-For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'.
-Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
-    unsigned char symbol = FSE_decodeSymbol(&DState, &DStream);
-
-You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
-Note : maximum allowed nbBits is 25, for 32-bits compatibility
-    size_t bitField = BIT_readBits(&DStream, nbBits);
-
-All above operations only read from local register (which size depends on size_t).
-Refueling the register from memory is manually performed by the reload method.
-    endSignal = FSE_reloadDStream(&DStream);
-
-BIT_reloadDStream() result tells if there is still some more data to read from DStream.
-BIT_DStream_unfinished : there is still some data left into the DStream.
-BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
-BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
-BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted.
-
-When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
-to properly detect the exact end of stream.
-After each decoded symbol, check if DStream is fully consumed using this simple test :
-    BIT_reloadDStream(&DStream) >= BIT_DStream_completed
-
-When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
-Checking if DStream has reached its end is performed by :
-    BIT_endOfDStream(&DStream);
-Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
-    FSE_endOfDState(&DState);
-*/
-
-
-/******************************************
-*  FSE unsafe API
-******************************************/
-static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
-/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
-
-
-/******************************************
-*  Implementation of inline functions
-******************************************/
-
-/* decompression */
-
-typedef struct {
-    U16 tableLog;
-    U16 fastMode;
-} FSE_DTableHeader;   /* sizeof U32 */
-
-typedef struct
-{
-    unsigned short newState;
-    unsigned char  symbol;
-    unsigned char  nbBits;
-} FSE_decode_t;   /* size == U32 */
-
-MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
-{
-    FSE_DTableHeader DTableH;
-    memcpy(&DTableH, dt, sizeof(DTableH));
-    DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog);
-    BIT_reloadDStream(bitD);
-    DStatePtr->table = dt + 1;
-}
-
-MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
-{
-    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    const U32  nbBits = DInfo.nbBits;
-    BYTE symbol = DInfo.symbol;
-    size_t lowBits = BIT_readBits(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
-{
-    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    const U32 nbBits = DInfo.nbBits;
-    BYTE symbol = DInfo.symbol;
-    size_t lowBits = BIT_readBitsFast(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
-{
-    return DStatePtr->state == 0;
-}
-
-
-#if defined (__cplusplus)
-}
-#endif
-/* ******************************************************************
-   Huff0 : Huffman coder, part of New Generation Entropy library
-   header file for static linking (only)
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/******************************************
-*  Static allocation macros
-******************************************/
-/* Huff0 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 Huff0's DTable */
-#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog))  /* nb Cells; use unsigned short for X2, unsigned int for X4 */
-#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 functions
-******************************************/
-static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
-static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-/*
-    zstd - standard compression library
-    Header File
-    Copyright (C) 2014-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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* *************************************
-*  Includes
-***************************************/
-#include <stddef.h>   /* size_t */
-
-
-/* *************************************
-*  Version
-***************************************/
-#define ZSTD_VERSION_MAJOR    0    /* for breaking interface changes  */
-#define ZSTD_VERSION_MINOR    2    /* for new (non-breaking) interface capabilities */
-#define ZSTD_VERSION_RELEASE  2    /* for tweaks, bug-fixes, or development */
-#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
-
-
-/* *************************************
-*  Advanced functions
-***************************************/
-typedef struct ZSTD_CCtx_s ZSTD_CCtx;   /* incomplete type */
-
-#if defined (__cplusplus)
-}
-#endif
-/*
-    zstd - standard compression library
-    Header File for static linking only
-    Copyright (C) 2014-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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-
-/* The objects defined into this file should be considered experimental.
- * They are not labelled stable, as their prototype may change in the future.
- * You can use them for tests, provide feedback, or if you can endure risk of future changes.
- */
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* *************************************
-*  Streaming functions
-***************************************/
-
-typedef struct ZSTD_DCtx_s ZSTD_DCtx;
-
-/*
-  Use above functions alternatively.
-  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
-  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
-  Result is the number of bytes regenerated within 'dst'.
-  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
-*/
-
-/* *************************************
-*  Prefix - version detection
-***************************************/
-#define ZSTD_magicNumber 0xFD2FB523   /* v0.3 */
-
-
-#if defined (__cplusplus)
-}
-#endif
-/* ******************************************************************
-   FSE : Finite State Entropy coder
-   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
-****************************************************************** */
-
-#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
-
-
-/****************************************************************
-*  Byte symbol type
-****************************************************************/
-#endif   /* !FSE_COMMONDEFS_ONLY */
-
-
-/****************************************************************
-*  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) */
-
-/****************************************************************
-*  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
-
-
-/****************************************************************
-*  Error Management
-****************************************************************/
-#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 */
-
+/* ****************************************************************** 
+   Error codes and messages 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef ERROR_H_MODULE 
+#define ERROR_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+#include <stddef.h>    /* size_t, ptrdiff_t */ 
+#include "zstd_v03.h" 
+ 
+/****************************************** 
+*  Compiler-specific 
+******************************************/ 
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+#  define ERR_STATIC static inline 
+#elif defined(_MSC_VER) 
+#  define ERR_STATIC static __inline 
+#elif defined(__GNUC__) 
+#  define ERR_STATIC static __attribute__((unused)) 
+#else 
+#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */ 
+#endif 
+ 
+ 
+/****************************************** 
+*  Error Management 
+******************************************/ 
+#define PREFIX(name) ZSTD_error_##name 
+ 
+#define ERROR(name) (size_t)-PREFIX(name) 
+ 
+#define ERROR_LIST(ITEM) \ 
+        ITEM(PREFIX(No_Error)) ITEM(PREFIX(GENERIC)) \ 
+        ITEM(PREFIX(memory_allocation)) \ 
+        ITEM(PREFIX(dstSize_tooSmall)) ITEM(PREFIX(srcSize_wrong)) \ 
+        ITEM(PREFIX(prefix_unknown)) ITEM(PREFIX(corruption_detected)) \ 
+        ITEM(PREFIX(tableLog_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooSmall)) \ 
+        ITEM(PREFIX(maxCode)) 
+ 
+#define ERROR_GENERATE_ENUM(ENUM) ENUM, 
+typedef enum { ERROR_LIST(ERROR_GENERATE_ENUM) } ERR_codes;  /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */ 
+ 
+#define ERROR_CONVERTTOSTRING(STRING) #STRING, 
+#define ERROR_GENERATE_STRING(EXPR) ERROR_CONVERTTOSTRING(EXPR) 
+ 
+ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); } 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* ERROR_H_MODULE */ 
+ 
+ 
+/* ****************************************************************** 
+   mem.h 
+   low-level memory access routines 
+   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 
+****************************************************************** */ 
+#ifndef MEM_H_MODULE 
+#define MEM_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/****************************************** 
+*  Includes 
+******************************************/ 
+#include <stddef.h>    /* size_t, ptrdiff_t */ 
+#include <string.h>    /* memcpy */ 
+ 
+ 
+/****************************************** 
+*  Compiler-specific 
+******************************************/ 
+#if defined(__GNUC__) 
+#  define MEM_STATIC static __attribute__((unused)) 
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+#  define MEM_STATIC static inline 
+#elif defined(_MSC_VER) 
+#  define MEM_STATIC static __inline 
+#else 
+#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */ 
+#endif 
+ 
+ 
+/**************************************************************** 
+*  Basic Types 
+*****************************************************************/ 
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+# include <stdint.h> 
+  typedef  uint8_t BYTE; 
+  typedef uint16_t U16; 
+  typedef  int16_t S16; 
+  typedef uint32_t U32; 
+  typedef  int32_t S32; 
+  typedef uint64_t U64; 
+  typedef  int64_t S64; 
+#else 
+  typedef unsigned char       BYTE; 
+  typedef unsigned short      U16; 
+  typedef   signed short      S16; 
+  typedef unsigned int        U32; 
+  typedef   signed int        S32; 
+  typedef unsigned long long  U64; 
+  typedef   signed long long  S64; 
+#endif 
+ 
+ 
+/**************************************************************** 
+*  Memory I/O 
+*****************************************************************/ 
+/* MEM_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 is portable but violate C standard. 
+ *            It can generate buggy code on targets generating assembly depending on alignment. 
+ *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) 
+ * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details. 
+ * Prefer these methods in priority order (0 > 1 > 2) 
+ */ 
+#ifndef MEM_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 MEM_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 MEM_FORCE_MEMORY_ACCESS 1 
+#  endif 
+#endif 
+ 
+MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; } 
+MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; } 
+ 
+MEM_STATIC unsigned MEM_isLittleEndian(void) 
+{ 
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */ 
+    return one.c[0]; 
+} 
+ 
+#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2) 
+ 
+/* violates C standard on structure alignment. 
+Only use if no other choice to achieve best performance on target platform */ 
+MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; } 
+MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; } 
+MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; } 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; } 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; } 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; } 
+ 
+#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_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 { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign; 
+ 
+MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; } 
+MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; } 
+MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; } 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; } 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; } 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign*)memPtr)->u64 = value; } 
+ 
+#else 
+ 
+/* default method, safe and standard. 
+   can sometimes prove slower */ 
+ 
+MEM_STATIC U16 MEM_read16(const void* memPtr) 
+{ 
+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC U32 MEM_read32(const void* memPtr) 
+{ 
+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC U64 MEM_read64(const void* memPtr) 
+{ 
+    U64 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+#endif // MEM_FORCE_MEMORY_ACCESS 
+ 
+ 
+MEM_STATIC U16 MEM_readLE16(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read16(memPtr); 
+    else 
+    { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U16)(p[0] + (p[1]<<8)); 
+    } 
+} 
+ 
+MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val) 
+{ 
+    if (MEM_isLittleEndian()) 
+    { 
+        MEM_write16(memPtr, val); 
+    } 
+    else 
+    { 
+        BYTE* p = (BYTE*)memPtr; 
+        p[0] = (BYTE)val; 
+        p[1] = (BYTE)(val>>8); 
+    } 
+} 
+ 
+MEM_STATIC U32 MEM_readLE32(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read32(memPtr); 
+    else 
+    { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24)); 
+    } 
+} 
+ 
+MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32) 
+{ 
+    if (MEM_isLittleEndian()) 
+    { 
+        MEM_write32(memPtr, val32); 
+    } 
+    else 
+    { 
+        BYTE* p = (BYTE*)memPtr; 
+        p[0] = (BYTE)val32; 
+        p[1] = (BYTE)(val32>>8); 
+        p[2] = (BYTE)(val32>>16); 
+        p[3] = (BYTE)(val32>>24); 
+    } 
+} 
+ 
+MEM_STATIC U64 MEM_readLE64(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read64(memPtr); 
+    else 
+    { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24) 
+                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56)); 
+    } 
+} 
+ 
+MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64) 
+{ 
+    if (MEM_isLittleEndian()) 
+    { 
+        MEM_write64(memPtr, val64); 
+    } 
+    else 
+    { 
+        BYTE* p = (BYTE*)memPtr; 
+        p[0] = (BYTE)val64; 
+        p[1] = (BYTE)(val64>>8); 
+        p[2] = (BYTE)(val64>>16); 
+        p[3] = (BYTE)(val64>>24); 
+        p[4] = (BYTE)(val64>>32); 
+        p[5] = (BYTE)(val64>>40); 
+        p[6] = (BYTE)(val64>>48); 
+        p[7] = (BYTE)(val64>>56); 
+    } 
+} 
+ 
+MEM_STATIC size_t MEM_readLEST(const void* memPtr) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_readLE32(memPtr); 
+    else 
+        return (size_t)MEM_readLE64(memPtr); 
+} 
+ 
+MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val) 
+{ 
+    if (MEM_32bits()) 
+        MEM_writeLE32(memPtr, (U32)val); 
+    else 
+        MEM_writeLE64(memPtr, (U64)val); 
+} 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* MEM_H_MODULE */ 
+ 
+ 
+/* ****************************************************************** 
+   bitstream 
+   Part of NewGen Entropy library 
+   header file (to include) 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef BITSTREAM_H_MODULE 
+#define BITSTREAM_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* 
+*  This API consists of small unitary functions, which highly benefit from being inlined. 
+*  Since link-time-optimization is not available for all compilers, 
+*  these functions are defined into a .h to be included. 
+*/ 
+ 
+ 
+/********************************************** 
+*  bitStream decompression API (read backward) 
+**********************************************/ 
+typedef struct 
+{ 
+    size_t   bitContainer; 
+    unsigned bitsConsumed; 
+    const char* ptr; 
+    const char* start; 
+} BIT_DStream_t; 
+ 
+typedef enum { BIT_DStream_unfinished = 0, 
+               BIT_DStream_endOfBuffer = 1, 
+               BIT_DStream_completed = 2, 
+               BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */ 
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */ 
+ 
+MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize); 
+MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits); 
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD); 
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD); 
+ 
+ 
+/* 
+* Start by invoking BIT_initDStream(). 
+* A chunk of the bitStream is then stored into a local register. 
+* 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 manually filled from memory by the BIT_reloadDStream() method. 
+* A reload guarantee a minimum of ((8*sizeof(size_t))-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() 
+*/ 
+ 
+ 
+/****************************************** 
+*  unsafe API 
+******************************************/ 
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits); 
+/* faster, but works only if nbBits >= 1 */ 
+ 
+ 
+ 
+/**************************************************************** 
+*  Helper functions 
+****************************************************************/ 
+MEM_STATIC unsigned BIT_highbit32 (register U32 val) 
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
+    unsigned long r=0; 
+    _BitScanReverse ( &r, val ); 
+    return (unsigned) r; 
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */ 
+    return 31 - __builtin_clz (val); 
+#   else   /* Software version */ 
+    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 }; 
+    U32 v = val; 
+    unsigned r; 
+    v |= v >> 1; 
+    v |= v >> 2; 
+    v |= v >> 4; 
+    v |= v >> 8; 
+    v |= v >> 16; 
+    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27]; 
+    return r; 
+#   endif 
+} 
+ 
+ 
+ 
+/********************************************************** 
+* bitStream decoding 
+**********************************************************/ 
+ 
+/*!BIT_initDStream 
+*  Initialize a BIT_DStream_t. 
+*  @bitD : a pointer to an already allocated BIT_DStream_t structure 
+*  @srcBuffer must point at the beginning of a bitStream 
+*  @srcSize must be the exact size of the bitStream 
+*  @result : size of stream (== srcSize) or an errorCode if a problem is detected 
+*/ 
+MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize) 
+{ 
+    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); } 
+ 
+    if (srcSize >=  sizeof(size_t))   /* normal case */ 
+    { 
+        U32 contain32; 
+        bitD->start = (const char*)srcBuffer; 
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t); 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr); 
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1]; 
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */ 
+        bitD->bitsConsumed = 8 - BIT_highbit32(contain32); 
+    } 
+    else 
+    { 
+        U32 contain32; 
+        bitD->start = (const char*)srcBuffer; 
+        bitD->ptr   = bitD->start; 
+        bitD->bitContainer = *(const BYTE*)(bitD->start); 
+        switch(srcSize) 
+        { 
+            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16); 
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24); 
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32); 
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; 
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; 
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8; 
+            default:; 
+        } 
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1]; 
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */ 
+        bitD->bitsConsumed = 8 - BIT_highbit32(contain32); 
+        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8; 
+    } 
+ 
+    return srcSize; 
+} 
+ 
+/*!BIT_lookBits 
+ * Provides next n bits from local register 
+ * local register is not modified (bits are still present for next read/look) 
+ * On 32-bits, maxNbBits==25 
+ * On 64-bits, maxNbBits==57 
+ * @return : value extracted 
+ */ 
+MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1; 
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask); 
+} 
+ 
+/*! BIT_lookBitsFast : 
+*   unsafe version; only works only if nbBits >= 1 */ 
+MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1; 
+    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask); 
+} 
+ 
+MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    bitD->bitsConsumed += nbBits; 
+} 
+ 
+/*!BIT_readBits 
+ * Read next n bits from local register. 
+ * pay attention to not read more than nbBits contained into local register. 
+ * @return : extracted value. 
+ */ 
+MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t value = BIT_lookBits(bitD, nbBits); 
+    BIT_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+/*!BIT_readBitsFast : 
+*  unsafe version; only works only if nbBits >= 1 */ 
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t value = BIT_lookBitsFast(bitD, nbBits); 
+    BIT_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD) 
+{ 
+	if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */ 
+		return BIT_DStream_overflow; 
+ 
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) 
+    { 
+        bitD->ptr -= bitD->bitsConsumed >> 3; 
+        bitD->bitsConsumed &= 7; 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr); 
+        return BIT_DStream_unfinished; 
+    } 
+    if (bitD->ptr == bitD->start) 
+    { 
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer; 
+        return BIT_DStream_completed; 
+    } 
+    { 
+        U32 nbBytes = bitD->bitsConsumed >> 3; 
+        BIT_DStream_status result = BIT_DStream_unfinished; 
+        if (bitD->ptr - nbBytes < bitD->start) 
+        { 
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */ 
+            result = BIT_DStream_endOfBuffer; 
+        } 
+        bitD->ptr -= nbBytes; 
+        bitD->bitsConsumed -= nbBytes*8; 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */ 
+        return result; 
+    } 
+} 
+ 
+/*! BIT_endOfDStream 
+*   @return Tells if DStream has reached its exact end 
+*/ 
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream) 
+{ 
+    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8)); 
+} 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* BITSTREAM_H_MODULE */ 
+/* ****************************************************************** 
+   Error codes and messages 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef ERROR_H_MODULE 
+#define ERROR_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/****************************************** 
+*  Compiler-specific 
+******************************************/ 
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+#  define ERR_STATIC static inline 
+#elif defined(_MSC_VER) 
+#  define ERR_STATIC static __inline 
+#elif defined(__GNUC__) 
+#  define ERR_STATIC static __attribute__((unused)) 
+#else 
+#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */ 
+#endif 
+ 
+ 
+/****************************************** 
+*  Error Management 
+******************************************/ 
+#define PREFIX(name) ZSTD_error_##name 
+ 
+#define ERROR(name) (size_t)-PREFIX(name) 
+ 
+#define ERROR_LIST(ITEM) \ 
+        ITEM(PREFIX(No_Error)) ITEM(PREFIX(GENERIC)) \ 
+        ITEM(PREFIX(dstSize_tooSmall)) ITEM(PREFIX(srcSize_wrong)) \ 
+        ITEM(PREFIX(prefix_unknown)) ITEM(PREFIX(corruption_detected)) \ 
+        ITEM(PREFIX(tableLog_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooSmall)) \ 
+        ITEM(PREFIX(maxCode)) 
+ 
+#define ERROR_GENERATE_ENUM(ENUM) ENUM, 
+typedef enum { ERROR_LIST(ERROR_GENERATE_ENUM) } ERR_codes;  /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */ 
+ 
+#define ERROR_CONVERTTOSTRING(STRING) #STRING, 
+#define ERROR_GENERATE_STRING(EXPR) ERROR_CONVERTTOSTRING(EXPR) 
+static const char* ERR_strings[] = { ERROR_LIST(ERROR_GENERATE_STRING) }; 
+ 
+ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); } 
+ 
+ERR_STATIC const char* ERR_getErrorName(size_t code) 
+{ 
+    static const char* codeError = "Unspecified error code"; 
+    if (ERR_isError(code)) return ERR_strings[-(int)(code)]; 
+    return codeError; 
+} 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* ERROR_H_MODULE */ 
+/* 
+Constructor and Destructor of type FSE_CTable 
+    Note that its size depends on 'tableLog' and 'maxSymbolValue' */ 
+typedef unsigned FSE_CTable;   /* don't allocate that. It's just a way to be more restrictive than void* */ 
+typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */ 
+ 
+ 
+/* ****************************************************************** 
+   FSE : Finite State Entropy coder 
+   header file for static linking (only) 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/****************************************** 
+*  Static allocation 
+******************************************/ 
+/* FSE buffer bounds */ 
+#define FSE_NCOUNTBOUND 512 
+#define FSE_BLOCKBOUND(size) (size + (size>>7)) 
+#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */ 
+ 
+/* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */ 
+#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2)) 
+#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog)) 
+ 
+ 
+/****************************************** 
+*  FSE advanced API 
+******************************************/ 
+static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits); 
+/* build a fake FSE_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */ 
+ 
+static size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue); 
+/* build a fake FSE_DTable, designed to always generate the same symbolValue */ 
+ 
+ 
+/****************************************** 
+*  FSE symbol decompression API 
+******************************************/ 
+typedef struct 
+{ 
+    size_t      state; 
+    const void* table;   /* precise table may vary, depending on U16 */ 
+} FSE_DState_t; 
+ 
+ 
+static void     FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt); 
+ 
+static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD); 
+ 
+static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr); 
+ 
+/* 
+Let's now decompose FSE_decompress_usingDTable() into its unitary components. 
+You will decode FSE-encoded symbols from the bitStream, 
+and also any other bitFields you put in, **in reverse order**. 
+ 
+You will need a few variables to track your bitStream. They are : 
+ 
+BIT_DStream_t DStream;    // Stream context 
+FSE_DState_t  DState;     // State context. Multiple ones are possible 
+FSE_DTable*   DTablePtr;  // Decoding table, provided by FSE_buildDTable() 
+ 
+The first thing to do is to init the bitStream. 
+    errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize); 
+ 
+You should then retrieve your initial state(s) 
+(in reverse flushing order if you have several ones) : 
+    errorCode = FSE_initDState(&DState, &DStream, DTablePtr); 
+ 
+You can then decode your data, symbol after symbol. 
+For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'. 
+Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out). 
+    unsigned char symbol = FSE_decodeSymbol(&DState, &DStream); 
+ 
+You can retrieve any bitfield you eventually stored into the bitStream (in reverse order) 
+Note : maximum allowed nbBits is 25, for 32-bits compatibility 
+    size_t bitField = BIT_readBits(&DStream, nbBits); 
+ 
+All above operations only read from local register (which size depends on size_t). 
+Refueling the register from memory is manually performed by the reload method. 
+    endSignal = FSE_reloadDStream(&DStream); 
+ 
+BIT_reloadDStream() result tells if there is still some more data to read from DStream. 
+BIT_DStream_unfinished : there is still some data left into the DStream. 
+BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled. 
+BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed. 
+BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted. 
+ 
+When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop, 
+to properly detect the exact end of stream. 
+After each decoded symbol, check if DStream is fully consumed using this simple test : 
+    BIT_reloadDStream(&DStream) >= BIT_DStream_completed 
+ 
+When it's done, verify decompression is fully completed, by checking both DStream and the relevant states. 
+Checking if DStream has reached its end is performed by : 
+    BIT_endOfDStream(&DStream); 
+Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible. 
+    FSE_endOfDState(&DState); 
+*/ 
+ 
+ 
+/****************************************** 
+*  FSE unsafe API 
+******************************************/ 
+static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD); 
+/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */ 
+ 
+ 
+/****************************************** 
+*  Implementation of inline functions 
+******************************************/ 
+ 
+/* decompression */ 
+ 
+typedef struct { 
+    U16 tableLog; 
+    U16 fastMode; 
+} FSE_DTableHeader;   /* sizeof U32 */ 
+ 
+typedef struct 
+{ 
+    unsigned short newState; 
+    unsigned char  symbol; 
+    unsigned char  nbBits; 
+} FSE_decode_t;   /* size == U32 */ 
+ 
+MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt) 
+{ 
+    FSE_DTableHeader DTableH; 
+    memcpy(&DTableH, dt, sizeof(DTableH)); 
+    DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog); 
+    BIT_reloadDStream(bitD); 
+    DStatePtr->table = dt + 1; 
+} 
+ 
+MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) 
+{ 
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    const U32  nbBits = DInfo.nbBits; 
+    BYTE symbol = DInfo.symbol; 
+    size_t lowBits = BIT_readBits(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) 
+{ 
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    const U32 nbBits = DInfo.nbBits; 
+    BYTE symbol = DInfo.symbol; 
+    size_t lowBits = BIT_readBitsFast(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr) 
+{ 
+    return DStatePtr->state == 0; 
+} 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+/* ****************************************************************** 
+   Huff0 : Huffman coder, part of New Generation Entropy library 
+   header file for static linking (only) 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/****************************************** 
+*  Static allocation macros 
+******************************************/ 
+/* Huff0 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 Huff0's DTable */ 
+#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog))  /* nb Cells; use unsigned short for X2, unsigned int for X4 */ 
+#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 functions 
+******************************************/ 
+static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */ 
+static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+/* 
+    zstd - standard compression library 
+    Header File 
+    Copyright (C) 2014-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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/* ************************************* 
+*  Includes 
+***************************************/ 
+#include <stddef.h>   /* size_t */ 
+ 
+ 
+/* ************************************* 
+*  Version 
+***************************************/ 
+#define ZSTD_VERSION_MAJOR    0    /* for breaking interface changes  */ 
+#define ZSTD_VERSION_MINOR    2    /* for new (non-breaking) interface capabilities */ 
+#define ZSTD_VERSION_RELEASE  2    /* for tweaks, bug-fixes, or development */ 
+#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE) 
+ 
+ 
+/* ************************************* 
+*  Advanced functions 
+***************************************/ 
+typedef struct ZSTD_CCtx_s ZSTD_CCtx;   /* incomplete type */ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+/* 
+    zstd - standard compression library 
+    Header File for static linking only 
+    Copyright (C) 2014-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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+ 
+/* The objects defined into this file should be considered experimental. 
+ * They are not labelled stable, as their prototype may change in the future. 
+ * You can use them for tests, provide feedback, or if you can endure risk of future changes. 
+ */ 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/* ************************************* 
+*  Streaming functions 
+***************************************/ 
+ 
+typedef struct ZSTD_DCtx_s ZSTD_DCtx; 
+ 
+/* 
+  Use above functions alternatively. 
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue(). 
+  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block. 
+  Result is the number of bytes regenerated within 'dst'. 
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header. 
+*/ 
+ 
+/* ************************************* 
+*  Prefix - version detection 
+***************************************/ 
+#define ZSTD_magicNumber 0xFD2FB523   /* v0.3 */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+/* ****************************************************************** 
+   FSE : Finite State Entropy coder 
+   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 
+****************************************************************** */ 
+ 
+#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 
+ 
+ 
+/**************************************************************** 
+*  Byte symbol type 
+****************************************************************/ 
+#endif   /* !FSE_COMMONDEFS_ONLY */ 
+ 
+ 
+/**************************************************************** 
+*  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) */ 
+ 
+/**************************************************************** 
+*  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 
+ 
+ 
+/**************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#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 */ 
+ 
 #define FSE_DECODE_TYPE FSE_decode_t
-
-static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }
-
+ 
+static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; } 
+ 
 static size_t FSE_buildDTable
-(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
-{
-    void* ptr = dt+1;
-    FSE_DTableHeader DTableH;
-    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)ptr;
-    const U32 tableSize = 1 << tableLog;
-    const U32 tableMask = tableSize-1;
-    const U32 step = FSE_tableStep(tableSize);
-    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];
-    U32 position = 0;
-    U32 highThreshold = tableSize-1;
-    const S16 largeLimit= (S16)(1 << (tableLog-1));
-    U32 noLarge = 1;
-    U32 s;
-
-    /* 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 */
-    DTableH.tableLog = (U16)tableLog;
-    for (s=0; s<=maxSymbolValue; s++)
-    {
-        if (normalizedCounter[s]==-1)
-        {
-            tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;
-            symbolNext[s] = 1;
-        }
-        else
-        {
-            if (normalizedCounter[s] >= largeLimit) noLarge=0;
-            symbolNext[s] = normalizedCounter[s];
-        }
-    }
-
-    /* Spread symbols */
-    for (s=0; s<=maxSymbolValue; 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 i;
-        for (i=0; i<tableSize; i++)
-        {
-            FSE_FUNCTION_TYPE symbol = (FSE_FUNCTION_TYPE)(tableDecode[i].symbol);
-            U16 nextState = symbolNext[symbol]++;
-            tableDecode[i].nbBits = (BYTE) (tableLog - BIT_highbit32 ((U32)nextState) );
-            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize);
-        }
-    }
-
-    DTableH.fastMode = (U16)noLarge;
-    memcpy(dt, &DTableH, sizeof(DTableH));
-    return 0;
-}
-
-
-#ifndef FSE_COMMONDEFS_ONLY
-/******************************************
-*  FSE helper functions
-******************************************/
-static unsigned FSE_isError(size_t code) { return ERR_isError(code); }
-
-
-/****************************************************************
-*  FSE NCount encoding-decoding
-****************************************************************/
-static short FSE_abs(short a)
-{
-    return a<0 ? -a : a;
-}
-
-static 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;
-        }
-        {
-            const short 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);
-            }
-        }
-    }
-    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;
-}
-
-
-/*********************************************************
-*  Decompression (Byte symbols)
-*********************************************************/
-static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
-{
-    void* ptr = dt;
-    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
-    FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1;
-
-    DTableH->tableLog = 0;
-    DTableH->fastMode = 0;
-
-    cell->newState = 0;
-    cell->symbol = symbolValue;
-    cell->nbBits = 0;
-
-    return 0;
-}
-
-
-static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
-{
-    void* ptr = dt;
-    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
-    FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1;
-    const unsigned tableSize = 1 << nbBits;
-    const unsigned tableMask = tableSize - 1;
-    const unsigned maxSymbolValue = tableMask;
-    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<=maxSymbolValue; 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;
-    size_t errorCode;
-
-    /* Init */
-    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 ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) )
-            break;
-
-        *op++ = FSE_GETSYMBOL(&state1);
-
-        if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) )
-            break;
-
-        *op++ = FSE_GETSYMBOL(&state2);
-    }
-
-    /* end ? */
-    if (BIT_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2))
-        return op-ostart;
-
-    if (op==omax) return ERROR(dstSize_tooSmall);   /* dst buffer is full, but cSrc unfinished */
-
-    return ERROR(corruption_detected);
-}
-
-
-static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
-                            const void* cSrc, size_t cSrcSize,
-                            const FSE_DTable* dt)
-{
-    FSE_DTableHeader DTableH;
-    memcpy(&DTableH, dt, sizeof(DTableH));
-
-    /* select fast mode (static) */
-    if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
-    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
-}
-
-
-static 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;
-    size_t errorCode;
-
-    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */
-
-    /* normal FSE decoding mode */
-    errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
-    if (FSE_isError(errorCode)) return errorCode;
-    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */
-    ip += errorCode;
-    cSrcSize -= errorCode;
-
-    errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);
-    if (FSE_isError(errorCode)) return errorCode;
-
-    /* always return, even if it is an error code */
-    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);
-}
-
-
-
-#endif   /* FSE_COMMONDEFS_ONLY */
-/* ******************************************************************
-   Huff0 : Huffman coder, part of New Generation Entropy library
-   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+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy
-    - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-
-/****************************************************************
-*  Compiler specifics
-****************************************************************/
-#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-/* inline is defined */
-#elif defined(_MSC_VER)
-#  define inline __inline
-#else
-#  define inline /* disable inline */
-#endif
-
-
-#ifdef _MSC_VER    /* Visual Studio */
-#  define FORCE_INLINE static __forceinline
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#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) */
-
-/****************************************************************
-*  Error Management
-****************************************************************/
-#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-
-
-/******************************************
-*  Helper functions
-******************************************/
-static unsigned HUF_isError(size_t code) { return ERR_isError(code); }
-
-#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
-
-
-
-/*********************************************************
-*  Huff0 : Huffman block decompression
-*********************************************************/
-typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2;   /* single-symbol decoding */
-
-typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4;  /* double-symbols decoding */
-
-typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
-
-/*! HUF_readStats
-    Read compact Huffman tree, saved by HUF_writeCTable
-    @huffWeight : destination buffer
-    @return : size read from `src`
-*/
-static size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                            U32* nbSymbolsPtr, U32* tableLogPtr,
-                            const void* src, size_t srcSize)
-{
-    U32 weightTotal;
-    U32 tableLog;
-    const BYTE* ip = (const BYTE*) src;
-    size_t iSize = ip[0];
-    size_t oSize;
-    U32 n;
-
-    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */
-
-    if (iSize >= 128)  /* special header */
-    {
-        if (iSize >= (242))   /* RLE */
-        {
-            static int 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;
-            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;
-    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) */
-    tableLog = BIT_highbit32(weightTotal) + 1;
-    if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
-    {
-        U32 total = 1 << tableLog;
-        U32 rest = total - weightTotal;
-        U32 verif = 1 << BIT_highbit32(rest);
-        U32 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);
-    *tableLogPtr = tableLog;
-    return iSize+1;
-}
-
-
-/**************************/
-/* single-symbol decoding */
-/**************************/
-
-static size_t HUF_readDTableX2 (U16* DTable, const void* src, size_t srcSize)
-{
-    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1];
-    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];   /* large enough for values from 0 to 16 */
-    U32 tableLog = 0;
-    const BYTE* ip = (const BYTE*) src;
-    size_t iSize = ip[0];
-    U32 nbSymbols = 0;
-    U32 n;
-    U32 nextRankStart;
-    void* ptr = DTable+1;
-    HUF_DEltX2* const dt = (HUF_DEltX2*)(ptr);
-
-    HUF_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */
-    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
-    if (HUF_isError(iSize)) return iSize;
-
-    /* check result */
-    if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge);   /* DTable is too small */
-    DTable[0] = (U16)tableLog;   /* maybe should separate sizeof DTable, as allocated, from used size of DTable, in case of DTable re-use */
-
-    /* Prepare ranks */
-    nextRankStart = 0;
-    for (n=1; n<=tableLog; n++)
-    {
-        U32 current = nextRankStart;
-        nextRankStart += (rankVal[n] << (n-1));
-        rankVal[n] = current;
-    }
-
-    /* fill DTable */
-    for (n=0; n<nbSymbols; n++)
-    {
-        const U32 w = huffWeight[n];
-        const U32 length = (1 << w) >> 1;
-        U32 i;
-        HUF_DEltX2 D;
-        D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);
-        for (i = rankVal[w]; i < rankVal[w] + length; i++)
-            dt[i] = D;
-        rankVal[w] += length;
-    }
-
-    return iSize;
-}
-
-static BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog)
-{
-        const size_t val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
-        const BYTE c = dt[val].byte;
-        BIT_skipBits(Dstream, dt[val].nbBits);
-        return c;
-}
-
-#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
-    *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog)
-
-#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
-    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
-        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
-
-#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
-    if (MEM_64bits()) \
-        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
-
-static inline size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 4 symbols at a time */
-    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4))
-    {
-        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
-        HUF_DECODE_SYMBOLX2_1(p, bitDPtr);
-        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
-        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-    }
-
-    /* closer to the end */
-    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd))
-        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-
-    /* no more data to retrieve from bitstream, hence no need to reload */
-    while (p < pEnd)
-        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-
-    return pEnd-pStart;
-}
-
-
-static size_t HUF_decompress4X2_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const U16* DTable)
-{
-    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
-
-    {
-        const BYTE* const istart = (const BYTE*) cSrc;
-        BYTE* const ostart = (BYTE*) dst;
-        BYTE* const oend = ostart + dstSize;
-
-        const void* ptr = DTable;
-        const HUF_DEltX2* const dt = ((const HUF_DEltX2*)ptr) +1;
-        const U32 dtLog = DTable[0];
-        size_t errorCode;
-
-        /* Init */
-        BIT_DStream_t bitD1;
-        BIT_DStream_t bitD2;
-        BIT_DStream_t bitD3;
-        BIT_DStream_t bitD4;
-        const size_t length1 = MEM_readLE16(istart);
-        const size_t length2 = MEM_readLE16(istart+2);
-        const size_t length3 = MEM_readLE16(istart+4);
-        size_t length4;
-        const BYTE* const istart1 = istart + 6;  /* jumpTable */
-        const BYTE* const istart2 = istart1 + length1;
-        const BYTE* const istart3 = istart2 + length2;
-        const BYTE* const istart4 = istart3 + length3;
-        const size_t segmentSize = (dstSize+3) / 4;
-        BYTE* const opStart2 = ostart + segmentSize;
-        BYTE* const opStart3 = opStart2 + segmentSize;
-        BYTE* const opStart4 = opStart3 + segmentSize;
-        BYTE* op1 = ostart;
-        BYTE* op2 = opStart2;
-        BYTE* op3 = opStart3;
-        BYTE* op4 = opStart4;
-        U32 endSignal;
-
-        length4 = cSrcSize - (length1 + length2 + length3 + 6);
-        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
-        errorCode = BIT_initDStream(&bitD1, istart1, length1);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD2, istart2, length2);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD3, istart3, length3);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD4, istart4, length4);
-        if (HUF_isError(errorCode)) return errorCode;
-
-        /* 16-32 symbols per loop (4-8 symbols per stream) */
-        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
-        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )
-        {
-            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
-            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
-            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
-            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
-            HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
-            HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
-            HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
-            HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
-            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
-            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
-            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
-            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
-            HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
-            HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
-            HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
-            HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
-
-            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
-        }
-
-        /* check corruption */
-        if (op1 > opStart2) return ERROR(corruption_detected);
-        if (op2 > opStart3) return ERROR(corruption_detected);
-        if (op3 > opStart4) return ERROR(corruption_detected);
-        /* note : op4 supposed already verified within main loop */
-
-        /* finish bitStreams one by one */
-        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
-        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
-        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
-        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
-
-        /* check */
-        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
-        if (!endSignal) return ERROR(corruption_detected);
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
-
-static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-    size_t errorCode;
-
-    errorCode = HUF_readDTableX2 (DTable, cSrc, cSrcSize);
-    if (HUF_isError(errorCode)) return errorCode;
-    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += errorCode;
-    cSrcSize -= errorCode;
-
-    return HUF_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
-}
-
-
-/***************************/
-/* double-symbols decoding */
-/***************************/
-
-static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed,
-                           const U32* rankValOrigin, const int minWeight,
-                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
-                           U32 nbBitsBaseline, U16 baseSeq)
-{
-    HUF_DEltX4 DElt;
-    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];
-    U32 s;
-
-    /* get pre-calculated rankVal */
-    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
-
-    /* fill skipped values */
-    if (minWeight>1)
-    {
-        U32 i, skipSize = rankVal[minWeight];
-        MEM_writeLE16(&(DElt.sequence), baseSeq);
-        DElt.nbBits   = (BYTE)(consumed);
-        DElt.length   = 1;
-        for (i = 0; i < skipSize; i++)
-            DTable[i] = DElt;
-    }
-
-    /* fill DTable */
-    for (s=0; s<sortedListSize; s++)   /* note : sortedSymbols already skipped */
-    {
-        const U32 symbol = sortedSymbols[s].symbol;
-        const U32 weight = sortedSymbols[s].weight;
-        const U32 nbBits = nbBitsBaseline - weight;
-        const U32 length = 1 << (sizeLog-nbBits);
-        const U32 start = rankVal[weight];
-        U32 i = start;
-        const U32 end = start + length;
-
-        MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
-        DElt.nbBits = (BYTE)(nbBits + consumed);
-        DElt.length = 2;
-        do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */
-
-        rankVal[weight] += length;
-    }
-}
-
-typedef U32 rankVal_t[HUF_ABSOLUTEMAX_TABLELOG][HUF_ABSOLUTEMAX_TABLELOG + 1];
-
-static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog,
-                           const sortedSymbol_t* sortedList, const U32 sortedListSize,
-                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
-                           const U32 nbBitsBaseline)
-{
-    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];
-    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */
-    const U32 minBits  = nbBitsBaseline - maxWeight;
-    U32 s;
-
-    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
-
-    /* fill DTable */
-    for (s=0; s<sortedListSize; s++)
-    {
-        const U16 symbol = sortedList[s].symbol;
-        const U32 weight = sortedList[s].weight;
-        const U32 nbBits = nbBitsBaseline - weight;
-        const U32 start = rankVal[weight];
-        const U32 length = 1 << (targetLog-nbBits);
-
-        if (targetLog-nbBits >= minBits)   /* enough room for a second symbol */
-        {
-            U32 sortedRank;
-            int minWeight = nbBits + scaleLog;
-            if (minWeight < 1) minWeight = 1;
-            sortedRank = rankStart[minWeight];
-            HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,
-                           rankValOrigin[nbBits], minWeight,
-                           sortedList+sortedRank, sortedListSize-sortedRank,
-                           nbBitsBaseline, symbol);
-        }
-        else
-        {
-            U32 i;
-            const U32 end = start + length;
-            HUF_DEltX4 DElt;
-
-            MEM_writeLE16(&(DElt.sequence), symbol);
-            DElt.nbBits   = (BYTE)(nbBits);
-            DElt.length   = 1;
-            for (i = start; i < end; i++)
-                DTable[i] = DElt;
-        }
-        rankVal[weight] += length;
-    }
-}
-
-static size_t HUF_readDTableX4 (U32* DTable, const void* src, size_t srcSize)
-{
-    BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1];
-    sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1];
-    U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 };
-    U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 };
-    U32* const rankStart = rankStart0+1;
-    rankVal_t rankVal;
-    U32 tableLog, maxW, sizeOfSort, nbSymbols;
-    const U32 memLog = DTable[0];
-    const BYTE* ip = (const BYTE*) src;
-    size_t iSize = ip[0];
-    void* ptr = DTable;
-    HUF_DEltX4* const dt = ((HUF_DEltX4*)ptr) + 1;
-
-    HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */
-    if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);
-    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
-    if (HUF_isError(iSize)) return iSize;
-
-    /* check result */
-    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
-
-    /* find maxWeight */
-    for (maxW = tableLog; rankStats[maxW]==0; maxW--)
-        { if (!maxW) return ERROR(GENERIC); }  /* necessarily finds a solution before maxW==0 */
-
-    /* Get start index of each weight */
-    {
-        U32 w, nextRankStart = 0;
-        for (w=1; w<=maxW; w++)
-        {
-            U32 current = nextRankStart;
-            nextRankStart += rankStats[w];
-            rankStart[w] = current;
-        }
-        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
-        sizeOfSort = nextRankStart;
-    }
-
-    /* sort symbols by weight */
-    {
-        U32 s;
-        for (s=0; s<nbSymbols; s++)
-        {
-            U32 w = weightList[s];
-            U32 r = rankStart[w]++;
-            sortedSymbol[r].symbol = (BYTE)s;
-            sortedSymbol[r].weight = (BYTE)w;
-        }
-        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
-    }
-
-	/* Build rankVal */
-    {
-        const U32 minBits = tableLog+1 - maxW;
-        U32 nextRankVal = 0;
-        U32 w, consumed;
-        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */
-        U32* rankVal0 = rankVal[0];
-        for (w=1; w<=maxW; w++)
-        {
-            U32 current = nextRankVal;
-            nextRankVal += rankStats[w] << (w+rescale);
-            rankVal0[w] = current;
-        }
-        for (consumed = minBits; consumed <= memLog - minBits; consumed++)
-        {
-            U32* rankValPtr = rankVal[consumed];
-            for (w = 1; w <= maxW; w++)
-            {
-                rankValPtr[w] = rankVal0[w] >> consumed;
-            }
-        }
-    }
-
-    HUF_fillDTableX4(dt, memLog,
-                   sortedSymbol, sizeOfSort,
-                   rankStart0, rankVal, maxW,
-                   tableLog+1);
-
-    return iSize;
-}
-
-
-static U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)
-{
-    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    memcpy(op, dt+val, 2);
-    BIT_skipBits(DStream, dt[val].nbBits);
-    return dt[val].length;
-}
-
-static U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)
-{
-    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    memcpy(op, dt+val, 1);
-    if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);
-    else
-    {
-        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8))
-        {
-            BIT_skipBits(DStream, dt[val].nbBits);
-            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
-                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
-        }
-    }
-    return 1;
-}
-
-
-#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \
-    ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-#define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \
-    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
-        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-#define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \
-    if (MEM_64bits()) \
-        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-static inline size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 8 symbols at a time */
-    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd-7))
-    {
-        HUF_DECODE_SYMBOLX4_2(p, bitDPtr);
-        HUF_DECODE_SYMBOLX4_1(p, bitDPtr);
-        HUF_DECODE_SYMBOLX4_2(p, bitDPtr);
-        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);
-    }
-
-    /* closer to the end */
-    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-2))
-        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);
-
-    while (p <= pEnd-2)
-        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
-
-    if (p < pEnd)
-        p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);
-
-    return p-pStart;
-}
-
-
-
-static size_t HUF_decompress4X4_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const U32* DTable)
-{
-    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
-
-    {
-        const BYTE* const istart = (const BYTE*) cSrc;
-        BYTE* const ostart = (BYTE*) dst;
-        BYTE* const oend = ostart + dstSize;
-
-        const void* ptr = DTable;
-        const HUF_DEltX4* const dt = ((const HUF_DEltX4*)ptr) +1;
-        const U32 dtLog = DTable[0];
-        size_t errorCode;
-
-        /* Init */
-        BIT_DStream_t bitD1;
-        BIT_DStream_t bitD2;
-        BIT_DStream_t bitD3;
-        BIT_DStream_t bitD4;
-        const size_t length1 = MEM_readLE16(istart);
-        const size_t length2 = MEM_readLE16(istart+2);
-        const size_t length3 = MEM_readLE16(istart+4);
-        size_t length4;
-        const BYTE* const istart1 = istart + 6;  /* jumpTable */
-        const BYTE* const istart2 = istart1 + length1;
-        const BYTE* const istart3 = istart2 + length2;
-        const BYTE* const istart4 = istart3 + length3;
-        const size_t segmentSize = (dstSize+3) / 4;
-        BYTE* const opStart2 = ostart + segmentSize;
-        BYTE* const opStart3 = opStart2 + segmentSize;
-        BYTE* const opStart4 = opStart3 + segmentSize;
-        BYTE* op1 = ostart;
-        BYTE* op2 = opStart2;
-        BYTE* op3 = opStart3;
-        BYTE* op4 = opStart4;
-        U32 endSignal;
-
-        length4 = cSrcSize - (length1 + length2 + length3 + 6);
-        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
-        errorCode = BIT_initDStream(&bitD1, istart1, length1);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD2, istart2, length2);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD3, istart3, length3);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD4, istart4, length4);
-        if (HUF_isError(errorCode)) return errorCode;
-
-        /* 16-32 symbols per loop (4-8 symbols per stream) */
-        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
-        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )
-        {
-            HUF_DECODE_SYMBOLX4_2(op1, &bitD1);
-            HUF_DECODE_SYMBOLX4_2(op2, &bitD2);
-            HUF_DECODE_SYMBOLX4_2(op3, &bitD3);
-            HUF_DECODE_SYMBOLX4_2(op4, &bitD4);
-            HUF_DECODE_SYMBOLX4_1(op1, &bitD1);
-            HUF_DECODE_SYMBOLX4_1(op2, &bitD2);
-            HUF_DECODE_SYMBOLX4_1(op3, &bitD3);
-            HUF_DECODE_SYMBOLX4_1(op4, &bitD4);
-            HUF_DECODE_SYMBOLX4_2(op1, &bitD1);
-            HUF_DECODE_SYMBOLX4_2(op2, &bitD2);
-            HUF_DECODE_SYMBOLX4_2(op3, &bitD3);
-            HUF_DECODE_SYMBOLX4_2(op4, &bitD4);
-            HUF_DECODE_SYMBOLX4_0(op1, &bitD1);
-            HUF_DECODE_SYMBOLX4_0(op2, &bitD2);
-            HUF_DECODE_SYMBOLX4_0(op3, &bitD3);
-            HUF_DECODE_SYMBOLX4_0(op4, &bitD4);
-
-            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
-        }
-
-        /* check corruption */
-        if (op1 > opStart2) return ERROR(corruption_detected);
-        if (op2 > opStart3) return ERROR(corruption_detected);
-        if (op3 > opStart4) return ERROR(corruption_detected);
-        /* note : op4 supposed already verified within main loop */
-
-        /* finish bitStreams one by one */
-        HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);
-        HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);
-        HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);
-        HUF_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog);
-
-        /* check */
-        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
-        if (!endSignal) return ERROR(corruption_detected);
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
-
-static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t hSize = HUF_readDTableX4 (DTable, cSrc, cSrcSize);
-    if (HUF_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize;
-    cSrcSize -= hSize;
-
-    return HUF_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
-}
-
-
-/**********************************/
-/* Generic decompression selector */
-/**********************************/
-
-typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
-static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] =
-{
-    /* single, double, quad */
-    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */
-    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */
-    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */
-    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */
-    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */
-    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */
-    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */
-    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */
-    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */
-    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */
-    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */
-    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */
-    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */
-    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */
-    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */
-    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */
-};
-
-typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
-
-static size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
+(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) 
+{ 
+    void* ptr = dt+1; 
+    FSE_DTableHeader DTableH; 
+    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)ptr; 
+    const U32 tableSize = 1 << tableLog; 
+    const U32 tableMask = tableSize-1; 
+    const U32 step = FSE_tableStep(tableSize); 
+    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1]; 
+    U32 position = 0; 
+    U32 highThreshold = tableSize-1; 
+    const S16 largeLimit= (S16)(1 << (tableLog-1)); 
+    U32 noLarge = 1; 
+    U32 s; 
+ 
+    /* 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 */ 
+    DTableH.tableLog = (U16)tableLog; 
+    for (s=0; s<=maxSymbolValue; s++) 
+    { 
+        if (normalizedCounter[s]==-1) 
+        { 
+            tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s; 
+            symbolNext[s] = 1; 
+        } 
+        else 
+        { 
+            if (normalizedCounter[s] >= largeLimit) noLarge=0; 
+            symbolNext[s] = normalizedCounter[s]; 
+        } 
+    } 
+ 
+    /* Spread symbols */ 
+    for (s=0; s<=maxSymbolValue; 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 i; 
+        for (i=0; i<tableSize; i++) 
+        { 
+            FSE_FUNCTION_TYPE symbol = (FSE_FUNCTION_TYPE)(tableDecode[i].symbol); 
+            U16 nextState = symbolNext[symbol]++; 
+            tableDecode[i].nbBits = (BYTE) (tableLog - BIT_highbit32 ((U32)nextState) ); 
+            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize); 
+        } 
+    } 
+ 
+    DTableH.fastMode = (U16)noLarge; 
+    memcpy(dt, &DTableH, sizeof(DTableH)); 
+    return 0; 
+} 
+ 
+ 
+#ifndef FSE_COMMONDEFS_ONLY 
+/****************************************** 
+*  FSE helper functions 
+******************************************/ 
+static unsigned FSE_isError(size_t code) { return ERR_isError(code); } 
+ 
+ 
+/**************************************************************** 
+*  FSE NCount encoding-decoding 
+****************************************************************/ 
+static short FSE_abs(short a) 
+{ 
+    return a<0 ? -a : a; 
+} 
+ 
+static 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; 
+        } 
+        { 
+            const short 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); 
+            } 
+        } 
+    } 
+    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; 
+} 
+ 
+ 
+/********************************************************* 
+*  Decompression (Byte symbols) 
+*********************************************************/ 
+static size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue) 
+{ 
+    void* ptr = dt; 
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; 
+    FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1; 
+ 
+    DTableH->tableLog = 0; 
+    DTableH->fastMode = 0; 
+ 
+    cell->newState = 0; 
+    cell->symbol = symbolValue; 
+    cell->nbBits = 0; 
+ 
+    return 0; 
+} 
+ 
+ 
+static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits) 
+{ 
+    void* ptr = dt; 
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; 
+    FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1; 
+    const unsigned tableSize = 1 << nbBits; 
+    const unsigned tableMask = tableSize - 1; 
+    const unsigned maxSymbolValue = tableMask; 
+    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<=maxSymbolValue; 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; 
+    size_t errorCode; 
+ 
+    /* Init */ 
+    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 ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) ) 
+            break; 
+ 
+        *op++ = FSE_GETSYMBOL(&state1); 
+ 
+        if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) ) 
+            break; 
+ 
+        *op++ = FSE_GETSYMBOL(&state2); 
+    } 
+ 
+    /* end ? */ 
+    if (BIT_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2)) 
+        return op-ostart; 
+ 
+    if (op==omax) return ERROR(dstSize_tooSmall);   /* dst buffer is full, but cSrc unfinished */ 
+ 
+    return ERROR(corruption_detected); 
+} 
+ 
+ 
+static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize, 
+                            const void* cSrc, size_t cSrcSize, 
+                            const FSE_DTable* dt) 
+{ 
+    FSE_DTableHeader DTableH; 
+    memcpy(&DTableH, dt, sizeof(DTableH)); 
+ 
+    /* select fast mode (static) */ 
+    if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1); 
+    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0); 
+} 
+ 
+ 
+static 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; 
+    size_t errorCode; 
+ 
+    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */ 
+ 
+    /* normal FSE decoding mode */ 
+    errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize); 
+    if (FSE_isError(errorCode)) return errorCode; 
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */ 
+    ip += errorCode; 
+    cSrcSize -= errorCode; 
+ 
+    errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog); 
+    if (FSE_isError(errorCode)) return errorCode; 
+ 
+    /* always return, even if it is an error code */ 
+    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt); 
+} 
+ 
+ 
+ 
+#endif   /* FSE_COMMONDEFS_ONLY */ 
+/* ****************************************************************** 
+   Huff0 : Huffman coder, part of New Generation Entropy library 
+   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+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+ 
+/**************************************************************** 
+*  Compiler specifics 
+****************************************************************/ 
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+/* inline is defined */ 
+#elif defined(_MSC_VER) 
+#  define inline __inline 
+#else 
+#  define inline /* disable inline */ 
+#endif 
+ 
+ 
+#ifdef _MSC_VER    /* Visual Studio */ 
+#  define FORCE_INLINE static __forceinline 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#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) */ 
+ 
+/**************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */ 
+ 
+ 
+/****************************************** 
+*  Helper functions 
+******************************************/ 
+static unsigned HUF_isError(size_t code) { return ERR_isError(code); } 
+ 
+#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 
+ 
+ 
+ 
+/********************************************************* 
+*  Huff0 : Huffman block decompression 
+*********************************************************/ 
+typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2;   /* single-symbol decoding */ 
+ 
+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4;  /* double-symbols decoding */ 
+ 
+typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t; 
+ 
+/*! HUF_readStats 
+    Read compact Huffman tree, saved by HUF_writeCTable 
+    @huffWeight : destination buffer 
+    @return : size read from `src` 
+*/ 
+static size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats, 
+                            U32* nbSymbolsPtr, U32* tableLogPtr, 
+                            const void* src, size_t srcSize) 
+{ 
+    U32 weightTotal; 
+    U32 tableLog; 
+    const BYTE* ip = (const BYTE*) src; 
+    size_t iSize = ip[0]; 
+    size_t oSize; 
+    U32 n; 
+ 
+    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    if (iSize >= 128)  /* special header */ 
+    { 
+        if (iSize >= (242))   /* RLE */ 
+        { 
+            static int 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; 
+            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; 
+    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) */ 
+    tableLog = BIT_highbit32(weightTotal) + 1; 
+    if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected); 
+    { 
+        U32 total = 1 << tableLog; 
+        U32 rest = total - weightTotal; 
+        U32 verif = 1 << BIT_highbit32(rest); 
+        U32 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); 
+    *tableLogPtr = tableLog; 
+    return iSize+1; 
+} 
+ 
+ 
+/**************************/ 
+/* single-symbol decoding */ 
+/**************************/ 
+ 
+static size_t HUF_readDTableX2 (U16* DTable, const void* src, size_t srcSize) 
+{ 
+    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1]; 
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];   /* large enough for values from 0 to 16 */ 
+    U32 tableLog = 0; 
+    const BYTE* ip = (const BYTE*) src; 
+    size_t iSize = ip[0]; 
+    U32 nbSymbols = 0; 
+    U32 n; 
+    U32 nextRankStart; 
+    void* ptr = DTable+1; 
+    HUF_DEltX2* const dt = (HUF_DEltX2*)(ptr); 
+ 
+    HUF_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */ 
+    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    iSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize); 
+    if (HUF_isError(iSize)) return iSize; 
+ 
+    /* check result */ 
+    if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge);   /* DTable is too small */ 
+    DTable[0] = (U16)tableLog;   /* maybe should separate sizeof DTable, as allocated, from used size of DTable, in case of DTable re-use */ 
+ 
+    /* Prepare ranks */ 
+    nextRankStart = 0; 
+    for (n=1; n<=tableLog; n++) 
+    { 
+        U32 current = nextRankStart; 
+        nextRankStart += (rankVal[n] << (n-1)); 
+        rankVal[n] = current; 
+    } 
+ 
+    /* fill DTable */ 
+    for (n=0; n<nbSymbols; n++) 
+    { 
+        const U32 w = huffWeight[n]; 
+        const U32 length = (1 << w) >> 1; 
+        U32 i; 
+        HUF_DEltX2 D; 
+        D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w); 
+        for (i = rankVal[w]; i < rankVal[w] + length; i++) 
+            dt[i] = D; 
+        rankVal[w] += length; 
+    } 
+ 
+    return iSize; 
+} 
+ 
+static BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog) 
+{ 
+        const size_t val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */ 
+        const BYTE c = dt[val].byte; 
+        BIT_skipBits(Dstream, dt[val].nbBits); 
+        return c; 
+} 
+ 
+#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \ 
+    *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog) 
+ 
+#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \ 
+    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \ 
+        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) 
+ 
+#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \ 
+    if (MEM_64bits()) \ 
+        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) 
+ 
+static inline size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog) 
+{ 
+    BYTE* const pStart = p; 
+ 
+    /* up to 4 symbols at a time */ 
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4)) 
+    { 
+        HUF_DECODE_SYMBOLX2_2(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX2_1(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX2_2(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr); 
+    } 
+ 
+    /* closer to the end */ 
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd)) 
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr); 
+ 
+    /* no more data to retrieve from bitstream, hence no need to reload */ 
+    while (p < pEnd) 
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr); 
+ 
+    return pEnd-pStart; 
+} 
+ 
+ 
+static size_t HUF_decompress4X2_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const U16* DTable) 
+{ 
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */ 
+ 
+    { 
+        const BYTE* const istart = (const BYTE*) cSrc; 
+        BYTE* const ostart = (BYTE*) dst; 
+        BYTE* const oend = ostart + dstSize; 
+ 
+        const void* ptr = DTable; 
+        const HUF_DEltX2* const dt = ((const HUF_DEltX2*)ptr) +1; 
+        const U32 dtLog = DTable[0]; 
+        size_t errorCode; 
+ 
+        /* Init */ 
+        BIT_DStream_t bitD1; 
+        BIT_DStream_t bitD2; 
+        BIT_DStream_t bitD3; 
+        BIT_DStream_t bitD4; 
+        const size_t length1 = MEM_readLE16(istart); 
+        const size_t length2 = MEM_readLE16(istart+2); 
+        const size_t length3 = MEM_readLE16(istart+4); 
+        size_t length4; 
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */ 
+        const BYTE* const istart2 = istart1 + length1; 
+        const BYTE* const istart3 = istart2 + length2; 
+        const BYTE* const istart4 = istart3 + length3; 
+        const size_t segmentSize = (dstSize+3) / 4; 
+        BYTE* const opStart2 = ostart + segmentSize; 
+        BYTE* const opStart3 = opStart2 + segmentSize; 
+        BYTE* const opStart4 = opStart3 + segmentSize; 
+        BYTE* op1 = ostart; 
+        BYTE* op2 = opStart2; 
+        BYTE* op3 = opStart3; 
+        BYTE* op4 = opStart4; 
+        U32 endSignal; 
+ 
+        length4 = cSrcSize - (length1 + length2 + length3 + 6); 
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */ 
+        errorCode = BIT_initDStream(&bitD1, istart1, length1); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD2, istart2, length2); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD3, istart3, length3); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD4, istart4, length4); 
+        if (HUF_isError(errorCode)) return errorCode; 
+ 
+        /* 16-32 symbols per loop (4-8 symbols per stream) */ 
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); 
+        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; ) 
+        { 
+            HUF_DECODE_SYMBOLX2_2(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX2_2(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX2_2(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX2_2(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX2_1(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX2_1(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX2_1(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX2_1(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX2_2(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX2_2(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX2_2(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX2_2(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX2_0(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX2_0(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX2_0(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX2_0(op4, &bitD4); 
+ 
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); 
+        } 
+ 
+        /* check corruption */ 
+        if (op1 > opStart2) return ERROR(corruption_detected); 
+        if (op2 > opStart3) return ERROR(corruption_detected); 
+        if (op3 > opStart4) return ERROR(corruption_detected); 
+        /* note : op4 supposed already verified within main loop */ 
+ 
+        /* finish bitStreams one by one */ 
+        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog); 
+        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog); 
+        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog); 
+        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog); 
+ 
+        /* check */ 
+        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4); 
+        if (!endSignal) return ERROR(corruption_detected); 
+ 
+        /* decoded size */ 
+        return dstSize; 
+    } 
+} 
+ 
+ 
+static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+    size_t errorCode; 
+ 
+    errorCode = HUF_readDTableX2 (DTable, cSrc, cSrcSize); 
+    if (HUF_isError(errorCode)) return errorCode; 
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += errorCode; 
+    cSrcSize -= errorCode; 
+ 
+    return HUF_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable); 
+} 
+ 
+ 
+/***************************/ 
+/* double-symbols decoding */ 
+/***************************/ 
+ 
+static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed, 
+                           const U32* rankValOrigin, const int minWeight, 
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize, 
+                           U32 nbBitsBaseline, U16 baseSeq) 
+{ 
+    HUF_DEltX4 DElt; 
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1]; 
+    U32 s; 
+ 
+    /* get pre-calculated rankVal */ 
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal)); 
+ 
+    /* fill skipped values */ 
+    if (minWeight>1) 
+    { 
+        U32 i, skipSize = rankVal[minWeight]; 
+        MEM_writeLE16(&(DElt.sequence), baseSeq); 
+        DElt.nbBits   = (BYTE)(consumed); 
+        DElt.length   = 1; 
+        for (i = 0; i < skipSize; i++) 
+            DTable[i] = DElt; 
+    } 
+ 
+    /* fill DTable */ 
+    for (s=0; s<sortedListSize; s++)   /* note : sortedSymbols already skipped */ 
+    { 
+        const U32 symbol = sortedSymbols[s].symbol; 
+        const U32 weight = sortedSymbols[s].weight; 
+        const U32 nbBits = nbBitsBaseline - weight; 
+        const U32 length = 1 << (sizeLog-nbBits); 
+        const U32 start = rankVal[weight]; 
+        U32 i = start; 
+        const U32 end = start + length; 
+ 
+        MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8))); 
+        DElt.nbBits = (BYTE)(nbBits + consumed); 
+        DElt.length = 2; 
+        do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */ 
+ 
+        rankVal[weight] += length; 
+    } 
+} 
+ 
+typedef U32 rankVal_t[HUF_ABSOLUTEMAX_TABLELOG][HUF_ABSOLUTEMAX_TABLELOG + 1]; 
+ 
+static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog, 
+                           const sortedSymbol_t* sortedList, const U32 sortedListSize, 
+                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight, 
+                           const U32 nbBitsBaseline) 
+{ 
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1]; 
+    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */ 
+    const U32 minBits  = nbBitsBaseline - maxWeight; 
+    U32 s; 
+ 
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal)); 
+ 
+    /* fill DTable */ 
+    for (s=0; s<sortedListSize; s++) 
+    { 
+        const U16 symbol = sortedList[s].symbol; 
+        const U32 weight = sortedList[s].weight; 
+        const U32 nbBits = nbBitsBaseline - weight; 
+        const U32 start = rankVal[weight]; 
+        const U32 length = 1 << (targetLog-nbBits); 
+ 
+        if (targetLog-nbBits >= minBits)   /* enough room for a second symbol */ 
+        { 
+            U32 sortedRank; 
+            int minWeight = nbBits + scaleLog; 
+            if (minWeight < 1) minWeight = 1; 
+            sortedRank = rankStart[minWeight]; 
+            HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits, 
+                           rankValOrigin[nbBits], minWeight, 
+                           sortedList+sortedRank, sortedListSize-sortedRank, 
+                           nbBitsBaseline, symbol); 
+        } 
+        else 
+        { 
+            U32 i; 
+            const U32 end = start + length; 
+            HUF_DEltX4 DElt; 
+ 
+            MEM_writeLE16(&(DElt.sequence), symbol); 
+            DElt.nbBits   = (BYTE)(nbBits); 
+            DElt.length   = 1; 
+            for (i = start; i < end; i++) 
+                DTable[i] = DElt; 
+        } 
+        rankVal[weight] += length; 
+    } 
+} 
+ 
+static size_t HUF_readDTableX4 (U32* DTable, const void* src, size_t srcSize) 
+{ 
+    BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1]; 
+    sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1]; 
+    U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 }; 
+    U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 }; 
+    U32* const rankStart = rankStart0+1; 
+    rankVal_t rankVal; 
+    U32 tableLog, maxW, sizeOfSort, nbSymbols; 
+    const U32 memLog = DTable[0]; 
+    const BYTE* ip = (const BYTE*) src; 
+    size_t iSize = ip[0]; 
+    void* ptr = DTable; 
+    HUF_DEltX4* const dt = ((HUF_DEltX4*)ptr) + 1; 
+ 
+    HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */ 
+    if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge); 
+    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize); 
+    if (HUF_isError(iSize)) return iSize; 
+ 
+    /* check result */ 
+    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */ 
+ 
+    /* find maxWeight */ 
+    for (maxW = tableLog; rankStats[maxW]==0; maxW--) 
+        { if (!maxW) return ERROR(GENERIC); }  /* necessarily finds a solution before maxW==0 */ 
+ 
+    /* Get start index of each weight */ 
+    { 
+        U32 w, nextRankStart = 0; 
+        for (w=1; w<=maxW; w++) 
+        { 
+            U32 current = nextRankStart; 
+            nextRankStart += rankStats[w]; 
+            rankStart[w] = current; 
+        } 
+        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/ 
+        sizeOfSort = nextRankStart; 
+    } 
+ 
+    /* sort symbols by weight */ 
+    { 
+        U32 s; 
+        for (s=0; s<nbSymbols; s++) 
+        { 
+            U32 w = weightList[s]; 
+            U32 r = rankStart[w]++; 
+            sortedSymbol[r].symbol = (BYTE)s; 
+            sortedSymbol[r].weight = (BYTE)w; 
+        } 
+        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */ 
+    } 
+ 
+	/* Build rankVal */ 
+    { 
+        const U32 minBits = tableLog+1 - maxW; 
+        U32 nextRankVal = 0; 
+        U32 w, consumed; 
+        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */ 
+        U32* rankVal0 = rankVal[0]; 
+        for (w=1; w<=maxW; w++) 
+        { 
+            U32 current = nextRankVal; 
+            nextRankVal += rankStats[w] << (w+rescale); 
+            rankVal0[w] = current; 
+        } 
+        for (consumed = minBits; consumed <= memLog - minBits; consumed++) 
+        { 
+            U32* rankValPtr = rankVal[consumed]; 
+            for (w = 1; w <= maxW; w++) 
+            { 
+                rankValPtr[w] = rankVal0[w] >> consumed; 
+            } 
+        } 
+    } 
+ 
+    HUF_fillDTableX4(dt, memLog, 
+                   sortedSymbol, sizeOfSort, 
+                   rankStart0, rankVal, maxW, 
+                   tableLog+1); 
+ 
+    return iSize; 
+} 
+ 
+ 
+static U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog) 
+{ 
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    memcpy(op, dt+val, 2); 
+    BIT_skipBits(DStream, dt[val].nbBits); 
+    return dt[val].length; 
+} 
+ 
+static U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog) 
+{ 
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    memcpy(op, dt+val, 1); 
+    if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits); 
+    else 
+    { 
+        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) 
+        { 
+            BIT_skipBits(DStream, dt[val].nbBits); 
+            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8)) 
+                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */ 
+        } 
+    } 
+    return 1; 
+} 
+ 
+ 
+#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \ 
+    ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+#define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \ 
+    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \ 
+        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+#define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \ 
+    if (MEM_64bits()) \ 
+        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+static inline size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog) 
+{ 
+    BYTE* const pStart = p; 
+ 
+    /* up to 8 symbols at a time */ 
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd-7)) 
+    { 
+        HUF_DECODE_SYMBOLX4_2(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX4_1(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX4_2(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr); 
+    } 
+ 
+    /* closer to the end */ 
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-2)) 
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr); 
+ 
+    while (p <= pEnd-2) 
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */ 
+ 
+    if (p < pEnd) 
+        p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog); 
+ 
+    return p-pStart; 
+} 
+ 
+ 
+ 
+static size_t HUF_decompress4X4_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const U32* DTable) 
+{ 
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */ 
+ 
+    { 
+        const BYTE* const istart = (const BYTE*) cSrc; 
+        BYTE* const ostart = (BYTE*) dst; 
+        BYTE* const oend = ostart + dstSize; 
+ 
+        const void* ptr = DTable; 
+        const HUF_DEltX4* const dt = ((const HUF_DEltX4*)ptr) +1; 
+        const U32 dtLog = DTable[0]; 
+        size_t errorCode; 
+ 
+        /* Init */ 
+        BIT_DStream_t bitD1; 
+        BIT_DStream_t bitD2; 
+        BIT_DStream_t bitD3; 
+        BIT_DStream_t bitD4; 
+        const size_t length1 = MEM_readLE16(istart); 
+        const size_t length2 = MEM_readLE16(istart+2); 
+        const size_t length3 = MEM_readLE16(istart+4); 
+        size_t length4; 
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */ 
+        const BYTE* const istart2 = istart1 + length1; 
+        const BYTE* const istart3 = istart2 + length2; 
+        const BYTE* const istart4 = istart3 + length3; 
+        const size_t segmentSize = (dstSize+3) / 4; 
+        BYTE* const opStart2 = ostart + segmentSize; 
+        BYTE* const opStart3 = opStart2 + segmentSize; 
+        BYTE* const opStart4 = opStart3 + segmentSize; 
+        BYTE* op1 = ostart; 
+        BYTE* op2 = opStart2; 
+        BYTE* op3 = opStart3; 
+        BYTE* op4 = opStart4; 
+        U32 endSignal; 
+ 
+        length4 = cSrcSize - (length1 + length2 + length3 + 6); 
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */ 
+        errorCode = BIT_initDStream(&bitD1, istart1, length1); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD2, istart2, length2); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD3, istart3, length3); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD4, istart4, length4); 
+        if (HUF_isError(errorCode)) return errorCode; 
+ 
+        /* 16-32 symbols per loop (4-8 symbols per stream) */ 
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); 
+        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; ) 
+        { 
+            HUF_DECODE_SYMBOLX4_2(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX4_2(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX4_2(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX4_2(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX4_1(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX4_1(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX4_1(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX4_1(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX4_2(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX4_2(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX4_2(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX4_2(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX4_0(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX4_0(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX4_0(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX4_0(op4, &bitD4); 
+ 
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); 
+        } 
+ 
+        /* check corruption */ 
+        if (op1 > opStart2) return ERROR(corruption_detected); 
+        if (op2 > opStart3) return ERROR(corruption_detected); 
+        if (op3 > opStart4) return ERROR(corruption_detected); 
+        /* note : op4 supposed already verified within main loop */ 
+ 
+        /* finish bitStreams one by one */ 
+        HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog); 
+        HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog); 
+        HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog); 
+        HUF_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog); 
+ 
+        /* check */ 
+        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4); 
+        if (!endSignal) return ERROR(corruption_detected); 
+ 
+        /* decoded size */ 
+        return dstSize; 
+    } 
+} 
+ 
+ 
+static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
+    size_t hSize = HUF_readDTableX4 (DTable, cSrc, cSrcSize); 
+    if (HUF_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; 
+    cSrcSize -= hSize; 
+ 
+    return HUF_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable); 
+} 
+ 
+ 
+/**********************************/ 
+/* Generic decompression selector */ 
+/**********************************/ 
+ 
+typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t; 
+static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] = 
+{ 
+    /* single, double, quad */ 
+    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */ 
+    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */ 
+    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */ 
+    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */ 
+    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */ 
+    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */ 
+    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */ 
+    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */ 
+    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */ 
+    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */ 
+    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */ 
+    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */ 
+    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */ 
+    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */ 
+    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */ 
+    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */ 
+}; 
+ 
+typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); 
+ 
+static size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
     static const decompressionAlgo decompress[3] = { HUF_decompress4X2, HUF_decompress4X4, NULL };
-    /* estimate decompression time */
-    U32 Q;
-    const U32 D256 = (U32)(dstSize >> 8);
-    U32 Dtime[3];
-    U32 algoNb = 0;
-    int n;
-
-    /* validation checks */
-    if (dstSize == 0) return ERROR(dstSize_tooSmall);
-    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
-    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
-    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
-
-    /* decoder timing evaluation */
-    Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */
-    for (n=0; n<3; n++)
-        Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256);
-
-    Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */
-
-    if (Dtime[1] < Dtime[0]) algoNb = 1;
-
-    return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
-
-    //return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize);   /* multi-streams single-symbol decoding */
-    //return HUF_decompress4X4(dst, dstSize, cSrc, cSrcSize);   /* multi-streams double-symbols decoding */
-    //return HUF_decompress4X6(dst, dstSize, cSrc, cSrcSize);   /* multi-streams quad-symbols decoding */
-}
-/*
-    zstd - standard compression library
-    Copyright (C) 2014-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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-
-/* ***************************************************************
-*  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
-*/
-#define ZSTD_MEMORY_USAGE 17
-
-/*!
- * HEAPMODE :
- * Select how default compression functions will allocate memory for their hash table,
- * in memory stack (0, fastest), or in memory heap (1, requires malloc())
- * Note that compression context is fairly large, as a consequence heap memory is recommended.
- */
-#ifndef ZSTD_HEAPMODE
-#  define ZSTD_HEAPMODE 1
-#endif /* ZSTD_HEAPMODE */
-
-/*!
-*  LEGACY_SUPPORT :
-*  decompressor can decode older formats (starting from Zstd 0.1+)
-*/
-#ifndef ZSTD_LEGACY_SUPPORT
-#  define ZSTD_LEGACY_SUPPORT 1
-#endif
-
-
-/* *******************************************************
-*  Includes
-*********************************************************/
-#include <stdlib.h>      /* calloc */
-#include <string.h>      /* memcpy, memmove */
-#include <stdio.h>       /* debug : printf */
-
-
-/* *******************************************************
-*  Compiler specifics
-*********************************************************/
-#ifdef __AVX2__
-#  include <immintrin.h>   /* AVX2 intrinsics */
-#endif
-
-#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 : 4324)        /* disable: C4324: padded structure */
-#else
-#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#  ifdef __GNUC__
-#    define FORCE_INLINE static inline __attribute__((always_inline))
-#  else
-#    define FORCE_INLINE static inline
-#  endif
-#endif
-
-
-/* *******************************************************
-*  Constants
-*********************************************************/
-#define HASH_LOG (ZSTD_MEMORY_USAGE - 2)
-#define HASH_TABLESIZE (1 << HASH_LOG)
-#define HASH_MASK (HASH_TABLESIZE - 1)
-
-#define KNUTH 2654435761
-
-#define BIT7 128
-#define BIT6  64
-#define BIT5  32
-#define BIT4  16
-#define BIT1   2
-#define BIT0   1
-
-#define KB *(1 <<10)
-#define MB *(1 <<20)
-#define GB *(1U<<30)
-
-#define BLOCKSIZE (128 KB)                 /* define, for static allocation */
-#define MIN_SEQUENCES_SIZE (2 /*seqNb*/ + 2 /*dumps*/ + 3 /*seqTables*/ + 1 /*bitStream*/)
-#define MIN_CBLOCK_SIZE (3 /*litCSize*/ + MIN_SEQUENCES_SIZE)
-#define IS_RAW BIT0
-#define IS_RLE BIT1
-
-#define WORKPLACESIZE (BLOCKSIZE*3)
-#define MINMATCH 4
-#define MLbits   7
-#define LLbits   6
-#define Offbits  5
-#define MaxML  ((1<<MLbits )-1)
-#define MaxLL  ((1<<LLbits )-1)
-#define MaxOff   31
-#define LitFSELog  11
-#define MLFSELog   10
-#define LLFSELog   10
-#define OffFSELog   9
-#define MAX(a,b) ((a)<(b)?(b):(a))
-#define MaxSeq MAX(MaxLL, MaxML)
-
-#define LITERAL_NOENTROPY 63
-#define COMMAND_NOENTROPY 7   /* to remove */
-
-static const size_t ZSTD_blockHeaderSize = 3;
-static const size_t ZSTD_frameHeaderSize = 4;
-
-
-/* *******************************************************
-*  Memory operations
-**********************************************************/
-static void   ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
-
-static void   ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
-
-#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; }
-
-/*! ZSTD_wildcopy : custom version of memcpy(), can copy up to 7-8 bytes too many */
-static void ZSTD_wildcopy(void* dst, const void* src, size_t length)
-{
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + length;
-    do COPY8(op, ip) while (op < oend);
-}
-
-
-/* **************************************
-*  Local structures
-****************************************/
-typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;
-
-typedef struct
-{
-    blockType_t blockType;
-    U32 origSize;
-} blockProperties_t;
-
-typedef struct {
-    void* buffer;
-    U32*  offsetStart;
-    U32*  offset;
-    BYTE* offCodeStart;
-    BYTE* offCode;
-    BYTE* litStart;
-    BYTE* lit;
-    BYTE* litLengthStart;
-    BYTE* litLength;
-    BYTE* matchLengthStart;
-    BYTE* matchLength;
-    BYTE* dumpsStart;
-    BYTE* dumps;
-} seqStore_t;
-
-
-/* *************************************
-*  Error Management
-***************************************/
-/*! ZSTD_isError
-*   tells if a return value is an error code */
-static unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }
-
-
-/* *************************************
-*  Function body to include
-***************************************/
-static size_t ZSTD_read_ARCH(const void* p) { size_t r; memcpy(&r, p, sizeof(r)); return r; }
-
-MEM_STATIC unsigned ZSTD_NbCommonBytes (register size_t val)
-{
-    if (MEM_isLittleEndian())
-    {
-        if (MEM_64bits())
-        {
-#       if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r = 0;
-            _BitScanForward64( &r, (U64)val );
-            return (int)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (__builtin_ctzll((U64)val) >> 3);
-#       else
-            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 };
-            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];
-#       endif
-        }
-        else /* 32 bits */
-        {
-#       if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r;
-            _BitScanForward( &r, (U32)val );
-            return (int)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (__builtin_ctz((U32)val) >> 3);
-#       else
-            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 };
-            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
-#       endif
-        }
-    }
-    else   /* Big Endian CPU */
-    {
-        if (MEM_32bits())
-        {
-#       if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r = 0;
-            _BitScanReverse64( &r, val );
-            return (unsigned)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (__builtin_clzll(val) >> 3);
-#       else
-            unsigned r;
-            const unsigned n32 = sizeof(size_t)*4;   /* calculate this way due to compiler complaining in 32-bits mode */
-            if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; }
-            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
-            r += (!val);
-            return r;
-#       endif
-        }
-        else /* 32 bits */
-        {
-#       if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r = 0;
-            _BitScanReverse( &r, (unsigned long)val );
-            return (unsigned)(r>>3);
-#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (__builtin_clz((U32)val) >> 3);
-#       else
-            unsigned r;
-            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
-            r += (!val);
-            return r;
-#       endif
-        }
-    }
-}
-
-
-MEM_STATIC size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
-{
-    const BYTE* const pStart = pIn;
-
-    while ((pIn<pInLimit-(sizeof(size_t)-1)))
-    {
-        size_t diff = ZSTD_read_ARCH(pMatch) ^ ZSTD_read_ARCH(pIn);
-        if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; }
-        pIn += ZSTD_NbCommonBytes(diff);
-        return (size_t)(pIn - pStart);
-    }
-
-    if (MEM_32bits()) if ((pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; }
-    if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; }
-    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
-    return (size_t)(pIn - pStart);
-}
-
-
-/* *************************************************************
-*   Decompression section
-***************************************************************/
-struct ZSTD_DCtx_s
-{
-    U32 LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)];
-    U32 OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)];
-    U32 MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)];
-    void* previousDstEnd;
-    void* base;
-    size_t expected;
-    blockType_t bType;
-    U32 phase;
-    const BYTE* litPtr;
-    size_t litBufSize;
-    size_t litSize;
-    BYTE litBuffer[BLOCKSIZE + 8 /* margin for wildcopy */];
-};   /* typedef'd to ZSTD_Dctx within "zstd_static.h" */
-
-
-static size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
-{
-    const BYTE* const in = (const BYTE* const)src;
-    BYTE headerFlags;
-    U32 cSize;
-
-    if (srcSize < 3) return ERROR(srcSize_wrong);
-
-    headerFlags = *in;
-    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);
-
-    bpPtr->blockType = (blockType_t)(headerFlags >> 6);
-    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;
-
-    if (bpPtr->blockType == bt_end) return 0;
-    if (bpPtr->blockType == bt_rle) return 1;
-    return cSize;
-}
-
-static size_t ZSTD_copyUncompressedBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall);
-    memcpy(dst, src, srcSize);
-    return srcSize;
-}
-
-
-/** ZSTD_decompressLiterals
-    @return : nb of bytes read from src, or an error code*/
-static size_t ZSTD_decompressLiterals(void* dst, size_t* maxDstSizePtr,
-                                const void* src, size_t srcSize)
-{
-    const BYTE* ip = (const BYTE*)src;
-
-    const size_t litSize = (MEM_readLE32(src) & 0x1FFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
-    const size_t litCSize = (MEM_readLE32(ip+2) & 0xFFFFFF) >> 5;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
-
-    if (litSize > *maxDstSizePtr) return ERROR(corruption_detected);
-    if (litCSize + 5 > srcSize) return ERROR(corruption_detected);
-
-    if (HUF_isError(HUF_decompress(dst, litSize, ip+5, litCSize))) return ERROR(corruption_detected);
-
-    *maxDstSizePtr = litSize;
-    return litCSize + 5;
-}
-
-
-/** ZSTD_decodeLiteralsBlock
-    @return : nb of bytes read from src (< srcSize )*/
-static size_t ZSTD_decodeLiteralsBlock(void* ctx,
-                          const void* src, size_t srcSize)
-{
-    ZSTD_DCtx* dctx = (ZSTD_DCtx*)ctx;
-    const BYTE* const istart = (const BYTE* const)src;
-
-    /* any compressed block with literals segment must be at least this size */
-    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
-
-    switch(*istart & 3)
-    {
-    default:
-    case 0:
-        {
-            size_t litSize = BLOCKSIZE;
-            const size_t readSize = ZSTD_decompressLiterals(dctx->litBuffer, &litSize, src, srcSize);
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litBufSize = BLOCKSIZE;
-            dctx->litSize = litSize;
-            return readSize;   /* works if it's an error too */
-        }
-    case IS_RAW:
-        {
-            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
-            if (litSize > srcSize-11)   /* risk of reading too far with wildcopy */
-            {
-				if (litSize > srcSize-3) return ERROR(corruption_detected);
-				memcpy(dctx->litBuffer, istart, litSize);
-				dctx->litPtr = dctx->litBuffer;
-				dctx->litBufSize = BLOCKSIZE;
-				dctx->litSize = litSize;
-				return litSize+3;
-			}
-			/* direct reference into compressed stream */
-            dctx->litPtr = istart+3;
-            dctx->litBufSize = srcSize-3;
-            dctx->litSize = litSize;
-            return litSize+3;
-        }
-    case IS_RLE:
-        {
-            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
-            if (litSize > BLOCKSIZE) return ERROR(corruption_detected);
-            memset(dctx->litBuffer, istart[3], litSize);
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litBufSize = BLOCKSIZE;
-            dctx->litSize = litSize;
-            return 4;
-        }
-    }
-}
-
-
-static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,
-                         FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb,
-                         const void* src, size_t srcSize)
-{
-    const BYTE* const istart = (const BYTE* const)src;
-    const BYTE* ip = istart;
-    const BYTE* const iend = istart + srcSize;
-    U32 LLtype, Offtype, MLtype;
-    U32 LLlog, Offlog, MLlog;
-    size_t dumpsLength;
-
-    /* check */
-    if (srcSize < 5) return ERROR(srcSize_wrong);
-
-    /* SeqHead */
-    *nbSeq = MEM_readLE16(ip); ip+=2;
-    LLtype  = *ip >> 6;
-    Offtype = (*ip >> 4) & 3;
-    MLtype  = (*ip >> 2) & 3;
-    if (*ip & 2)
-    {
-        dumpsLength  = ip[2];
-        dumpsLength += ip[1] << 8;
-        ip += 3;
-    }
-    else
-    {
-        dumpsLength  = ip[1];
-        dumpsLength += (ip[0] & 1) << 8;
-        ip += 2;
-    }
-    *dumpsPtr = ip;
-    ip += dumpsLength;
-    *dumpsLengthPtr = dumpsLength;
-
-    /* check */
-    if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */
-
-    /* sequences */
-    {
-        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL and MaxOff */
-        size_t headerSize;
-
-        /* Build DTables */
-        switch(LLtype)
-        {
-        U32 max;
-        case bt_rle :
-            LLlog = 0;
-            FSE_buildDTable_rle(DTableLL, *ip++); break;
-        case bt_raw :
-            LLlog = LLbits;
-            FSE_buildDTable_raw(DTableLL, LLbits); break;
-        default :
-            max = MaxLL;
-            headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);
-            if (FSE_isError(headerSize)) return ERROR(GENERIC);
-            if (LLlog > LLFSELog) return ERROR(corruption_detected);
-            ip += headerSize;
-            FSE_buildDTable(DTableLL, norm, max, LLlog);
-        }
-
-        switch(Offtype)
-        {
-        U32 max;
-        case bt_rle :
-            Offlog = 0;
-            if (ip > iend-2) return ERROR(srcSize_wrong);   /* min : "raw", hence no header, but at least xxLog bits */
-            FSE_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */
-            break;
-        case bt_raw :
-            Offlog = Offbits;
-            FSE_buildDTable_raw(DTableOffb, Offbits); break;
-        default :
-            max = MaxOff;
-            headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);
-            if (FSE_isError(headerSize)) return ERROR(GENERIC);
-            if (Offlog > OffFSELog) return ERROR(corruption_detected);
-            ip += headerSize;
-            FSE_buildDTable(DTableOffb, norm, max, Offlog);
-        }
-
-        switch(MLtype)
-        {
-        U32 max;
-        case bt_rle :
-            MLlog = 0;
-            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */
-            FSE_buildDTable_rle(DTableML, *ip++); break;
-        case bt_raw :
-            MLlog = MLbits;
-            FSE_buildDTable_raw(DTableML, MLbits); break;
-        default :
-            max = MaxML;
-            headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);
-            if (FSE_isError(headerSize)) return ERROR(GENERIC);
-            if (MLlog > MLFSELog) return ERROR(corruption_detected);
-            ip += headerSize;
-            FSE_buildDTable(DTableML, norm, max, MLlog);
-        }
-    }
-
-    return ip-istart;
-}
-
-
-typedef struct {
-    size_t litLength;
-    size_t offset;
-    size_t matchLength;
-} seq_t;
-
-typedef struct {
-    BIT_DStream_t DStream;
-    FSE_DState_t stateLL;
-    FSE_DState_t stateOffb;
-    FSE_DState_t stateML;
-    size_t prevOffset;
-    const BYTE* dumps;
-    const BYTE* dumpsEnd;
-} seqState_t;
-
-
-static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState)
-{
-    size_t litLength;
-    size_t prevOffset;
-    size_t offset;
-    size_t matchLength;
-    const BYTE* dumps = seqState->dumps;
-    const BYTE* const de = seqState->dumpsEnd;
-
-    /* Literal length */
-    litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream));
-    prevOffset = litLength ? seq->offset : seqState->prevOffset;
-    seqState->prevOffset = seq->offset;
-    if (litLength == MaxLL)
-    {
-        U32 add = *dumps++;
-        if (add < 255) litLength += add;
-        else
-        {
-            litLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */
-            dumps += 3;
-        }
-        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */
-    }
-
-    /* Offset */
-    {
-        static const size_t offsetPrefix[MaxOff+1] = {  /* note : size_t faster than U32 */
-                1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256,
-                512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
-                524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 };
-        U32 offsetCode, nbBits;
-        offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream));   /* <= maxOff, by table construction */
-        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));
-        nbBits = offsetCode - 1;
-        if (offsetCode==0) nbBits = 0;   /* cmove */
-        offset = offsetPrefix[offsetCode] + BIT_readBits(&(seqState->DStream), nbBits);
-        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));
-        if (offsetCode==0) offset = prevOffset;   /* cmove */
-    }
-
-    /* MatchLength */
-    matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream));
-    if (matchLength == MaxML)
-    {
-        U32 add = *dumps++;
-        if (add < 255) matchLength += add;
-        else
-        {
-            matchLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */
-            dumps += 3;
-        }
-        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */
-    }
-    matchLength += MINMATCH;
-
-    /* save result */
-    seq->litLength = litLength;
-    seq->offset = offset;
-    seq->matchLength = matchLength;
-    seqState->dumps = dumps;
-}
-
-
-static size_t ZSTD_execSequence(BYTE* op,
-                                seq_t sequence,
-                                const BYTE** litPtr, const BYTE* const litLimit,
-                                BYTE* const base, BYTE* const oend)
-{
-    static const int dec32table[] = {0, 1, 2, 1, 4, 4, 4, 4};   /* added */
-    static const int dec64table[] = {8, 8, 8, 7, 8, 9,10,11};   /* substracted */
-    const BYTE* const ostart = op;
-    BYTE* const oLitEnd = op + sequence.litLength;
-    BYTE* const oMatchEnd = op + sequence.litLength + sequence.matchLength;   /* risk : address space overflow (32-bits) */
-    BYTE* const oend_8 = oend-8;
-    const BYTE* const litEnd = *litPtr + sequence.litLength;
-
-    /* checks */
-    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */
-    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */
-    if (litEnd > litLimit-8) return ERROR(corruption_detected);   /* overRead beyond lit buffer */
-
-    /* copy Literals */
-    ZSTD_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */
-    op = oLitEnd;
-    *litPtr = litEnd;   /* update for next sequence */
-
-    /* copy Match */
-    {
-        const BYTE* match = op - sequence.offset;
-
-        /* check */
-        if (sequence.offset > (size_t)op) return ERROR(corruption_detected);   /* address space overflow test (this test seems kept by clang optimizer) */
-        //if (match > op) return ERROR(corruption_detected);   /* address space overflow test (is clang optimizer removing this test ?) */
-        if (match < base) return ERROR(corruption_detected);
-
-        /* close range match, overlap */
-        if (sequence.offset < 8)
-        {
-            const int dec64 = dec64table[sequence.offset];
-            op[0] = match[0];
-            op[1] = match[1];
-            op[2] = match[2];
-            op[3] = match[3];
-            match += dec32table[sequence.offset];
-            ZSTD_copy4(op+4, match);
-            match -= dec64;
-        }
-        else
-        {
-            ZSTD_copy8(op, match);
-        }
-        op += 8; match += 8;
-
-        if (oMatchEnd > oend-12)
-        {
-            if (op < oend_8)
-            {
-                ZSTD_wildcopy(op, match, oend_8 - op);
-                match += oend_8 - op;
-                op = oend_8;
-            }
-            while (op < oMatchEnd) *op++ = *match++;
-        }
-        else
-        {
-            ZSTD_wildcopy(op, match, sequence.matchLength-8);   /* works even if matchLength < 8 */
-        }
-    }
-
-    return oMatchEnd - ostart;
-}
-
-static size_t ZSTD_decompressSequences(
-                               void* ctx,
-                               void* dst, size_t maxDstSize,
-                         const void* seqStart, size_t seqSize)
-{
-    ZSTD_DCtx* dctx = (ZSTD_DCtx*)ctx;
-    const BYTE* ip = (const BYTE*)seqStart;
-    const BYTE* const iend = ip + seqSize;
-    BYTE* const ostart = (BYTE* const)dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + maxDstSize;
-    size_t errorCode, dumpsLength;
-    const BYTE* litPtr = dctx->litPtr;
-    const BYTE* const litMax = litPtr + dctx->litBufSize;
-    const BYTE* const litEnd = litPtr + dctx->litSize;
-    int nbSeq;
-    const BYTE* dumps;
-    U32* DTableLL = dctx->LLTable;
-    U32* DTableML = dctx->MLTable;
-    U32* DTableOffb = dctx->OffTable;
-    BYTE* const base = (BYTE*) (dctx->base);
-
-    /* Build Decoding Tables */
-    errorCode = ZSTD_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,
-                                      DTableLL, DTableML, DTableOffb,
-                                      ip, iend-ip);
-    if (ZSTD_isError(errorCode)) return errorCode;
-    ip += errorCode;
-
-    /* Regen sequences */
-    {
-        seq_t sequence;
-        seqState_t seqState;
-
-        memset(&sequence, 0, sizeof(sequence));
-        seqState.dumps = dumps;
-        seqState.dumpsEnd = dumps + dumpsLength;
-        seqState.prevOffset = sequence.offset = 4;
-        errorCode = BIT_initDStream(&(seqState.DStream), ip, iend-ip);
-        if (ERR_isError(errorCode)) return ERROR(corruption_detected);
-        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
-        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
-        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
-
-        for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (nbSeq>0) ; )
-        {
-            size_t oneSeqSize;
-            nbSeq--;
-            ZSTD_decodeSequence(&sequence, &seqState);
-            oneSeqSize = ZSTD_execSequence(op, sequence, &litPtr, litMax, base, oend);
-            if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
-            op += oneSeqSize;
-        }
-
-        /* check if reached exact end */
-        if ( !BIT_endOfDStream(&(seqState.DStream)) ) return ERROR(corruption_detected);   /* requested too much : data is corrupted */
-        if (nbSeq<0) return ERROR(corruption_detected);   /* requested too many sequences : data is corrupted */
-
-        /* last literal segment */
-        {
-            size_t lastLLSize = litEnd - litPtr;
-            if (litPtr > litEnd) return ERROR(corruption_detected);
-            if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);
-            if (op != litPtr) memmove(op, litPtr, lastLLSize);
-            op += lastLLSize;
-        }
-    }
-
-    return op-ostart;
-}
-
-
-static size_t ZSTD_decompressBlock(
-                            void* ctx,
-                            void* dst, size_t maxDstSize,
-                      const void* src, size_t srcSize)
-{
-    /* blockType == blockCompressed */
-    const BYTE* ip = (const BYTE*)src;
-
-    /* Decode literals sub-block */
-    size_t litCSize = ZSTD_decodeLiteralsBlock(ctx, src, srcSize);
-    if (ZSTD_isError(litCSize)) return litCSize;
-    ip += litCSize;
-    srcSize -= litCSize;
-
-    return ZSTD_decompressSequences(ctx, dst, maxDstSize, ip, srcSize);
-}
-
-
-static size_t ZSTD_decompressDCtx(void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    const BYTE* ip = (const BYTE*)src;
-    const BYTE* iend = ip + srcSize;
-    BYTE* const ostart = (BYTE* const)dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + maxDstSize;
-    size_t remainingSize = srcSize;
-    U32 magicNumber;
-    blockProperties_t blockProperties;
-
-    /* Frame Header */
-    if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
-    magicNumber = MEM_readLE32(src);
-    if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);
-    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize;
-
-    /* Loop on each block */
-    while (1)
-    {
-        size_t decodedSize=0;
-        size_t cBlockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties);
-        if (ZSTD_isError(cBlockSize)) return cBlockSize;
-
-        ip += ZSTD_blockHeaderSize;
-        remainingSize -= ZSTD_blockHeaderSize;
-        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);
-
-        switch(blockProperties.blockType)
-        {
-        case bt_compressed:
-            decodedSize = ZSTD_decompressBlock(ctx, op, oend-op, ip, cBlockSize);
-            break;
-        case bt_raw :
-            decodedSize = ZSTD_copyUncompressedBlock(op, oend-op, ip, cBlockSize);
-            break;
-        case bt_rle :
-            return ERROR(GENERIC);   /* not yet supported */
-            break;
-        case bt_end :
-            /* end of frame */
-            if (remainingSize) return ERROR(srcSize_wrong);
-            break;
-        default:
-            return ERROR(GENERIC);   /* impossible */
-        }
-        if (cBlockSize == 0) break;   /* bt_end */
-
-        if (ZSTD_isError(decodedSize)) return decodedSize;
-        op += decodedSize;
-        ip += cBlockSize;
-        remainingSize -= cBlockSize;
-    }
-
-    return op-ostart;
-}
-
-static size_t ZSTD_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    ZSTD_DCtx ctx;
-    ctx.base = dst;
-    return ZSTD_decompressDCtx(&ctx, dst, maxDstSize, src, srcSize);
-}
-
-
-/*******************************
-*  Streaming Decompression API
-*******************************/
-
-static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx)
-{
-    dctx->expected = ZSTD_frameHeaderSize;
-    dctx->phase = 0;
-    dctx->previousDstEnd = NULL;
-    dctx->base = NULL;
-    return 0;
-}
-
-static ZSTD_DCtx* ZSTD_createDCtx(void)
-{
-    ZSTD_DCtx* dctx = (ZSTD_DCtx*)malloc(sizeof(ZSTD_DCtx));
-    if (dctx==NULL) return NULL;
-    ZSTD_resetDCtx(dctx);
-    return dctx;
-}
-
-static size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
-{
-    free(dctx);
-    return 0;
-}
-
-static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx)
-{
-    return dctx->expected;
-}
-
-static size_t ZSTD_decompressContinue(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    /* Sanity check */
-    if (srcSize != ctx->expected) return ERROR(srcSize_wrong);
-    if (dst != ctx->previousDstEnd)  /* not contiguous */
-        ctx->base = dst;
-
-    /* Decompress : frame header */
-    if (ctx->phase == 0)
-    {
-        /* Check frame magic header */
-        U32 magicNumber = MEM_readLE32(src);
-        if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);
-        ctx->phase = 1;
-        ctx->expected = ZSTD_blockHeaderSize;
-        return 0;
-    }
-
-    /* Decompress : block header */
-    if (ctx->phase == 1)
-    {
-        blockProperties_t bp;
-        size_t blockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
-        if (ZSTD_isError(blockSize)) return blockSize;
-        if (bp.blockType == bt_end)
-        {
-            ctx->expected = 0;
-            ctx->phase = 0;
-        }
-        else
-        {
-            ctx->expected = blockSize;
-            ctx->bType = bp.blockType;
-            ctx->phase = 2;
-        }
-
-        return 0;
-    }
-
-    /* Decompress : block content */
-    {
-        size_t rSize;
-        switch(ctx->bType)
-        {
-        case bt_compressed:
-            rSize = ZSTD_decompressBlock(ctx, dst, maxDstSize, src, srcSize);
-            break;
-        case bt_raw :
-            rSize = ZSTD_copyUncompressedBlock(dst, maxDstSize, src, srcSize);
-            break;
-        case bt_rle :
-            return ERROR(GENERIC);   /* not yet handled */
-            break;
-        case bt_end :   /* should never happen (filtered at phase 1) */
-            rSize = 0;
-            break;
-        default:
-            return ERROR(GENERIC);
-        }
-        ctx->phase = 1;
-        ctx->expected = ZSTD_blockHeaderSize;
-        ctx->previousDstEnd = (void*)( ((char*)dst) + rSize);
-        return rSize;
-    }
-
-}
-
-
-/* wrapper layer */
-
-unsigned ZSTDv03_isError(size_t code)
-{
-	return ZSTD_isError(code);
-}
-
-size_t ZSTDv03_decompress( void* dst, size_t maxOriginalSize,
-                     const void* src, size_t compressedSize)
-{
-	return ZSTD_decompress(dst, maxOriginalSize, src, compressedSize);
-}
-
-ZSTDv03_Dctx* ZSTDv03_createDCtx(void)
-{
-	return (ZSTDv03_Dctx*)ZSTD_createDCtx();
-}
-
-size_t ZSTDv03_freeDCtx(ZSTDv03_Dctx* dctx)
-{
-	return ZSTD_freeDCtx((ZSTD_DCtx*)dctx);
-}
-
-size_t ZSTDv03_resetDCtx(ZSTDv03_Dctx* dctx)
-{
-	return ZSTD_resetDCtx((ZSTD_DCtx*)dctx);
-}
-
-size_t ZSTDv03_nextSrcSizeToDecompress(ZSTDv03_Dctx* dctx)
-{
-	return ZSTD_nextSrcSizeToDecompress((ZSTD_DCtx*)dctx);
-}
-
-size_t ZSTDv03_decompressContinue(ZSTDv03_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-	return ZSTD_decompressContinue((ZSTD_DCtx*)dctx, dst, maxDstSize, src, srcSize);
-}
+    /* estimate decompression time */ 
+    U32 Q; 
+    const U32 D256 = (U32)(dstSize >> 8); 
+    U32 Dtime[3]; 
+    U32 algoNb = 0; 
+    int n; 
+ 
+    /* validation checks */ 
+    if (dstSize == 0) return ERROR(dstSize_tooSmall); 
+    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */ 
+    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */ 
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */ 
+ 
+    /* decoder timing evaluation */ 
+    Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */ 
+    for (n=0; n<3; n++) 
+        Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256); 
+ 
+    Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */ 
+ 
+    if (Dtime[1] < Dtime[0]) algoNb = 1; 
+ 
+    return decompress[algoNb](dst, dstSize, cSrc, cSrcSize); 
+ 
+    //return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize);   /* multi-streams single-symbol decoding */ 
+    //return HUF_decompress4X4(dst, dstSize, cSrc, cSrcSize);   /* multi-streams double-symbols decoding */ 
+    //return HUF_decompress4X6(dst, dstSize, cSrc, cSrcSize);   /* multi-streams quad-symbols decoding */ 
+} 
+/* 
+    zstd - standard compression library 
+    Copyright (C) 2014-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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+ 
+/* *************************************************************** 
+*  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 
+*/ 
+#define ZSTD_MEMORY_USAGE 17 
+ 
+/*! 
+ * HEAPMODE : 
+ * Select how default compression functions will allocate memory for their hash table, 
+ * in memory stack (0, fastest), or in memory heap (1, requires malloc()) 
+ * Note that compression context is fairly large, as a consequence heap memory is recommended. 
+ */ 
+#ifndef ZSTD_HEAPMODE 
+#  define ZSTD_HEAPMODE 1 
+#endif /* ZSTD_HEAPMODE */ 
+ 
+/*! 
+*  LEGACY_SUPPORT : 
+*  decompressor can decode older formats (starting from Zstd 0.1+) 
+*/ 
+#ifndef ZSTD_LEGACY_SUPPORT 
+#  define ZSTD_LEGACY_SUPPORT 1 
+#endif 
+ 
+ 
+/* ******************************************************* 
+*  Includes 
+*********************************************************/ 
+#include <stdlib.h>      /* calloc */ 
+#include <string.h>      /* memcpy, memmove */ 
+#include <stdio.h>       /* debug : printf */ 
+ 
+ 
+/* ******************************************************* 
+*  Compiler specifics 
+*********************************************************/ 
+#ifdef __AVX2__ 
+#  include <immintrin.h>   /* AVX2 intrinsics */ 
+#endif 
+ 
+#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 : 4324)        /* disable: C4324: padded structure */ 
+#else 
+#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) 
+#  ifdef __GNUC__ 
+#    define FORCE_INLINE static inline __attribute__((always_inline)) 
+#  else 
+#    define FORCE_INLINE static inline 
+#  endif 
+#endif 
+ 
+ 
+/* ******************************************************* 
+*  Constants 
+*********************************************************/ 
+#define HASH_LOG (ZSTD_MEMORY_USAGE - 2) 
+#define HASH_TABLESIZE (1 << HASH_LOG) 
+#define HASH_MASK (HASH_TABLESIZE - 1) 
+ 
+#define KNUTH 2654435761 
+ 
+#define BIT7 128 
+#define BIT6  64 
+#define BIT5  32 
+#define BIT4  16 
+#define BIT1   2 
+#define BIT0   1 
+ 
+#define KB *(1 <<10) 
+#define MB *(1 <<20) 
+#define GB *(1U<<30) 
+ 
+#define BLOCKSIZE (128 KB)                 /* define, for static allocation */ 
+#define MIN_SEQUENCES_SIZE (2 /*seqNb*/ + 2 /*dumps*/ + 3 /*seqTables*/ + 1 /*bitStream*/) 
+#define MIN_CBLOCK_SIZE (3 /*litCSize*/ + MIN_SEQUENCES_SIZE) 
+#define IS_RAW BIT0 
+#define IS_RLE BIT1 
+ 
+#define WORKPLACESIZE (BLOCKSIZE*3) 
+#define MINMATCH 4 
+#define MLbits   7 
+#define LLbits   6 
+#define Offbits  5 
+#define MaxML  ((1<<MLbits )-1) 
+#define MaxLL  ((1<<LLbits )-1) 
+#define MaxOff   31 
+#define LitFSELog  11 
+#define MLFSELog   10 
+#define LLFSELog   10 
+#define OffFSELog   9 
+#define MAX(a,b) ((a)<(b)?(b):(a)) 
+#define MaxSeq MAX(MaxLL, MaxML) 
+ 
+#define LITERAL_NOENTROPY 63 
+#define COMMAND_NOENTROPY 7   /* to remove */ 
+ 
+static const size_t ZSTD_blockHeaderSize = 3; 
+static const size_t ZSTD_frameHeaderSize = 4; 
+ 
+ 
+/* ******************************************************* 
+*  Memory operations 
+**********************************************************/ 
+static void   ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); } 
+ 
+static void   ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); } 
+ 
+#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; } 
+ 
+/*! ZSTD_wildcopy : custom version of memcpy(), can copy up to 7-8 bytes too many */ 
+static void ZSTD_wildcopy(void* dst, const void* src, size_t length) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + length; 
+    do COPY8(op, ip) while (op < oend); 
+} 
+ 
+ 
+/* ************************************** 
+*  Local structures 
+****************************************/ 
+typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t; 
+ 
+typedef struct 
+{ 
+    blockType_t blockType; 
+    U32 origSize; 
+} blockProperties_t; 
+ 
+typedef struct { 
+    void* buffer; 
+    U32*  offsetStart; 
+    U32*  offset; 
+    BYTE* offCodeStart; 
+    BYTE* offCode; 
+    BYTE* litStart; 
+    BYTE* lit; 
+    BYTE* litLengthStart; 
+    BYTE* litLength; 
+    BYTE* matchLengthStart; 
+    BYTE* matchLength; 
+    BYTE* dumpsStart; 
+    BYTE* dumps; 
+} seqStore_t; 
+ 
+ 
+/* ************************************* 
+*  Error Management 
+***************************************/ 
+/*! ZSTD_isError 
+*   tells if a return value is an error code */ 
+static unsigned ZSTD_isError(size_t code) { return ERR_isError(code); } 
+ 
+ 
+/* ************************************* 
+*  Function body to include 
+***************************************/ 
+static size_t ZSTD_read_ARCH(const void* p) { size_t r; memcpy(&r, p, sizeof(r)); return r; } 
+ 
+MEM_STATIC unsigned ZSTD_NbCommonBytes (register size_t val) 
+{ 
+    if (MEM_isLittleEndian()) 
+    { 
+        if (MEM_64bits()) 
+        { 
+#       if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            unsigned long r = 0; 
+            _BitScanForward64( &r, (U64)val ); 
+            return (int)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            return (__builtin_ctzll((U64)val) >> 3); 
+#       else 
+            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 0, 3, 1, 3, 1, 4, 2, 7, 0, 2, 3, 6, 1, 5, 3, 5, 1, 3, 4, 4, 2, 5, 6, 7, 7, 0, 1, 2, 3, 3, 4, 6, 2, 6, 5, 5, 3, 4, 5, 6, 7, 1, 2, 4, 6, 4, 4, 5, 7, 2, 6, 5, 7, 6, 7, 7 }; 
+            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58]; 
+#       endif 
+        } 
+        else /* 32 bits */ 
+        { 
+#       if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            unsigned long r; 
+            _BitScanForward( &r, (U32)val ); 
+            return (int)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            return (__builtin_ctz((U32)val) >> 3); 
+#       else 
+            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 3, 2, 2, 1, 3, 2, 0, 1, 3, 3, 1, 2, 2, 2, 2, 0, 3, 1, 2, 0, 1, 0, 1, 1 }; 
+            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27]; 
+#       endif 
+        } 
+    } 
+    else   /* Big Endian CPU */ 
+    { 
+        if (MEM_32bits()) 
+        { 
+#       if defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            unsigned long r = 0; 
+            _BitScanReverse64( &r, val ); 
+            return (unsigned)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            return (__builtin_clzll(val) >> 3); 
+#       else 
+            unsigned r; 
+            const unsigned n32 = sizeof(size_t)*4;   /* calculate this way due to compiler complaining in 32-bits mode */ 
+            if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; } 
+            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; } 
+            r += (!val); 
+            return r; 
+#       endif 
+        } 
+        else /* 32 bits */ 
+        { 
+#       if defined(_MSC_VER) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            unsigned long r = 0; 
+            _BitScanReverse( &r, (unsigned long)val ); 
+            return (unsigned)(r>>3); 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) && !defined(LZ4_FORCE_SW_BITCOUNT) 
+            return (__builtin_clz((U32)val) >> 3); 
+#       else 
+            unsigned r; 
+            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; } 
+            r += (!val); 
+            return r; 
+#       endif 
+        } 
+    } 
+} 
+ 
+ 
+MEM_STATIC size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit) 
+{ 
+    const BYTE* const pStart = pIn; 
+ 
+    while ((pIn<pInLimit-(sizeof(size_t)-1))) 
+    { 
+        size_t diff = ZSTD_read_ARCH(pMatch) ^ ZSTD_read_ARCH(pIn); 
+        if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; } 
+        pIn += ZSTD_NbCommonBytes(diff); 
+        return (size_t)(pIn - pStart); 
+    } 
+ 
+    if (MEM_32bits()) if ((pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; } 
+    if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; } 
+    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++; 
+    return (size_t)(pIn - pStart); 
+} 
+ 
+ 
+/* ************************************************************* 
+*   Decompression section 
+***************************************************************/ 
+struct ZSTD_DCtx_s 
+{ 
+    U32 LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)]; 
+    U32 OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)]; 
+    U32 MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)]; 
+    void* previousDstEnd; 
+    void* base; 
+    size_t expected; 
+    blockType_t bType; 
+    U32 phase; 
+    const BYTE* litPtr; 
+    size_t litBufSize; 
+    size_t litSize; 
+    BYTE litBuffer[BLOCKSIZE + 8 /* margin for wildcopy */]; 
+};   /* typedef'd to ZSTD_Dctx within "zstd_static.h" */ 
+ 
+ 
+static size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr) 
+{ 
+    const BYTE* const in = (const BYTE* const)src; 
+    BYTE headerFlags; 
+    U32 cSize; 
+ 
+    if (srcSize < 3) return ERROR(srcSize_wrong); 
+ 
+    headerFlags = *in; 
+    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16); 
+ 
+    bpPtr->blockType = (blockType_t)(headerFlags >> 6); 
+    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0; 
+ 
+    if (bpPtr->blockType == bt_end) return 0; 
+    if (bpPtr->blockType == bt_rle) return 1; 
+    return cSize; 
+} 
+ 
+static size_t ZSTD_copyUncompressedBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall); 
+    memcpy(dst, src, srcSize); 
+    return srcSize; 
+} 
+ 
+ 
+/** ZSTD_decompressLiterals 
+    @return : nb of bytes read from src, or an error code*/ 
+static size_t ZSTD_decompressLiterals(void* dst, size_t* maxDstSizePtr, 
+                                const void* src, size_t srcSize) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+ 
+    const size_t litSize = (MEM_readLE32(src) & 0x1FFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */ 
+    const size_t litCSize = (MEM_readLE32(ip+2) & 0xFFFFFF) >> 5;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */ 
+ 
+    if (litSize > *maxDstSizePtr) return ERROR(corruption_detected); 
+    if (litCSize + 5 > srcSize) return ERROR(corruption_detected); 
+ 
+    if (HUF_isError(HUF_decompress(dst, litSize, ip+5, litCSize))) return ERROR(corruption_detected); 
+ 
+    *maxDstSizePtr = litSize; 
+    return litCSize + 5; 
+} 
+ 
+ 
+/** ZSTD_decodeLiteralsBlock 
+    @return : nb of bytes read from src (< srcSize )*/ 
+static size_t ZSTD_decodeLiteralsBlock(void* ctx, 
+                          const void* src, size_t srcSize) 
+{ 
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)ctx; 
+    const BYTE* const istart = (const BYTE* const)src; 
+ 
+    /* any compressed block with literals segment must be at least this size */ 
+    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected); 
+ 
+    switch(*istart & 3) 
+    { 
+    default: 
+    case 0: 
+        { 
+            size_t litSize = BLOCKSIZE; 
+            const size_t readSize = ZSTD_decompressLiterals(dctx->litBuffer, &litSize, src, srcSize); 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litBufSize = BLOCKSIZE; 
+            dctx->litSize = litSize; 
+            return readSize;   /* works if it's an error too */ 
+        } 
+    case IS_RAW: 
+        { 
+            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */ 
+            if (litSize > srcSize-11)   /* risk of reading too far with wildcopy */ 
+            { 
+				if (litSize > srcSize-3) return ERROR(corruption_detected); 
+				memcpy(dctx->litBuffer, istart, litSize); 
+				dctx->litPtr = dctx->litBuffer; 
+				dctx->litBufSize = BLOCKSIZE; 
+				dctx->litSize = litSize; 
+				return litSize+3; 
+			} 
+			/* direct reference into compressed stream */ 
+            dctx->litPtr = istart+3; 
+            dctx->litBufSize = srcSize-3; 
+            dctx->litSize = litSize; 
+            return litSize+3; 
+        } 
+    case IS_RLE: 
+        { 
+            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */ 
+            if (litSize > BLOCKSIZE) return ERROR(corruption_detected); 
+            memset(dctx->litBuffer, istart[3], litSize); 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litBufSize = BLOCKSIZE; 
+            dctx->litSize = litSize; 
+            return 4; 
+        } 
+    } 
+} 
+ 
+ 
+static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr, 
+                         FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb, 
+                         const void* src, size_t srcSize) 
+{ 
+    const BYTE* const istart = (const BYTE* const)src; 
+    const BYTE* ip = istart; 
+    const BYTE* const iend = istart + srcSize; 
+    U32 LLtype, Offtype, MLtype; 
+    U32 LLlog, Offlog, MLlog; 
+    size_t dumpsLength; 
+ 
+    /* check */ 
+    if (srcSize < 5) return ERROR(srcSize_wrong); 
+ 
+    /* SeqHead */ 
+    *nbSeq = MEM_readLE16(ip); ip+=2; 
+    LLtype  = *ip >> 6; 
+    Offtype = (*ip >> 4) & 3; 
+    MLtype  = (*ip >> 2) & 3; 
+    if (*ip & 2) 
+    { 
+        dumpsLength  = ip[2]; 
+        dumpsLength += ip[1] << 8; 
+        ip += 3; 
+    } 
+    else 
+    { 
+        dumpsLength  = ip[1]; 
+        dumpsLength += (ip[0] & 1) << 8; 
+        ip += 2; 
+    } 
+    *dumpsPtr = ip; 
+    ip += dumpsLength; 
+    *dumpsLengthPtr = dumpsLength; 
+ 
+    /* check */ 
+    if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */ 
+ 
+    /* sequences */ 
+    { 
+        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL and MaxOff */ 
+        size_t headerSize; 
+ 
+        /* Build DTables */ 
+        switch(LLtype) 
+        { 
+        U32 max; 
+        case bt_rle : 
+            LLlog = 0; 
+            FSE_buildDTable_rle(DTableLL, *ip++); break; 
+        case bt_raw : 
+            LLlog = LLbits; 
+            FSE_buildDTable_raw(DTableLL, LLbits); break; 
+        default : 
+            max = MaxLL; 
+            headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip); 
+            if (FSE_isError(headerSize)) return ERROR(GENERIC); 
+            if (LLlog > LLFSELog) return ERROR(corruption_detected); 
+            ip += headerSize; 
+            FSE_buildDTable(DTableLL, norm, max, LLlog); 
+        } 
+ 
+        switch(Offtype) 
+        { 
+        U32 max; 
+        case bt_rle : 
+            Offlog = 0; 
+            if (ip > iend-2) return ERROR(srcSize_wrong);   /* min : "raw", hence no header, but at least xxLog bits */ 
+            FSE_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */ 
+            break; 
+        case bt_raw : 
+            Offlog = Offbits; 
+            FSE_buildDTable_raw(DTableOffb, Offbits); break; 
+        default : 
+            max = MaxOff; 
+            headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip); 
+            if (FSE_isError(headerSize)) return ERROR(GENERIC); 
+            if (Offlog > OffFSELog) return ERROR(corruption_detected); 
+            ip += headerSize; 
+            FSE_buildDTable(DTableOffb, norm, max, Offlog); 
+        } 
+ 
+        switch(MLtype) 
+        { 
+        U32 max; 
+        case bt_rle : 
+            MLlog = 0; 
+            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */ 
+            FSE_buildDTable_rle(DTableML, *ip++); break; 
+        case bt_raw : 
+            MLlog = MLbits; 
+            FSE_buildDTable_raw(DTableML, MLbits); break; 
+        default : 
+            max = MaxML; 
+            headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip); 
+            if (FSE_isError(headerSize)) return ERROR(GENERIC); 
+            if (MLlog > MLFSELog) return ERROR(corruption_detected); 
+            ip += headerSize; 
+            FSE_buildDTable(DTableML, norm, max, MLlog); 
+        } 
+    } 
+ 
+    return ip-istart; 
+} 
+ 
+ 
+typedef struct { 
+    size_t litLength; 
+    size_t offset; 
+    size_t matchLength; 
+} seq_t; 
+ 
+typedef struct { 
+    BIT_DStream_t DStream; 
+    FSE_DState_t stateLL; 
+    FSE_DState_t stateOffb; 
+    FSE_DState_t stateML; 
+    size_t prevOffset; 
+    const BYTE* dumps; 
+    const BYTE* dumpsEnd; 
+} seqState_t; 
+ 
+ 
+static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState) 
+{ 
+    size_t litLength; 
+    size_t prevOffset; 
+    size_t offset; 
+    size_t matchLength; 
+    const BYTE* dumps = seqState->dumps; 
+    const BYTE* const de = seqState->dumpsEnd; 
+ 
+    /* Literal length */ 
+    litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream)); 
+    prevOffset = litLength ? seq->offset : seqState->prevOffset; 
+    seqState->prevOffset = seq->offset; 
+    if (litLength == MaxLL) 
+    { 
+        U32 add = *dumps++; 
+        if (add < 255) litLength += add; 
+        else 
+        { 
+            litLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */ 
+            dumps += 3; 
+        } 
+        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */ 
+    } 
+ 
+    /* Offset */ 
+    { 
+        static const size_t offsetPrefix[MaxOff+1] = {  /* note : size_t faster than U32 */ 
+                1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256, 
+                512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 
+                524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 }; 
+        U32 offsetCode, nbBits; 
+        offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream));   /* <= maxOff, by table construction */ 
+        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream)); 
+        nbBits = offsetCode - 1; 
+        if (offsetCode==0) nbBits = 0;   /* cmove */ 
+        offset = offsetPrefix[offsetCode] + BIT_readBits(&(seqState->DStream), nbBits); 
+        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream)); 
+        if (offsetCode==0) offset = prevOffset;   /* cmove */ 
+    } 
+ 
+    /* MatchLength */ 
+    matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream)); 
+    if (matchLength == MaxML) 
+    { 
+        U32 add = *dumps++; 
+        if (add < 255) matchLength += add; 
+        else 
+        { 
+            matchLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */ 
+            dumps += 3; 
+        } 
+        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */ 
+    } 
+    matchLength += MINMATCH; 
+ 
+    /* save result */ 
+    seq->litLength = litLength; 
+    seq->offset = offset; 
+    seq->matchLength = matchLength; 
+    seqState->dumps = dumps; 
+} 
+ 
+ 
+static size_t ZSTD_execSequence(BYTE* op, 
+                                seq_t sequence, 
+                                const BYTE** litPtr, const BYTE* const litLimit, 
+                                BYTE* const base, BYTE* const oend) 
+{ 
+    static const int dec32table[] = {0, 1, 2, 1, 4, 4, 4, 4};   /* added */ 
+    static const int dec64table[] = {8, 8, 8, 7, 8, 9,10,11};   /* substracted */ 
+    const BYTE* const ostart = op; 
+    BYTE* const oLitEnd = op + sequence.litLength; 
+    BYTE* const oMatchEnd = op + sequence.litLength + sequence.matchLength;   /* risk : address space overflow (32-bits) */ 
+    BYTE* const oend_8 = oend-8; 
+    const BYTE* const litEnd = *litPtr + sequence.litLength; 
+ 
+    /* checks */ 
+    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */ 
+    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */ 
+    if (litEnd > litLimit-8) return ERROR(corruption_detected);   /* overRead beyond lit buffer */ 
+ 
+    /* copy Literals */ 
+    ZSTD_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */ 
+    op = oLitEnd; 
+    *litPtr = litEnd;   /* update for next sequence */ 
+ 
+    /* copy Match */ 
+    { 
+        const BYTE* match = op - sequence.offset; 
+ 
+        /* check */ 
+        if (sequence.offset > (size_t)op) return ERROR(corruption_detected);   /* address space overflow test (this test seems kept by clang optimizer) */ 
+        //if (match > op) return ERROR(corruption_detected);   /* address space overflow test (is clang optimizer removing this test ?) */ 
+        if (match < base) return ERROR(corruption_detected); 
+ 
+        /* close range match, overlap */ 
+        if (sequence.offset < 8) 
+        { 
+            const int dec64 = dec64table[sequence.offset]; 
+            op[0] = match[0]; 
+            op[1] = match[1]; 
+            op[2] = match[2]; 
+            op[3] = match[3]; 
+            match += dec32table[sequence.offset]; 
+            ZSTD_copy4(op+4, match); 
+            match -= dec64; 
+        } 
+        else 
+        { 
+            ZSTD_copy8(op, match); 
+        } 
+        op += 8; match += 8; 
+ 
+        if (oMatchEnd > oend-12) 
+        { 
+            if (op < oend_8) 
+            { 
+                ZSTD_wildcopy(op, match, oend_8 - op); 
+                match += oend_8 - op; 
+                op = oend_8; 
+            } 
+            while (op < oMatchEnd) *op++ = *match++; 
+        } 
+        else 
+        { 
+            ZSTD_wildcopy(op, match, sequence.matchLength-8);   /* works even if matchLength < 8 */ 
+        } 
+    } 
+ 
+    return oMatchEnd - ostart; 
+} 
+ 
+static size_t ZSTD_decompressSequences( 
+                               void* ctx, 
+                               void* dst, size_t maxDstSize, 
+                         const void* seqStart, size_t seqSize) 
+{ 
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)ctx; 
+    const BYTE* ip = (const BYTE*)seqStart; 
+    const BYTE* const iend = ip + seqSize; 
+    BYTE* const ostart = (BYTE* const)dst; 
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + maxDstSize; 
+    size_t errorCode, dumpsLength; 
+    const BYTE* litPtr = dctx->litPtr; 
+    const BYTE* const litMax = litPtr + dctx->litBufSize; 
+    const BYTE* const litEnd = litPtr + dctx->litSize; 
+    int nbSeq; 
+    const BYTE* dumps; 
+    U32* DTableLL = dctx->LLTable; 
+    U32* DTableML = dctx->MLTable; 
+    U32* DTableOffb = dctx->OffTable; 
+    BYTE* const base = (BYTE*) (dctx->base); 
+ 
+    /* Build Decoding Tables */ 
+    errorCode = ZSTD_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength, 
+                                      DTableLL, DTableML, DTableOffb, 
+                                      ip, iend-ip); 
+    if (ZSTD_isError(errorCode)) return errorCode; 
+    ip += errorCode; 
+ 
+    /* Regen sequences */ 
+    { 
+        seq_t sequence; 
+        seqState_t seqState; 
+ 
+        memset(&sequence, 0, sizeof(sequence)); 
+        seqState.dumps = dumps; 
+        seqState.dumpsEnd = dumps + dumpsLength; 
+        seqState.prevOffset = sequence.offset = 4; 
+        errorCode = BIT_initDStream(&(seqState.DStream), ip, iend-ip); 
+        if (ERR_isError(errorCode)) return ERROR(corruption_detected); 
+        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL); 
+        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb); 
+        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML); 
+ 
+        for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (nbSeq>0) ; ) 
+        { 
+            size_t oneSeqSize; 
+            nbSeq--; 
+            ZSTD_decodeSequence(&sequence, &seqState); 
+            oneSeqSize = ZSTD_execSequence(op, sequence, &litPtr, litMax, base, oend); 
+            if (ZSTD_isError(oneSeqSize)) return oneSeqSize; 
+            op += oneSeqSize; 
+        } 
+ 
+        /* check if reached exact end */ 
+        if ( !BIT_endOfDStream(&(seqState.DStream)) ) return ERROR(corruption_detected);   /* requested too much : data is corrupted */ 
+        if (nbSeq<0) return ERROR(corruption_detected);   /* requested too many sequences : data is corrupted */ 
+ 
+        /* last literal segment */ 
+        { 
+            size_t lastLLSize = litEnd - litPtr; 
+            if (litPtr > litEnd) return ERROR(corruption_detected); 
+            if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall); 
+            if (op != litPtr) memmove(op, litPtr, lastLLSize); 
+            op += lastLLSize; 
+        } 
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+static size_t ZSTD_decompressBlock( 
+                            void* ctx, 
+                            void* dst, size_t maxDstSize, 
+                      const void* src, size_t srcSize) 
+{ 
+    /* blockType == blockCompressed */ 
+    const BYTE* ip = (const BYTE*)src; 
+ 
+    /* Decode literals sub-block */ 
+    size_t litCSize = ZSTD_decodeLiteralsBlock(ctx, src, srcSize); 
+    if (ZSTD_isError(litCSize)) return litCSize; 
+    ip += litCSize; 
+    srcSize -= litCSize; 
+ 
+    return ZSTD_decompressSequences(ctx, dst, maxDstSize, ip, srcSize); 
+} 
+ 
+ 
+static size_t ZSTD_decompressDCtx(void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    const BYTE* iend = ip + srcSize; 
+    BYTE* const ostart = (BYTE* const)dst; 
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + maxDstSize; 
+    size_t remainingSize = srcSize; 
+    U32 magicNumber; 
+    blockProperties_t blockProperties; 
+ 
+    /* Frame Header */ 
+    if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong); 
+    magicNumber = MEM_readLE32(src); 
+    if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown); 
+    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize; 
+ 
+    /* Loop on each block */ 
+    while (1) 
+    { 
+        size_t decodedSize=0; 
+        size_t cBlockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties); 
+        if (ZSTD_isError(cBlockSize)) return cBlockSize; 
+ 
+        ip += ZSTD_blockHeaderSize; 
+        remainingSize -= ZSTD_blockHeaderSize; 
+        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong); 
+ 
+        switch(blockProperties.blockType) 
+        { 
+        case bt_compressed: 
+            decodedSize = ZSTD_decompressBlock(ctx, op, oend-op, ip, cBlockSize); 
+            break; 
+        case bt_raw : 
+            decodedSize = ZSTD_copyUncompressedBlock(op, oend-op, ip, cBlockSize); 
+            break; 
+        case bt_rle : 
+            return ERROR(GENERIC);   /* not yet supported */ 
+            break; 
+        case bt_end : 
+            /* end of frame */ 
+            if (remainingSize) return ERROR(srcSize_wrong); 
+            break; 
+        default: 
+            return ERROR(GENERIC);   /* impossible */ 
+        } 
+        if (cBlockSize == 0) break;   /* bt_end */ 
+ 
+        if (ZSTD_isError(decodedSize)) return decodedSize; 
+        op += decodedSize; 
+        ip += cBlockSize; 
+        remainingSize -= cBlockSize; 
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+static size_t ZSTD_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    ZSTD_DCtx ctx; 
+    ctx.base = dst; 
+    return ZSTD_decompressDCtx(&ctx, dst, maxDstSize, src, srcSize); 
+} 
+ 
+ 
+/******************************* 
+*  Streaming Decompression API 
+*******************************/ 
+ 
+static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx) 
+{ 
+    dctx->expected = ZSTD_frameHeaderSize; 
+    dctx->phase = 0; 
+    dctx->previousDstEnd = NULL; 
+    dctx->base = NULL; 
+    return 0; 
+} 
+ 
+static ZSTD_DCtx* ZSTD_createDCtx(void) 
+{ 
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)malloc(sizeof(ZSTD_DCtx)); 
+    if (dctx==NULL) return NULL; 
+    ZSTD_resetDCtx(dctx); 
+    return dctx; 
+} 
+ 
+static size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx) 
+{ 
+    free(dctx); 
+    return 0; 
+} 
+ 
+static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) 
+{ 
+    return dctx->expected; 
+} 
+ 
+static size_t ZSTD_decompressContinue(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    /* Sanity check */ 
+    if (srcSize != ctx->expected) return ERROR(srcSize_wrong); 
+    if (dst != ctx->previousDstEnd)  /* not contiguous */ 
+        ctx->base = dst; 
+ 
+    /* Decompress : frame header */ 
+    if (ctx->phase == 0) 
+    { 
+        /* Check frame magic header */ 
+        U32 magicNumber = MEM_readLE32(src); 
+        if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown); 
+        ctx->phase = 1; 
+        ctx->expected = ZSTD_blockHeaderSize; 
+        return 0; 
+    } 
+ 
+    /* Decompress : block header */ 
+    if (ctx->phase == 1) 
+    { 
+        blockProperties_t bp; 
+        size_t blockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp); 
+        if (ZSTD_isError(blockSize)) return blockSize; 
+        if (bp.blockType == bt_end) 
+        { 
+            ctx->expected = 0; 
+            ctx->phase = 0; 
+        } 
+        else 
+        { 
+            ctx->expected = blockSize; 
+            ctx->bType = bp.blockType; 
+            ctx->phase = 2; 
+        } 
+ 
+        return 0; 
+    } 
+ 
+    /* Decompress : block content */ 
+    { 
+        size_t rSize; 
+        switch(ctx->bType) 
+        { 
+        case bt_compressed: 
+            rSize = ZSTD_decompressBlock(ctx, dst, maxDstSize, src, srcSize); 
+            break; 
+        case bt_raw : 
+            rSize = ZSTD_copyUncompressedBlock(dst, maxDstSize, src, srcSize); 
+            break; 
+        case bt_rle : 
+            return ERROR(GENERIC);   /* not yet handled */ 
+            break; 
+        case bt_end :   /* should never happen (filtered at phase 1) */ 
+            rSize = 0; 
+            break; 
+        default: 
+            return ERROR(GENERIC); 
+        } 
+        ctx->phase = 1; 
+        ctx->expected = ZSTD_blockHeaderSize; 
+        ctx->previousDstEnd = (void*)( ((char*)dst) + rSize); 
+        return rSize; 
+    } 
+ 
+} 
+ 
+ 
+/* wrapper layer */ 
+ 
+unsigned ZSTDv03_isError(size_t code) 
+{ 
+	return ZSTD_isError(code); 
+} 
+ 
+size_t ZSTDv03_decompress( void* dst, size_t maxOriginalSize, 
+                     const void* src, size_t compressedSize) 
+{ 
+	return ZSTD_decompress(dst, maxOriginalSize, src, compressedSize); 
+} 
+ 
+ZSTDv03_Dctx* ZSTDv03_createDCtx(void) 
+{ 
+	return (ZSTDv03_Dctx*)ZSTD_createDCtx(); 
+} 
+ 
+size_t ZSTDv03_freeDCtx(ZSTDv03_Dctx* dctx) 
+{ 
+	return ZSTD_freeDCtx((ZSTD_DCtx*)dctx); 
+} 
+ 
+size_t ZSTDv03_resetDCtx(ZSTDv03_Dctx* dctx) 
+{ 
+	return ZSTD_resetDCtx((ZSTD_DCtx*)dctx); 
+} 
+ 
+size_t ZSTDv03_nextSrcSizeToDecompress(ZSTDv03_Dctx* dctx) 
+{ 
+	return ZSTD_nextSrcSizeToDecompress((ZSTD_DCtx*)dctx); 
+} 
+ 
+size_t ZSTDv03_decompressContinue(ZSTDv03_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+	return ZSTD_decompressContinue((ZSTD_DCtx*)dctx, dst, maxDstSize, src, srcSize); 
+} 
diff --git a/contrib/libs/zstd06/legacy/zstd_v03.h b/contrib/libs/zstd06/legacy/zstd_v03.h
index 38b1f6eb98..7607f343c9 100644
--- a/contrib/libs/zstd06/legacy/zstd_v03.h
+++ b/contrib/libs/zstd06/legacy/zstd_v03.h
@@ -1,100 +1,100 @@
 #include <contrib/libs/zstd06/renames.h>
-/*
-    zstd_v03 - decoder for 0.3 format
-    Header File
-    Copyright (C) 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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-#pragma once
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* *************************************
-*  Includes
-***************************************/
-#include <stddef.h>   /* size_t */
-
-
-/* *************************************
-*  Simple one-step function
-***************************************/
-/**
-ZSTDv03_decompress() : decompress ZSTD frames compliant with v0.3.x format
-    compressedSize : is the exact source size
-    maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated.
-                      It must be equal or larger than originalSize, otherwise decompression will fail.
-    return : the number of bytes decompressed into destination buffer (originalSize)
-             or an errorCode if it fails (which can be tested using ZSTDv01_isError())
-*/
-size_t ZSTDv03_decompress( void* dst, size_t maxOriginalSize,
-                     const void* src, size_t compressedSize);
-
-/**
-ZSTDv03_isError() : tells if the result of ZSTDv03_decompress() is an error
-*/
-unsigned ZSTDv03_isError(size_t code);
-
-
-/* *************************************
-*  Advanced functions
-***************************************/
-typedef struct ZSTDv03_Dctx_s ZSTDv03_Dctx;
-ZSTDv03_Dctx* ZSTDv03_createDCtx(void);
-size_t ZSTDv03_freeDCtx(ZSTDv03_Dctx* dctx);
-
-size_t ZSTDv03_decompressDCtx(void* ctx,
-                              void* dst, size_t maxOriginalSize,
-                        const void* src, size_t compressedSize);
-
-/* *************************************
-*  Streaming functions
-***************************************/
-size_t ZSTDv03_resetDCtx(ZSTDv03_Dctx* dctx);
-
-size_t ZSTDv03_nextSrcSizeToDecompress(ZSTDv03_Dctx* dctx);
-size_t ZSTDv03_decompressContinue(ZSTDv03_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
-/**
-  Use above functions alternatively.
-  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
-  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
-  Result is the number of bytes regenerated within 'dst'.
-  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
-*/
-
-/* *************************************
-*  Prefix - version detection
-***************************************/
-#define ZSTDv03_magicNumber 0xFD2FB523   /* v0.3 */
-
-
-#if defined (__cplusplus)
-}
-#endif
+/* 
+    zstd_v03 - decoder for 0.3 format 
+    Header File 
+    Copyright (C) 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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+#pragma once 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/* ************************************* 
+*  Includes 
+***************************************/ 
+#include <stddef.h>   /* size_t */ 
+ 
+ 
+/* ************************************* 
+*  Simple one-step function 
+***************************************/ 
+/** 
+ZSTDv03_decompress() : decompress ZSTD frames compliant with v0.3.x format 
+    compressedSize : is the exact source size 
+    maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated. 
+                      It must be equal or larger than originalSize, otherwise decompression will fail. 
+    return : the number of bytes decompressed into destination buffer (originalSize) 
+             or an errorCode if it fails (which can be tested using ZSTDv01_isError()) 
+*/ 
+size_t ZSTDv03_decompress( void* dst, size_t maxOriginalSize, 
+                     const void* src, size_t compressedSize); 
+ 
+/** 
+ZSTDv03_isError() : tells if the result of ZSTDv03_decompress() is an error 
+*/ 
+unsigned ZSTDv03_isError(size_t code); 
+ 
+ 
+/* ************************************* 
+*  Advanced functions 
+***************************************/ 
+typedef struct ZSTDv03_Dctx_s ZSTDv03_Dctx; 
+ZSTDv03_Dctx* ZSTDv03_createDCtx(void); 
+size_t ZSTDv03_freeDCtx(ZSTDv03_Dctx* dctx); 
+ 
+size_t ZSTDv03_decompressDCtx(void* ctx, 
+                              void* dst, size_t maxOriginalSize, 
+                        const void* src, size_t compressedSize); 
+ 
+/* ************************************* 
+*  Streaming functions 
+***************************************/ 
+size_t ZSTDv03_resetDCtx(ZSTDv03_Dctx* dctx); 
+ 
+size_t ZSTDv03_nextSrcSizeToDecompress(ZSTDv03_Dctx* dctx); 
+size_t ZSTDv03_decompressContinue(ZSTDv03_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize); 
+/** 
+  Use above functions alternatively. 
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue(). 
+  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block. 
+  Result is the number of bytes regenerated within 'dst'. 
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header. 
+*/ 
+ 
+/* ************************************* 
+*  Prefix - version detection 
+***************************************/ 
+#define ZSTDv03_magicNumber 0xFD2FB523   /* v0.3 */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
diff --git a/contrib/libs/zstd06/legacy/zstd_v04.c b/contrib/libs/zstd06/legacy/zstd_v04.c
index 66a47e7a12..0c72bcf43c 100644
--- a/contrib/libs/zstd06/legacy/zstd_v04.c
+++ b/contrib/libs/zstd06/legacy/zstd_v04.c
@@ -1,3625 +1,3625 @@
-/* ******************************************************************
-   zstd_v04.c
-   Decompression module for ZSTD v0.4 legacy format
-   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 :
-    - Homepage : http://www.zstd.net/
-****************************************************************** */
-
-/*- Dependencies -*/
-#include "zstd_v04.h"
-
-
-/* ******************************************************************
-   mem.h
-   low-level memory access routines
-   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
-****************************************************************** */
-#ifndef MEM_H_MODULE
-#define MEM_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/******************************************
-*  Includes
-******************************************/
-#include <stddef.h>    /* size_t, ptrdiff_t */
-#include <string.h>    /* memcpy */
-
-
-/******************************************
-*  Compiler-specific
-******************************************/
-#if defined(__GNUC__)
-#  define MEM_STATIC static __attribute__((unused))
-#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#  define MEM_STATIC static inline
-#elif defined(_MSC_VER)
-#  define MEM_STATIC static __inline
-#else
-#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
-#endif
-
-
-/****************************************************************
-*  Basic Types
-*****************************************************************/
-#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-# include <stdint.h>
-  typedef  uint8_t BYTE;
-  typedef uint16_t U16;
-  typedef  int16_t S16;
-  typedef uint32_t U32;
-  typedef  int32_t S32;
-  typedef uint64_t U64;
-  typedef  int64_t S64;
-#else
-  typedef unsigned char       BYTE;
-  typedef unsigned short      U16;
-  typedef   signed short      S16;
-  typedef unsigned int        U32;
-  typedef   signed int        S32;
-  typedef unsigned long long  U64;
-  typedef   signed long long  S64;
-#endif
-
-
-/****************************************************************
-*  Memory I/O
-*****************************************************************/
-/* MEM_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 is portable but violate C standard.
- *            It can generate buggy code on targets generating assembly depending on alignment.
- *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
- * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
- * Prefer these methods in priority order (0 > 1 > 2)
- */
-#ifndef MEM_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 MEM_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 MEM_FORCE_MEMORY_ACCESS 1
-#  endif
-#endif
-
-MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }
-MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }
-
-MEM_STATIC unsigned MEM_isLittleEndian(void)
-{
-    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
-    return one.c[0];
-}
-
-#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)
-
-/* violates C standard on structure alignment.
-Only use if no other choice to achieve best performance on target platform */
-MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
-MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
-MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
-MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
-MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }
-
-#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_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 { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign;
-
-MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
-MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
-MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
-MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; }
-MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign*)memPtr)->u64 = value; }
-
-#else
-
-/* default method, safe and standard.
-   can sometimes prove slower */
-
-MEM_STATIC U16 MEM_read16(const void* memPtr)
-{
-    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC U32 MEM_read32(const void* memPtr)
-{
-    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC U64 MEM_read64(const void* memPtr)
-{
-    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-MEM_STATIC void MEM_write32(void* memPtr, U32 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-MEM_STATIC void MEM_write64(void* memPtr, U64 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-#endif // MEM_FORCE_MEMORY_ACCESS
-
-
-MEM_STATIC U16 MEM_readLE16(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read16(memPtr);
-    else
-    {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U16)(p[0] + (p[1]<<8));
-    }
-}
-
-MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
-{
-    if (MEM_isLittleEndian())
-    {
-        MEM_write16(memPtr, val);
-    }
-    else
-    {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE)val;
-        p[1] = (BYTE)(val>>8);
-    }
-}
-
-MEM_STATIC U32 MEM_readLE32(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read32(memPtr);
-    else
-    {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));
-    }
-}
-
-MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)
-{
-    if (MEM_isLittleEndian())
-    {
-        MEM_write32(memPtr, val32);
-    }
-    else
-    {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE)val32;
-        p[1] = (BYTE)(val32>>8);
-        p[2] = (BYTE)(val32>>16);
-        p[3] = (BYTE)(val32>>24);
-    }
-}
-
-MEM_STATIC U64 MEM_readLE64(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read64(memPtr);
-    else
-    {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)
-                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));
-    }
-}
-
-MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)
-{
-    if (MEM_isLittleEndian())
-    {
-        MEM_write64(memPtr, val64);
-    }
-    else
-    {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE)val64;
-        p[1] = (BYTE)(val64>>8);
-        p[2] = (BYTE)(val64>>16);
-        p[3] = (BYTE)(val64>>24);
-        p[4] = (BYTE)(val64>>32);
-        p[5] = (BYTE)(val64>>40);
-        p[6] = (BYTE)(val64>>48);
-        p[7] = (BYTE)(val64>>56);
-    }
-}
-
-MEM_STATIC size_t MEM_readLEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readLE32(memPtr);
-    else
-        return (size_t)MEM_readLE64(memPtr);
-}
-
-MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val)
-{
-    if (MEM_32bits())
-        MEM_writeLE32(memPtr, (U32)val);
-    else
-        MEM_writeLE64(memPtr, (U64)val);
-}
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* MEM_H_MODULE */
-
-/* ******************************************************************
-   Error codes list
-   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 :
-   - Source repository : https://github.com/Cyan4973/zstd
-****************************************************************** */
-#ifndef ERROR_PUBLIC_H_MODULE
-#define ERROR_PUBLIC_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* ****************************************
-*  error list
-******************************************/
-enum {
-  ZSTD_error_No_Error,
-  ZSTD_error_GENERIC,
-  ZSTD_error_prefix_unknown,
-  ZSTD_error_frameParameter_unsupported,
-  ZSTD_error_frameParameter_unsupportedBy32bitsImplementation,
-  ZSTD_error_init_missing,
-  ZSTD_error_memory_allocation,
-  ZSTD_error_stage_wrong,
-  ZSTD_error_dstSize_tooSmall,
-  ZSTD_error_srcSize_wrong,
-  ZSTD_error_corruption_detected,
-  ZSTD_error_tableLog_tooLarge,
-  ZSTD_error_maxSymbolValue_tooLarge,
-  ZSTD_error_maxSymbolValue_tooSmall,
-  ZSTD_error_maxCode
-};
-
-/* note : functions provide error codes in reverse negative order,
-          so compare with (size_t)(0-enum) */
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* ERROR_PUBLIC_H_MODULE */
-
-
-
-/*
-    zstd - standard compression library
-    Header File for static linking only
-    Copyright (C) 2014-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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-#ifndef ZSTD_STATIC_H
-#define ZSTD_STATIC_H
-
-/* The objects defined into this file shall be considered experimental.
- * They are not considered stable, as their prototype may change in the future.
- * You can use them for tests, provide feedback, or if you can endure risks of future changes.
- */
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* *************************************
-*  Types
-***************************************/
-#define ZSTD_WINDOWLOG_MAX 26
-#define ZSTD_WINDOWLOG_MIN 18
-#define ZSTD_WINDOWLOG_ABSOLUTEMIN 11
-#define ZSTD_CONTENTLOG_MAX (ZSTD_WINDOWLOG_MAX+1)
-#define ZSTD_CONTENTLOG_MIN 4
-#define ZSTD_HASHLOG_MAX 28
-#define ZSTD_HASHLOG_MIN 4
-#define ZSTD_SEARCHLOG_MAX (ZSTD_CONTENTLOG_MAX-1)
-#define ZSTD_SEARCHLOG_MIN 1
-#define ZSTD_SEARCHLENGTH_MAX 7
-#define ZSTD_SEARCHLENGTH_MIN 4
-
-/** from faster to stronger */
-typedef enum { ZSTD_fast, ZSTD_greedy, ZSTD_lazy, ZSTD_lazy2, ZSTD_btlazy2 } ZSTD_strategy;
-
-typedef struct
-{
-    U64 srcSize;       /* optional : tells how much bytes are present in the frame. Use 0 if not known. */
-    U32 windowLog;     /* largest match distance : larger == more compression, more memory needed during decompression */
-    U32 contentLog;    /* full search segment : larger == more compression, slower, more memory (useless for fast) */
-    U32 hashLog;       /* dispatch table : larger == more memory, faster */
-    U32 searchLog;     /* nb of searches : larger == more compression, slower */
-    U32 searchLength;  /* size of matches : larger == faster decompression, sometimes less compression */
-    ZSTD_strategy strategy;
-} ZSTD_parameters;
-
-typedef ZSTDv04_Dctx ZSTD_DCtx;
-
-/* *************************************
-*  Advanced functions
-***************************************/
-/** ZSTD_decompress_usingDict
-*   Same as ZSTD_decompressDCtx, using a Dictionary content as prefix
-*   Note : dict can be NULL, in which case, it's equivalent to ZSTD_decompressDCtx() */
-static size_t ZSTD_decompress_usingDict(ZSTD_DCtx* ctx,
-                                             void* dst, size_t maxDstSize,
-                                       const void* src, size_t srcSize,
-                                       const void* dict,size_t dictSize);
-
-
-/* **************************************
-*  Streaming functions (direct mode)
-****************************************/
-static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx);
-static size_t ZSTD_getFrameParams(ZSTD_parameters* params, const void* src, size_t srcSize);
-static void   ZSTD_decompress_insertDictionary(ZSTD_DCtx* ctx, const void* src, size_t srcSize);
-
-static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx);
-static size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
-
-/**
-  Streaming decompression, bufferless mode
-
-  A ZSTD_DCtx object is required to track streaming operations.
-  Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it.
-  A ZSTD_DCtx object can be re-used multiple times. Use ZSTD_resetDCtx() to return to fresh status.
-
-  First operation is to retrieve frame parameters, using ZSTD_getFrameParams().
-  This function doesn't consume its input. It needs enough input data to properly decode the frame header.
-  Objective is to retrieve *params.windowlog, to know minimum amount of memory required during decoding.
-  Result : 0 when successful, it means the ZSTD_parameters structure has been filled.
-           >0 : means there is not enough data into src. Provides the expected size to successfully decode header.
-           errorCode, which can be tested using ZSTD_isError() (For example, if it's not a ZSTD header)
-
-  Then, you can optionally insert a dictionary.
-  This operation must mimic the compressor behavior, otherwise decompression will fail or be corrupted.
-
-  Then it's possible to start decompression.
-  Use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively.
-  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
-  ZSTD_decompressContinue() requires this exact amount of bytes, or it will fail.
-  ZSTD_decompressContinue() needs previous data blocks during decompression, up to (1 << windowlog).
-  They should preferably be located contiguously, prior to current block. Alternatively, a round buffer is also possible.
-
-  @result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst'.
-  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
-
-  A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero.
-  Context can then be reset to start a new decompression.
-*/
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-/* ******************************************************************
-   Error codes and messages
-   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/zstd
-****************************************************************** */
-/* Note : this module is expected to remain private, do not expose it */
-
-#ifndef ERROR_H_MODULE
-#define ERROR_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* *****************************************
-*  Includes
-******************************************/
-#include <stddef.h>        /* size_t, ptrdiff_t */
-
-
-/* *****************************************
-*  Compiler-specific
-******************************************/
-#if defined(__GNUC__)
-#  define ERR_STATIC static __attribute__((unused))
-#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#  define ERR_STATIC static inline
-#elif defined(_MSC_VER)
-#  define ERR_STATIC static __inline
-#else
-#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
-#endif
-
-
-/* *****************************************
-*  Error Codes
-******************************************/
-#define PREFIX(name) ZSTD_error_##name
-
-#ifdef ERROR
-#  undef ERROR   /* reported already defined on VS 2015 by Rich Geldreich */
-#endif
-#define ERROR(name) (size_t)-PREFIX(name)
-
-ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }
-
-
-/* *****************************************
-*  Error Strings
-******************************************/
-
-ERR_STATIC const char* ERR_getErrorName(size_t code)
-{
-    static const char* codeError = "Unspecified error code";
-    switch( (size_t)(0-code) )
-    {
-    case ZSTD_error_No_Error: return "No error detected";
-    case ZSTD_error_GENERIC:  return "Error (generic)";
-    case ZSTD_error_prefix_unknown: return "Unknown frame descriptor";
-    case ZSTD_error_frameParameter_unsupported: return "Unsupported frame parameter";
-    case ZSTD_error_frameParameter_unsupportedBy32bitsImplementation: return "Frame parameter unsupported in 32-bits mode";
-    case ZSTD_error_init_missing: return "Context should be init first";
-    case ZSTD_error_memory_allocation: return "Allocation error : not enough memory";
-    case ZSTD_error_dstSize_tooSmall: return "Destination buffer is too small";
-    case ZSTD_error_srcSize_wrong: return "Src size incorrect";
-    case ZSTD_error_corruption_detected: return "Corrupted block detected";
-    case ZSTD_error_tableLog_tooLarge: return "tableLog requires too much memory";
-    case ZSTD_error_maxSymbolValue_tooLarge: return "Unsupported max possible Symbol Value : too large";
-    case ZSTD_error_maxSymbolValue_tooSmall: return "Specified maxSymbolValue is too small";
-    case ZSTD_error_maxCode:
-    default: return codeError;
-    }
-}
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* ERROR_H_MODULE */
-
-
-#endif  /* ZSTD_STATIC_H */
-
-
-/*
-    zstd_internal - common functions to include
-    Header File for include
-    Copyright (C) 2014-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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-#ifndef ZSTD_CCOMMON_H_MODULE
-#define ZSTD_CCOMMON_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* *************************************
-*  Common macros
-***************************************/
-#define MIN(a,b) ((a)<(b) ? (a) : (b))
-#define MAX(a,b) ((a)>(b) ? (a) : (b))
-
-
-/* *************************************
-*  Common constants
-***************************************/
-#define ZSTD_MAGICNUMBER 0xFD2FB524   /* v0.4 */
-
-#define KB *(1 <<10)
-#define MB *(1 <<20)
-#define GB *(1U<<30)
-
-#define BLOCKSIZE (128 KB)                 /* define, for static allocation */
-
-static const size_t ZSTD_blockHeaderSize = 3;
-static const size_t ZSTD_frameHeaderSize_min = 5;
-#define ZSTD_frameHeaderSize_max 5         /* define, for static allocation */
-
-#define BIT7 128
-#define BIT6  64
-#define BIT5  32
-#define BIT4  16
-#define BIT1   2
-#define BIT0   1
-
-#define IS_RAW BIT0
-#define IS_RLE BIT1
-
-#define MINMATCH 4
-#define REPCODE_STARTVALUE 4
-
-#define MLbits   7
-#define LLbits   6
-#define Offbits  5
-#define MaxML  ((1<<MLbits) - 1)
-#define MaxLL  ((1<<LLbits) - 1)
-#define MaxOff ((1<<Offbits)- 1)
-#define MLFSELog   10
-#define LLFSELog   10
-#define OffFSELog   9
-#define MaxSeq MAX(MaxLL, MaxML)
-
-#define MIN_SEQUENCES_SIZE (2 /*seqNb*/ + 2 /*dumps*/ + 3 /*seqTables*/ + 1 /*bitStream*/)
-#define MIN_CBLOCK_SIZE (3 /*litCSize*/ + MIN_SEQUENCES_SIZE)
-
-typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;
-
-
-/* ******************************************
-*  Shared functions to include for inlining
-********************************************/
-static void ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
-
-#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; }
-
-/*! ZSTD_wildcopy : custom version of memcpy(), can copy up to 7-8 bytes too many */
-static void ZSTD_wildcopy(void* dst, const void* src, size_t length)
-{
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + length;
-    do
-        COPY8(op, ip)
-    while (op < oend);
-}
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-
-/* ******************************************************************
-   FSE : Finite State Entropy coder
-   header file
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef FSE_H
-#define FSE_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* *****************************************
-*  Includes
-******************************************/
-#include <stddef.h>    /* size_t, ptrdiff_t */
-
-
-/* *****************************************
-*  FSE simple functions
-******************************************/
-static size_t FSE_decompress(void* dst,  size_t maxDstSize,
-                const void* cSrc, size_t cSrcSize);
-/*!
-FSE_decompress():
-    Decompress FSE data from buffer 'cSrc', of size 'cSrcSize',
-    into already allocated destination buffer 'dst', of size 'maxDstSize'.
-    return : size of regenerated data (<= maxDstSize)
-             or an error code, which can be tested using FSE_isError()
-
-    ** Important ** : FSE_decompress() doesn't decompress non-compressible nor RLE data !!!
-    Why ? : making this distinction requires a header.
-    Header management is intentionally delegated to the user layer, which can better manage special cases.
-*/
-
-
-/* *****************************************
-*  Tool functions
-******************************************/
-/* Error Management */
-static unsigned    FSE_isError(size_t code);        /* tells if a return value is an error code */
-
-
-
-/* *****************************************
-*  FSE detailed API
-******************************************/
-/*!
-FSE_compress() does the following:
-1. count symbol occurrence from source[] into table count[]
-2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog)
-3. save normalized counters to memory buffer using writeNCount()
-4. build encoding table 'CTable' from normalized counters
-5. encode the data stream using encoding table 'CTable'
-
-FSE_decompress() does the following:
-1. read normalized counters with readNCount()
-2. build decoding table 'DTable' from normalized counters
-3. decode the data stream using decoding table 'DTable'
-
-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 provide normalized distribution using external method.
-*/
-
-
-/* *** DECOMPRESSION *** */
-
-/*!
-FSE_readNCount():
-   Read compactly saved 'normalizedCounter' from 'rBuffer'.
-   return : size read from 'rBuffer'
-            or an errorCode, which can be tested using FSE_isError()
-            maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
-static  size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize);
-
-/*!
-Constructor and Destructor of type FSE_DTable
-    Note that its size depends on 'tableLog' */
-typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
-
-/*!
-FSE_buildDTable():
-   Builds 'dt', which must be already allocated, using FSE_createDTable()
-   return : 0,
-            or an errorCode, which can be tested using FSE_isError() */
-static size_t FSE_buildDTable ( FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
-
-/*!
-FSE_decompress_usingDTable():
-   Decompress compressed source 'cSrc' of size 'cSrcSize' using 'dt'
-   into 'dst' which must be already allocated.
-   return : size of regenerated data (necessarily <= maxDstSize)
-            or an errorCode, which can be tested using FSE_isError() */
-static  size_t FSE_decompress_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt);
-
-/*!
-Tutorial :
-----------
-(Note : these functions only decompress FSE-compressed blocks.
- If block is uncompressed, use memcpy() instead
- If block is a single repeated byte, use memset() instead )
-
-The first step is to obtain the normalized frequencies of symbols.
-This can be performed by FSE_readNCount() if it was saved using FSE_writeNCount().
-'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short.
-In practice, that means it's necessary to know 'maxSymbolValue' beforehand,
-or size the table to handle worst case situations (typically 256).
-FSE_readNCount() will provide 'tableLog' and 'maxSymbolValue'.
-The result of FSE_readNCount() is the number of bytes read from 'rBuffer'.
-Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that.
-If there is an error, the function will return an error code, which can be tested using FSE_isError().
-
-The next step is to build the decompression tables 'FSE_DTable' from 'normalizedCounter'.
-This is performed by the function FSE_buildDTable().
-The space required by 'FSE_DTable' must be already allocated using FSE_createDTable().
-If there is an error, the function will return an error code, which can be tested using FSE_isError().
-
-'FSE_DTable' can then be used to decompress 'cSrc', with FSE_decompress_usingDTable().
-'cSrcSize' must be strictly correct, otherwise decompression will fail.
-FSE_decompress_usingDTable() result will tell how many bytes were regenerated (<=maxDstSize).
-If there is an error, the function will return an error code, which can be tested using FSE_isError(). (ex: dst buffer too small)
-*/
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* FSE_H */
-
-
-/* ******************************************************************
-   bitstream
-   Part of NewGen Entropy library
-   header file (to include)
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef BITSTREAM_H_MODULE
-#define BITSTREAM_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/*
-*  This API consists of small unitary functions, which highly benefit from being inlined.
-*  Since link-time-optimization is not available for all compilers,
-*  these functions are defined into a .h to be included.
-*/
-
-/**********************************************
-*  bitStream decompression API (read backward)
-**********************************************/
-typedef struct
-{
-    size_t   bitContainer;
-    unsigned bitsConsumed;
-    const char* ptr;
-    const char* start;
-} BIT_DStream_t;
-
-typedef enum { BIT_DStream_unfinished = 0,
-               BIT_DStream_endOfBuffer = 1,
-               BIT_DStream_completed = 2,
-               BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */
-               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
-
-MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
-MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
-MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
-MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
-
-
-/*
-* Start by invoking BIT_initDStream().
-* A chunk of the bitStream is then stored into a local register.
-* 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 manually filled from memory by the BIT_reloadDStream() method.
-* A reload guarantee a minimum of ((8*sizeof(size_t))-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()
-*/
-
-
-/******************************************
-*  unsafe API
-******************************************/
-MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
-/* faster, but works only if nbBits >= 1 */
-
-
-
-/****************************************************************
-*  Helper functions
-****************************************************************/
-MEM_STATIC unsigned BIT_highbit32 (register U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
-    unsigned long r=0;
-    _BitScanReverse ( &r, val );
-    return (unsigned) r;
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
-    return 31 - __builtin_clz (val);
-#   else   /* Software version */
-    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
-    U32 v = val;
-    unsigned r;
-    v |= v >> 1;
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
-    return r;
-#   endif
-}
-
-
-/**********************************************************
-* bitStream decoding
-**********************************************************/
-
-/*!BIT_initDStream
-*  Initialize a BIT_DStream_t.
-*  @bitD : a pointer to an already allocated BIT_DStream_t structure
-*  @srcBuffer must point at the beginning of a bitStream
-*  @srcSize must be the exact size of the bitStream
-*  @result : size of stream (== srcSize) or an errorCode if a problem is detected
-*/
-MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
-{
-    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
-
-    if (srcSize >=  sizeof(size_t))   /* normal case */
-    {
-        U32 contain32;
-        bitD->start = (const char*)srcBuffer;
-        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t);
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);
-        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
-        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
-        bitD->bitsConsumed = 8 - BIT_highbit32(contain32);
-    }
-    else
-    {
-        U32 contain32;
-        bitD->start = (const char*)srcBuffer;
-        bitD->ptr   = bitD->start;
-        bitD->bitContainer = *(const BYTE*)(bitD->start);
-        switch(srcSize)
-        {
-            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);
-            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);
-            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);
-            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;
-            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;
-            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8;
-            default:;
-        }
-        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
-        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
-        bitD->bitsConsumed = 8 - BIT_highbit32(contain32);
-        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;
-    }
-
-    return srcSize;
-}
-
-/*!BIT_lookBits
- * Provides next n bits from local register
- * local register is not modified (bits are still present for next read/look)
- * On 32-bits, maxNbBits==25
- * On 64-bits, maxNbBits==57
- * @return : value extracted
- */
-MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)
-{
-    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
-    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
-}
-
-/*! BIT_lookBitsFast :
-*   unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits)
-{
-    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
-    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);
-}
-
-MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
-{
-    bitD->bitsConsumed += nbBits;
-}
-
-/*!BIT_readBits
- * Read next n bits from local register.
- * pay attention to not read more than nbBits contained into local register.
- * @return : extracted value.
- */
-MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
-{
-    size_t value = BIT_lookBits(bitD, nbBits);
-    BIT_skipBits(bitD, nbBits);
-    return value;
-}
-
-/*!BIT_readBitsFast :
-*  unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)
-{
-    size_t value = BIT_lookBitsFast(bitD, nbBits);
-    BIT_skipBits(bitD, nbBits);
-    return value;
-}
-
-MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
-{
-	if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
-		return BIT_DStream_overflow;
-
-    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer))
-    {
-        bitD->ptr -= bitD->bitsConsumed >> 3;
-        bitD->bitsConsumed &= 7;
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);
-        return BIT_DStream_unfinished;
-    }
-    if (bitD->ptr == bitD->start)
-    {
-        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
-        return BIT_DStream_completed;
-    }
-    {
-        U32 nbBytes = bitD->bitsConsumed >> 3;
-        BIT_DStream_status result = BIT_DStream_unfinished;
-        if (bitD->ptr - nbBytes < bitD->start)
-        {
-            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
-            result = BIT_DStream_endOfBuffer;
-        }
-        bitD->ptr -= nbBytes;
-        bitD->bitsConsumed -= nbBytes*8;
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
-        return result;
-    }
-}
-
-/*! BIT_endOfDStream
-*   @return Tells if DStream has reached its exact end
-*/
-MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
-{
-    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
-}
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* BITSTREAM_H_MODULE */
-
-
-
-/* ******************************************************************
-   FSE : Finite State Entropy coder
-   header file for static linking (only)
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef FSE_STATIC_H
-#define FSE_STATIC_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* *****************************************
-*  Static allocation
-*******************************************/
-/* FSE buffer bounds */
-#define FSE_NCOUNTBOUND 512
-#define FSE_BLOCKBOUND(size) (size + (size>>7))
-#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
-
-/* It is possible to statically allocate FSE CTable/DTable as a table of unsigned using below macros */
-#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))
-#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
-
-
-/* *****************************************
-*  FSE advanced API
-*******************************************/
-static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);
-/* build a fake FSE_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */
-
-static size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);
-/* build a fake FSE_DTable, designed to always generate the same symbolValue */
-
-
-
-/* *****************************************
-*  FSE symbol decompression API
-*******************************************/
-typedef struct
-{
-    size_t      state;
-    const void* table;   /* precise table may vary, depending on U16 */
-} FSE_DState_t;
-
-
-static void     FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);
-
-static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
-
-static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);
-
-/*!
-Let's now decompose FSE_decompress_usingDTable() into its unitary components.
-You will decode FSE-encoded symbols from the bitStream,
-and also any other bitFields you put in, **in reverse order**.
-
-You will need a few variables to track your bitStream. They are :
-
-BIT_DStream_t DStream;    // Stream context
-FSE_DState_t  DState;     // State context. Multiple ones are possible
-FSE_DTable*   DTablePtr;  // Decoding table, provided by FSE_buildDTable()
-
-The first thing to do is to init the bitStream.
-    errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize);
-
-You should then retrieve your initial state(s)
-(in reverse flushing order if you have several ones) :
-    errorCode = FSE_initDState(&DState, &DStream, DTablePtr);
-
-You can then decode your data, symbol after symbol.
-For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'.
-Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
-    unsigned char symbol = FSE_decodeSymbol(&DState, &DStream);
-
-You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
-Note : maximum allowed nbBits is 25, for 32-bits compatibility
-    size_t bitField = BIT_readBits(&DStream, nbBits);
-
-All above operations only read from local register (which size depends on size_t).
-Refueling the register from memory is manually performed by the reload method.
-    endSignal = FSE_reloadDStream(&DStream);
-
-BIT_reloadDStream() result tells if there is still some more data to read from DStream.
-BIT_DStream_unfinished : there is still some data left into the DStream.
-BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
-BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
-BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted.
-
-When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
-to properly detect the exact end of stream.
-After each decoded symbol, check if DStream is fully consumed using this simple test :
-    BIT_reloadDStream(&DStream) >= BIT_DStream_completed
-
-When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
-Checking if DStream has reached its end is performed by :
-    BIT_endOfDStream(&DStream);
-Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
-    FSE_endOfDState(&DState);
-*/
-
-
-/* *****************************************
-*  FSE unsafe API
-*******************************************/
-static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
-/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
-
-
-/* *****************************************
-*  Implementation of inlined functions
-*******************************************/
-/* decompression */
-
-typedef struct {
-    U16 tableLog;
-    U16 fastMode;
-} FSE_DTableHeader;   /* sizeof U32 */
-
-typedef struct
-{
-    unsigned short newState;
-    unsigned char  symbol;
-    unsigned char  nbBits;
-} FSE_decode_t;   /* size == U32 */
-
-MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
-{
-    FSE_DTableHeader DTableH;
-    memcpy(&DTableH, dt, sizeof(DTableH));
-    DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog);
-    BIT_reloadDStream(bitD);
-    DStatePtr->table = dt + 1;
-}
-
-MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
-{
-    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    const U32  nbBits = DInfo.nbBits;
-    BYTE symbol = DInfo.symbol;
-    size_t lowBits = BIT_readBits(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
-{
-    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    const U32 nbBits = DInfo.nbBits;
-    BYTE symbol = DInfo.symbol;
-    size_t lowBits = BIT_readBitsFast(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
-{
-    return DStatePtr->state == 0;
-}
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* FSE_STATIC_H */
-
-/* ******************************************************************
-   FSE : Finite State Entropy coder
-   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
-****************************************************************** */
-
-#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 */
-
-/* **************************************************************
-*  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
-
-
-/* **************************************************************
-*  Dependencies
-****************************************************************/
-#include <stdlib.h>     /* malloc, free, qsort */
-#include <string.h>     /* memcpy, memset */
-#include <stdio.h>      /* printf (debug) */
-
-
-/* ***************************************************************
-*  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
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#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)
-
-static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }
-
-
-static size_t FSE_buildDTable(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
-{
-    FSE_DTableHeader DTableH;
-    void* const tdPtr = dt+1;   /* because dt is unsigned, 32-bits aligned on 32-bits */
-    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*) (tdPtr);
-    const U32 tableSize = 1 << tableLog;
-    const U32 tableMask = tableSize-1;
-    const U32 step = FSE_tableStep(tableSize);
-    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];
-    U32 position = 0;
-    U32 highThreshold = tableSize-1;
-    const S16 largeLimit= (S16)(1 << (tableLog-1));
-    U32 noLarge = 1;
-    U32 s;
-
-    /* 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 */
-    DTableH.tableLog = (U16)tableLog;
-    for (s=0; s<=maxSymbolValue; s++)
-    {
-        if (normalizedCounter[s]==-1)
-        {
-            tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;
-            symbolNext[s] = 1;
-        }
-        else
-        {
-            if (normalizedCounter[s] >= largeLimit) noLarge=0;
-            symbolNext[s] = normalizedCounter[s];
-        }
-    }
-
-    /* Spread symbols */
-    for (s=0; s<=maxSymbolValue; 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 i;
-        for (i=0; i<tableSize; i++)
-        {
-            FSE_FUNCTION_TYPE symbol = (FSE_FUNCTION_TYPE)(tableDecode[i].symbol);
-            U16 nextState = symbolNext[symbol]++;
-            tableDecode[i].nbBits = (BYTE) (tableLog - BIT_highbit32 ((U32)nextState) );
-            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize);
-        }
-    }
-
-    DTableH.fastMode = (U16)noLarge;
-    memcpy(dt, &DTableH, sizeof(DTableH));
-    return 0;
-}
-
-
-#ifndef FSE_COMMONDEFS_ONLY
-/******************************************
-*  FSE helper functions
-******************************************/
-static unsigned FSE_isError(size_t code) { return ERR_isError(code); }
-
-
-/****************************************************************
-*  FSE NCount encoding-decoding
-****************************************************************/
-static short FSE_abs(short a)
-{
-    return a<0 ? -a : a;
-}
-
-static 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;
-        }
-        {
-            const short 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);
-            }
-        }
-    }
-    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;
-}
-
-
-/*********************************************************
-*  Decompression (Byte symbols)
-*********************************************************/
-static 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;
-}
-
-
-static 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 maxSymbolValue = tableMask;
-    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<=maxSymbolValue; 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;
-    size_t errorCode;
-
-    /* Init */
-    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 ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) )
-            break;
-
-        *op++ = FSE_GETSYMBOL(&state1);
-
-        if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) )
-            break;
-
-        *op++ = FSE_GETSYMBOL(&state2);
-    }
-
-    /* end ? */
-    if (BIT_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2))
-        return op-ostart;
-
-    if (op==omax) return ERROR(dstSize_tooSmall);   /* dst buffer is full, but cSrc unfinished */
-
-    return ERROR(corruption_detected);
-}
-
-
-static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
-                            const void* cSrc, size_t cSrcSize,
-                            const FSE_DTable* dt)
-{
-    FSE_DTableHeader DTableH;
-    U32 fastMode;
-
-    memcpy(&DTableH, dt, sizeof(DTableH));
-    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);
-}
-
-
-static 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;
-    size_t errorCode;
-
-    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */
-
-    /* normal FSE decoding mode */
-    errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
-    if (FSE_isError(errorCode)) return errorCode;
-    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */
-    ip += errorCode;
-    cSrcSize -= errorCode;
-
-    errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);
-    if (FSE_isError(errorCode)) return errorCode;
-
-    /* always return, even if it is an error code */
-    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);
-}
-
-
-
-#endif   /* FSE_COMMONDEFS_ONLY */
-
-
-/* ******************************************************************
-   Huff0 : Huffman coder, part of New Generation Entropy library
-   header file
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef HUFF0_H
-#define HUFF0_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* ****************************************
-*  Dependency
-******************************************/
-#include <stddef.h>    /* size_t */
-
-
-/* ****************************************
-*  Huff0 simple functions
-******************************************/
-static size_t HUF_decompress(void* dst,  size_t dstSize,
-                const void* cSrc, size_t cSrcSize);
-/*!
-HUF_decompress():
-    Decompress Huff0 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
-******************************************/
-/* Error Management */
-static unsigned    HUF_isError(size_t code);        /* tells if a return value is an error code */
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif   /* HUFF0_H */
-
-
-/* ******************************************************************
-   Huff0 : Huffman coder, part of New Generation Entropy library
-   header file for static linking (only)
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef HUFF0_STATIC_H
-#define HUFF0_STATIC_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-
-/* ****************************************
-*  Static allocation macros
-******************************************/
-/* static allocation of Huff0's DTable */
-#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog))  /* nb Cells; use unsigned short for X2, unsigned int for X4 */
-#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
-******************************************/
-static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
-static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */
-
-
-/* ****************************************
-*  Huff0 detailed API
-******************************************/
-/*!
-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
-
-*/
-static size_t HUF_readDTableX2 (unsigned short* DTable, const void* src, size_t srcSize);
-static size_t HUF_readDTableX4 (unsigned* DTable, const void* src, size_t srcSize);
-
-static size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable);
-static size_t HUF_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable);
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* HUFF0_STATIC_H */
-
-
-
-/* ******************************************************************
-   Huff0 : Huffman coder, part of New Generation Entropy library
-   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+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy
-****************************************************************** */
-
-/* **************************************************************
-*  Compiler specifics
-****************************************************************/
-#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-/* inline is defined */
-#elif defined(_MSC_VER)
-#  define inline __inline
-#else
-#  define inline /* disable inline */
-#endif
-
-
-#ifdef _MSC_VER    /* Visual Studio */
-#  define FORCE_INLINE static __forceinline
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#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) */
-
-
-/* **************************************************************
-*  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
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-static unsigned HUF_isError(size_t code) { return ERR_isError(code); }
-#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-
-
-
-/*-*******************************************************
-*  Huff0 : Huffman block decompression
-*********************************************************/
-typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2;   /* single-symbol decoding */
-
-typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4;  /* double-symbols decoding */
-
-typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
-
-/*! HUF_readStats
-    Read compact Huffman tree, saved by HUF_writeCTable
-    @huffWeight : destination buffer
-    @return : size read from `src`
-*/
-static size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                            U32* nbSymbolsPtr, U32* tableLogPtr,
-                            const void* src, size_t srcSize)
-{
-    U32 weightTotal;
-    U32 tableLog;
-    const BYTE* ip = (const BYTE*) src;
-    size_t iSize = ip[0];
-    size_t oSize;
-    U32 n;
-
-    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */
-
-    if (iSize >= 128)  /* special header */
-    {
-        if (iSize >= (242))   /* RLE */
-        {
-            static int 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;
-            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;
-    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) */
-    tableLog = BIT_highbit32(weightTotal) + 1;
-    if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
-    {
-        U32 total = 1 << tableLog;
-        U32 rest = total - weightTotal;
-        U32 verif = 1 << BIT_highbit32(rest);
-        U32 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);
-    *tableLogPtr = tableLog;
-    return iSize+1;
-}
-
-
-/**************************/
-/* single-symbol decoding */
-/**************************/
-
-static size_t HUF_readDTableX2 (U16* DTable, const void* src, size_t srcSize)
-{
-    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1];
-    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];   /* large enough for values from 0 to 16 */
-    U32 tableLog = 0;
-    size_t iSize;
-    U32 nbSymbols = 0;
-    U32 n;
-    U32 nextRankStart;
-    void* const dtPtr = DTable + 1;
-    HUF_DEltX2* const dt = (HUF_DEltX2*)dtPtr;
-
-    HUF_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */
-    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
-    if (HUF_isError(iSize)) return iSize;
-
-    /* check result */
-    if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge);   /* DTable is too small */
-    DTable[0] = (U16)tableLog;   /* maybe should separate sizeof DTable, as allocated, from used size of DTable, in case of DTable re-use */
-
-    /* Prepare ranks */
-    nextRankStart = 0;
-    for (n=1; n<=tableLog; n++)
-    {
-        U32 current = nextRankStart;
-        nextRankStart += (rankVal[n] << (n-1));
-        rankVal[n] = current;
-    }
-
-    /* fill DTable */
-    for (n=0; n<nbSymbols; n++)
-    {
-        const U32 w = huffWeight[n];
-        const U32 length = (1 << w) >> 1;
-        U32 i;
-        HUF_DEltX2 D;
-        D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);
-        for (i = rankVal[w]; i < rankVal[w] + length; i++)
-            dt[i] = D;
-        rankVal[w] += length;
-    }
-
-    return iSize;
-}
-
-static BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog)
-{
-        const size_t val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
-        const BYTE c = dt[val].byte;
-        BIT_skipBits(Dstream, dt[val].nbBits);
-        return c;
-}
-
-#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
-    *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog)
-
-#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
-    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
-        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
-
-#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
-    if (MEM_64bits()) \
-        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
-
-static inline size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 4 symbols at a time */
-    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4))
-    {
-        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
-        HUF_DECODE_SYMBOLX2_1(p, bitDPtr);
-        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);
-        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-    }
-
-    /* closer to the end */
-    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd))
-        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-
-    /* no more data to retrieve from bitstream, hence no need to reload */
-    while (p < pEnd)
-        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);
-
-    return pEnd-pStart;
-}
-
-
-static size_t HUF_decompress4X2_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const U16* DTable)
-{
-    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
-
-    {
-        const BYTE* const istart = (const BYTE*) cSrc;
-        BYTE* const ostart = (BYTE*) dst;
-        BYTE* const oend = ostart + dstSize;
-        const void* const dtPtr = DTable;
-        const HUF_DEltX2* const dt = ((const HUF_DEltX2*)dtPtr) +1;
-        const U32 dtLog = DTable[0];
-        size_t errorCode;
-
-        /* Init */
-        BIT_DStream_t bitD1;
-        BIT_DStream_t bitD2;
-        BIT_DStream_t bitD3;
-        BIT_DStream_t bitD4;
-        const size_t length1 = MEM_readLE16(istart);
-        const size_t length2 = MEM_readLE16(istart+2);
-        const size_t length3 = MEM_readLE16(istart+4);
-        size_t length4;
-        const BYTE* const istart1 = istart + 6;  /* jumpTable */
-        const BYTE* const istart2 = istart1 + length1;
-        const BYTE* const istart3 = istart2 + length2;
-        const BYTE* const istart4 = istart3 + length3;
-        const size_t segmentSize = (dstSize+3) / 4;
-        BYTE* const opStart2 = ostart + segmentSize;
-        BYTE* const opStart3 = opStart2 + segmentSize;
-        BYTE* const opStart4 = opStart3 + segmentSize;
-        BYTE* op1 = ostart;
-        BYTE* op2 = opStart2;
-        BYTE* op3 = opStart3;
-        BYTE* op4 = opStart4;
-        U32 endSignal;
-
-        length4 = cSrcSize - (length1 + length2 + length3 + 6);
-        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
-        errorCode = BIT_initDStream(&bitD1, istart1, length1);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD2, istart2, length2);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD3, istart3, length3);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD4, istart4, length4);
-        if (HUF_isError(errorCode)) return errorCode;
-
-        /* 16-32 symbols per loop (4-8 symbols per stream) */
-        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
-        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )
-        {
-            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
-            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
-            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
-            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
-            HUF_DECODE_SYMBOLX2_1(op1, &bitD1);
-            HUF_DECODE_SYMBOLX2_1(op2, &bitD2);
-            HUF_DECODE_SYMBOLX2_1(op3, &bitD3);
-            HUF_DECODE_SYMBOLX2_1(op4, &bitD4);
-            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);
-            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);
-            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);
-            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);
-            HUF_DECODE_SYMBOLX2_0(op1, &bitD1);
-            HUF_DECODE_SYMBOLX2_0(op2, &bitD2);
-            HUF_DECODE_SYMBOLX2_0(op3, &bitD3);
-            HUF_DECODE_SYMBOLX2_0(op4, &bitD4);
-
-            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
-        }
-
-        /* check corruption */
-        if (op1 > opStart2) return ERROR(corruption_detected);
-        if (op2 > opStart3) return ERROR(corruption_detected);
-        if (op3 > opStart4) return ERROR(corruption_detected);
-        /* note : op4 supposed already verified within main loop */
-
-        /* finish bitStreams one by one */
-        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
-        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
-        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
-        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
-
-        /* check */
-        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
-        if (!endSignal) return ERROR(corruption_detected);
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
-
-static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-    size_t errorCode;
-
-    errorCode = HUF_readDTableX2 (DTable, cSrc, cSrcSize);
-    if (HUF_isError(errorCode)) return errorCode;
-    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += errorCode;
-    cSrcSize -= errorCode;
-
-    return HUF_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
-}
-
-
-/***************************/
-/* double-symbols decoding */
-/***************************/
-
-static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed,
-                           const U32* rankValOrigin, const int minWeight,
-                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
-                           U32 nbBitsBaseline, U16 baseSeq)
-{
-    HUF_DEltX4 DElt;
-    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];
-    U32 s;
-
-    /* get pre-calculated rankVal */
-    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
-
-    /* fill skipped values */
-    if (minWeight>1)
-    {
-        U32 i, skipSize = rankVal[minWeight];
-        MEM_writeLE16(&(DElt.sequence), baseSeq);
-        DElt.nbBits   = (BYTE)(consumed);
-        DElt.length   = 1;
-        for (i = 0; i < skipSize; i++)
-            DTable[i] = DElt;
-    }
-
-    /* fill DTable */
-    for (s=0; s<sortedListSize; s++)   /* note : sortedSymbols already skipped */
-    {
-        const U32 symbol = sortedSymbols[s].symbol;
-        const U32 weight = sortedSymbols[s].weight;
-        const U32 nbBits = nbBitsBaseline - weight;
-        const U32 length = 1 << (sizeLog-nbBits);
-        const U32 start = rankVal[weight];
-        U32 i = start;
-        const U32 end = start + length;
-
-        MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
-        DElt.nbBits = (BYTE)(nbBits + consumed);
-        DElt.length = 2;
-        do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */
-
-        rankVal[weight] += length;
-    }
-}
-
-typedef U32 rankVal_t[HUF_ABSOLUTEMAX_TABLELOG][HUF_ABSOLUTEMAX_TABLELOG + 1];
-
-static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog,
-                           const sortedSymbol_t* sortedList, const U32 sortedListSize,
-                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
-                           const U32 nbBitsBaseline)
-{
-    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];
-    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */
-    const U32 minBits  = nbBitsBaseline - maxWeight;
-    U32 s;
-
-    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
-
-    /* fill DTable */
-    for (s=0; s<sortedListSize; s++)
-    {
-        const U16 symbol = sortedList[s].symbol;
-        const U32 weight = sortedList[s].weight;
-        const U32 nbBits = nbBitsBaseline - weight;
-        const U32 start = rankVal[weight];
-        const U32 length = 1 << (targetLog-nbBits);
-
-        if (targetLog-nbBits >= minBits)   /* enough room for a second symbol */
-        {
-            U32 sortedRank;
-            int minWeight = nbBits + scaleLog;
-            if (minWeight < 1) minWeight = 1;
-            sortedRank = rankStart[minWeight];
-            HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,
-                           rankValOrigin[nbBits], minWeight,
-                           sortedList+sortedRank, sortedListSize-sortedRank,
-                           nbBitsBaseline, symbol);
-        }
-        else
-        {
-            U32 i;
-            const U32 end = start + length;
-            HUF_DEltX4 DElt;
-
-            MEM_writeLE16(&(DElt.sequence), symbol);
-            DElt.nbBits   = (BYTE)(nbBits);
-            DElt.length   = 1;
-            for (i = start; i < end; i++)
-                DTable[i] = DElt;
-        }
-        rankVal[weight] += length;
-    }
-}
-
-static size_t HUF_readDTableX4 (U32* DTable, const void* src, size_t srcSize)
-{
-    BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1];
-    sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1];
-    U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 };
-    U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 };
-    U32* const rankStart = rankStart0+1;
-    rankVal_t rankVal;
-    U32 tableLog, maxW, sizeOfSort, nbSymbols;
-    const U32 memLog = DTable[0];
-    size_t iSize;
-    void* dtPtr = DTable;
-    HUF_DEltX4* const dt = ((HUF_DEltX4*)dtPtr) + 1;
-
-    HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */
-    if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);
-    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
-    if (HUF_isError(iSize)) return iSize;
-
-    /* check result */
-    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
-
-    /* find maxWeight */
-    for (maxW = tableLog; rankStats[maxW]==0; maxW--)
-        { if (!maxW) return ERROR(GENERIC); }  /* necessarily finds a solution before maxW==0 */
-
-    /* Get start index of each weight */
-    {
-        U32 w, nextRankStart = 0;
-        for (w=1; w<=maxW; w++)
-        {
-            U32 current = nextRankStart;
-            nextRankStart += rankStats[w];
-            rankStart[w] = current;
-        }
-        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
-        sizeOfSort = nextRankStart;
-    }
-
-    /* sort symbols by weight */
-    {
-        U32 s;
-        for (s=0; s<nbSymbols; s++)
-        {
-            U32 w = weightList[s];
-            U32 r = rankStart[w]++;
-            sortedSymbol[r].symbol = (BYTE)s;
-            sortedSymbol[r].weight = (BYTE)w;
-        }
-        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
-    }
-
-    /* Build rankVal */
-    {
-        const U32 minBits = tableLog+1 - maxW;
-        U32 nextRankVal = 0;
-        U32 w, consumed;
-        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */
-        U32* rankVal0 = rankVal[0];
-        for (w=1; w<=maxW; w++)
-        {
-            U32 current = nextRankVal;
-            nextRankVal += rankStats[w] << (w+rescale);
-            rankVal0[w] = current;
-        }
-        for (consumed = minBits; consumed <= memLog - minBits; consumed++)
-        {
-            U32* rankValPtr = rankVal[consumed];
-            for (w = 1; w <= maxW; w++)
-            {
-                rankValPtr[w] = rankVal0[w] >> consumed;
-            }
-        }
-    }
-
-    HUF_fillDTableX4(dt, memLog,
-                   sortedSymbol, sizeOfSort,
-                   rankStart0, rankVal, maxW,
-                   tableLog+1);
-
-    return iSize;
-}
-
-
-static U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)
-{
-    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    memcpy(op, dt+val, 2);
-    BIT_skipBits(DStream, dt[val].nbBits);
-    return dt[val].length;
-}
-
-static U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)
-{
-    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    memcpy(op, dt+val, 1);
-    if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);
-    else
-    {
-        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8))
-        {
-            BIT_skipBits(DStream, dt[val].nbBits);
-            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
-                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
-        }
-    }
-    return 1;
-}
-
-
-#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \
-    ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-#define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \
-    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \
-        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-#define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \
-    if (MEM_64bits()) \
-        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-static inline size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 8 symbols at a time */
-    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd-7))
-    {
-        HUF_DECODE_SYMBOLX4_2(p, bitDPtr);
-        HUF_DECODE_SYMBOLX4_1(p, bitDPtr);
-        HUF_DECODE_SYMBOLX4_2(p, bitDPtr);
-        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);
-    }
-
-    /* closer to the end */
-    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-2))
-        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);
-
-    while (p <= pEnd-2)
-        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
-
-    if (p < pEnd)
-        p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);
-
-    return p-pStart;
-}
-
-static size_t HUF_decompress4X4_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const U32* DTable)
-{
-    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
-
-    {
-        const BYTE* const istart = (const BYTE*) cSrc;
-        BYTE* const ostart = (BYTE*) dst;
-        BYTE* const oend = ostart + dstSize;
-        const void* const dtPtr = DTable;
-        const HUF_DEltX4* const dt = ((const HUF_DEltX4*)dtPtr) +1;
-        const U32 dtLog = DTable[0];
-        size_t errorCode;
-
-        /* Init */
-        BIT_DStream_t bitD1;
-        BIT_DStream_t bitD2;
-        BIT_DStream_t bitD3;
-        BIT_DStream_t bitD4;
-        const size_t length1 = MEM_readLE16(istart);
-        const size_t length2 = MEM_readLE16(istart+2);
-        const size_t length3 = MEM_readLE16(istart+4);
-        size_t length4;
-        const BYTE* const istart1 = istart + 6;  /* jumpTable */
-        const BYTE* const istart2 = istart1 + length1;
-        const BYTE* const istart3 = istart2 + length2;
-        const BYTE* const istart4 = istart3 + length3;
-        const size_t segmentSize = (dstSize+3) / 4;
-        BYTE* const opStart2 = ostart + segmentSize;
-        BYTE* const opStart3 = opStart2 + segmentSize;
-        BYTE* const opStart4 = opStart3 + segmentSize;
-        BYTE* op1 = ostart;
-        BYTE* op2 = opStart2;
-        BYTE* op3 = opStart3;
-        BYTE* op4 = opStart4;
-        U32 endSignal;
-
-        length4 = cSrcSize - (length1 + length2 + length3 + 6);
-        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
-        errorCode = BIT_initDStream(&bitD1, istart1, length1);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD2, istart2, length2);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD3, istart3, length3);
-        if (HUF_isError(errorCode)) return errorCode;
-        errorCode = BIT_initDStream(&bitD4, istart4, length4);
-        if (HUF_isError(errorCode)) return errorCode;
-
-        /* 16-32 symbols per loop (4-8 symbols per stream) */
-        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
-        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )
-        {
-            HUF_DECODE_SYMBOLX4_2(op1, &bitD1);
-            HUF_DECODE_SYMBOLX4_2(op2, &bitD2);
-            HUF_DECODE_SYMBOLX4_2(op3, &bitD3);
-            HUF_DECODE_SYMBOLX4_2(op4, &bitD4);
-            HUF_DECODE_SYMBOLX4_1(op1, &bitD1);
-            HUF_DECODE_SYMBOLX4_1(op2, &bitD2);
-            HUF_DECODE_SYMBOLX4_1(op3, &bitD3);
-            HUF_DECODE_SYMBOLX4_1(op4, &bitD4);
-            HUF_DECODE_SYMBOLX4_2(op1, &bitD1);
-            HUF_DECODE_SYMBOLX4_2(op2, &bitD2);
-            HUF_DECODE_SYMBOLX4_2(op3, &bitD3);
-            HUF_DECODE_SYMBOLX4_2(op4, &bitD4);
-            HUF_DECODE_SYMBOLX4_0(op1, &bitD1);
-            HUF_DECODE_SYMBOLX4_0(op2, &bitD2);
-            HUF_DECODE_SYMBOLX4_0(op3, &bitD3);
-            HUF_DECODE_SYMBOLX4_0(op4, &bitD4);
-
-            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);
-        }
-
-        /* check corruption */
-        if (op1 > opStart2) return ERROR(corruption_detected);
-        if (op2 > opStart3) return ERROR(corruption_detected);
-        if (op3 > opStart4) return ERROR(corruption_detected);
-        /* note : op4 supposed already verified within main loop */
-
-        /* finish bitStreams one by one */
-        HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);
-        HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);
-        HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);
-        HUF_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog);
-
-        /* check */
-        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
-        if (!endSignal) return ERROR(corruption_detected);
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
-
-static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t hSize = HUF_readDTableX4 (DTable, cSrc, cSrcSize);
-    if (HUF_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize;
-    cSrcSize -= hSize;
-
-    return HUF_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
-}
-
-
-/**********************************/
-/* Generic decompression selector */
-/**********************************/
-
-typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
-static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] =
-{
-    /* single, double, quad */
-    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */
-    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */
-    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */
-    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */
-    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */
-    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */
-    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */
-    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */
-    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */
-    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */
-    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */
-    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */
-    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */
-    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */
-    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */
-    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */
-};
-
-typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
-
-static size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
+/* ****************************************************************** 
+   zstd_v04.c 
+   Decompression module for ZSTD v0.4 legacy format 
+   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 : 
+    - Homepage : http://www.zstd.net/ 
+****************************************************************** */ 
+ 
+/*- Dependencies -*/ 
+#include "zstd_v04.h" 
+ 
+ 
+/* ****************************************************************** 
+   mem.h 
+   low-level memory access routines 
+   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 
+****************************************************************** */ 
+#ifndef MEM_H_MODULE 
+#define MEM_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/****************************************** 
+*  Includes 
+******************************************/ 
+#include <stddef.h>    /* size_t, ptrdiff_t */ 
+#include <string.h>    /* memcpy */ 
+ 
+ 
+/****************************************** 
+*  Compiler-specific 
+******************************************/ 
+#if defined(__GNUC__) 
+#  define MEM_STATIC static __attribute__((unused)) 
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+#  define MEM_STATIC static inline 
+#elif defined(_MSC_VER) 
+#  define MEM_STATIC static __inline 
+#else 
+#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */ 
+#endif 
+ 
+ 
+/**************************************************************** 
+*  Basic Types 
+*****************************************************************/ 
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+# include <stdint.h> 
+  typedef  uint8_t BYTE; 
+  typedef uint16_t U16; 
+  typedef  int16_t S16; 
+  typedef uint32_t U32; 
+  typedef  int32_t S32; 
+  typedef uint64_t U64; 
+  typedef  int64_t S64; 
+#else 
+  typedef unsigned char       BYTE; 
+  typedef unsigned short      U16; 
+  typedef   signed short      S16; 
+  typedef unsigned int        U32; 
+  typedef   signed int        S32; 
+  typedef unsigned long long  U64; 
+  typedef   signed long long  S64; 
+#endif 
+ 
+ 
+/**************************************************************** 
+*  Memory I/O 
+*****************************************************************/ 
+/* MEM_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 is portable but violate C standard. 
+ *            It can generate buggy code on targets generating assembly depending on alignment. 
+ *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) 
+ * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details. 
+ * Prefer these methods in priority order (0 > 1 > 2) 
+ */ 
+#ifndef MEM_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 MEM_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 MEM_FORCE_MEMORY_ACCESS 1 
+#  endif 
+#endif 
+ 
+MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; } 
+MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; } 
+ 
+MEM_STATIC unsigned MEM_isLittleEndian(void) 
+{ 
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */ 
+    return one.c[0]; 
+} 
+ 
+#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2) 
+ 
+/* violates C standard on structure alignment. 
+Only use if no other choice to achieve best performance on target platform */ 
+MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; } 
+MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; } 
+MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; } 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; } 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; } 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; } 
+ 
+#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_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 { U16 u16; U32 u32; U64 u64; } __attribute__((packed)) unalign; 
+ 
+MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; } 
+MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; } 
+MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; } 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; } 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; } 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign*)memPtr)->u64 = value; } 
+ 
+#else 
+ 
+/* default method, safe and standard. 
+   can sometimes prove slower */ 
+ 
+MEM_STATIC U16 MEM_read16(const void* memPtr) 
+{ 
+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC U32 MEM_read32(const void* memPtr) 
+{ 
+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC U64 MEM_read64(const void* memPtr) 
+{ 
+    U64 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+#endif // MEM_FORCE_MEMORY_ACCESS 
+ 
+ 
+MEM_STATIC U16 MEM_readLE16(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read16(memPtr); 
+    else 
+    { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U16)(p[0] + (p[1]<<8)); 
+    } 
+} 
+ 
+MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val) 
+{ 
+    if (MEM_isLittleEndian()) 
+    { 
+        MEM_write16(memPtr, val); 
+    } 
+    else 
+    { 
+        BYTE* p = (BYTE*)memPtr; 
+        p[0] = (BYTE)val; 
+        p[1] = (BYTE)(val>>8); 
+    } 
+} 
+ 
+MEM_STATIC U32 MEM_readLE32(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read32(memPtr); 
+    else 
+    { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24)); 
+    } 
+} 
+ 
+MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32) 
+{ 
+    if (MEM_isLittleEndian()) 
+    { 
+        MEM_write32(memPtr, val32); 
+    } 
+    else 
+    { 
+        BYTE* p = (BYTE*)memPtr; 
+        p[0] = (BYTE)val32; 
+        p[1] = (BYTE)(val32>>8); 
+        p[2] = (BYTE)(val32>>16); 
+        p[3] = (BYTE)(val32>>24); 
+    } 
+} 
+ 
+MEM_STATIC U64 MEM_readLE64(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read64(memPtr); 
+    else 
+    { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24) 
+                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56)); 
+    } 
+} 
+ 
+MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64) 
+{ 
+    if (MEM_isLittleEndian()) 
+    { 
+        MEM_write64(memPtr, val64); 
+    } 
+    else 
+    { 
+        BYTE* p = (BYTE*)memPtr; 
+        p[0] = (BYTE)val64; 
+        p[1] = (BYTE)(val64>>8); 
+        p[2] = (BYTE)(val64>>16); 
+        p[3] = (BYTE)(val64>>24); 
+        p[4] = (BYTE)(val64>>32); 
+        p[5] = (BYTE)(val64>>40); 
+        p[6] = (BYTE)(val64>>48); 
+        p[7] = (BYTE)(val64>>56); 
+    } 
+} 
+ 
+MEM_STATIC size_t MEM_readLEST(const void* memPtr) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_readLE32(memPtr); 
+    else 
+        return (size_t)MEM_readLE64(memPtr); 
+} 
+ 
+MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val) 
+{ 
+    if (MEM_32bits()) 
+        MEM_writeLE32(memPtr, (U32)val); 
+    else 
+        MEM_writeLE64(memPtr, (U64)val); 
+} 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* MEM_H_MODULE */ 
+ 
+/* ****************************************************************** 
+   Error codes list 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/zstd 
+****************************************************************** */ 
+#ifndef ERROR_PUBLIC_H_MODULE 
+#define ERROR_PUBLIC_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* **************************************** 
+*  error list 
+******************************************/ 
+enum { 
+  ZSTD_error_No_Error, 
+  ZSTD_error_GENERIC, 
+  ZSTD_error_prefix_unknown, 
+  ZSTD_error_frameParameter_unsupported, 
+  ZSTD_error_frameParameter_unsupportedBy32bitsImplementation, 
+  ZSTD_error_init_missing, 
+  ZSTD_error_memory_allocation, 
+  ZSTD_error_stage_wrong, 
+  ZSTD_error_dstSize_tooSmall, 
+  ZSTD_error_srcSize_wrong, 
+  ZSTD_error_corruption_detected, 
+  ZSTD_error_tableLog_tooLarge, 
+  ZSTD_error_maxSymbolValue_tooLarge, 
+  ZSTD_error_maxSymbolValue_tooSmall, 
+  ZSTD_error_maxCode 
+}; 
+ 
+/* note : functions provide error codes in reverse negative order, 
+          so compare with (size_t)(0-enum) */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* ERROR_PUBLIC_H_MODULE */ 
+ 
+ 
+ 
+/* 
+    zstd - standard compression library 
+    Header File for static linking only 
+    Copyright (C) 2014-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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+#ifndef ZSTD_STATIC_H 
+#define ZSTD_STATIC_H 
+ 
+/* The objects defined into this file shall be considered experimental. 
+ * They are not considered stable, as their prototype may change in the future. 
+ * You can use them for tests, provide feedback, or if you can endure risks of future changes. 
+ */ 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/* ************************************* 
+*  Types 
+***************************************/ 
+#define ZSTD_WINDOWLOG_MAX 26 
+#define ZSTD_WINDOWLOG_MIN 18 
+#define ZSTD_WINDOWLOG_ABSOLUTEMIN 11 
+#define ZSTD_CONTENTLOG_MAX (ZSTD_WINDOWLOG_MAX+1) 
+#define ZSTD_CONTENTLOG_MIN 4 
+#define ZSTD_HASHLOG_MAX 28 
+#define ZSTD_HASHLOG_MIN 4 
+#define ZSTD_SEARCHLOG_MAX (ZSTD_CONTENTLOG_MAX-1) 
+#define ZSTD_SEARCHLOG_MIN 1 
+#define ZSTD_SEARCHLENGTH_MAX 7 
+#define ZSTD_SEARCHLENGTH_MIN 4 
+ 
+/** from faster to stronger */ 
+typedef enum { ZSTD_fast, ZSTD_greedy, ZSTD_lazy, ZSTD_lazy2, ZSTD_btlazy2 } ZSTD_strategy; 
+ 
+typedef struct 
+{ 
+    U64 srcSize;       /* optional : tells how much bytes are present in the frame. Use 0 if not known. */ 
+    U32 windowLog;     /* largest match distance : larger == more compression, more memory needed during decompression */ 
+    U32 contentLog;    /* full search segment : larger == more compression, slower, more memory (useless for fast) */ 
+    U32 hashLog;       /* dispatch table : larger == more memory, faster */ 
+    U32 searchLog;     /* nb of searches : larger == more compression, slower */ 
+    U32 searchLength;  /* size of matches : larger == faster decompression, sometimes less compression */ 
+    ZSTD_strategy strategy; 
+} ZSTD_parameters; 
+ 
+typedef ZSTDv04_Dctx ZSTD_DCtx; 
+ 
+/* ************************************* 
+*  Advanced functions 
+***************************************/ 
+/** ZSTD_decompress_usingDict 
+*   Same as ZSTD_decompressDCtx, using a Dictionary content as prefix 
+*   Note : dict can be NULL, in which case, it's equivalent to ZSTD_decompressDCtx() */ 
+static size_t ZSTD_decompress_usingDict(ZSTD_DCtx* ctx, 
+                                             void* dst, size_t maxDstSize, 
+                                       const void* src, size_t srcSize, 
+                                       const void* dict,size_t dictSize); 
+ 
+ 
+/* ************************************** 
+*  Streaming functions (direct mode) 
+****************************************/ 
+static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx); 
+static size_t ZSTD_getFrameParams(ZSTD_parameters* params, const void* src, size_t srcSize); 
+static void   ZSTD_decompress_insertDictionary(ZSTD_DCtx* ctx, const void* src, size_t srcSize); 
+ 
+static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx); 
+static size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize); 
+ 
+/** 
+  Streaming decompression, bufferless mode 
+ 
+  A ZSTD_DCtx object is required to track streaming operations. 
+  Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it. 
+  A ZSTD_DCtx object can be re-used multiple times. Use ZSTD_resetDCtx() to return to fresh status. 
+ 
+  First operation is to retrieve frame parameters, using ZSTD_getFrameParams(). 
+  This function doesn't consume its input. It needs enough input data to properly decode the frame header. 
+  Objective is to retrieve *params.windowlog, to know minimum amount of memory required during decoding. 
+  Result : 0 when successful, it means the ZSTD_parameters structure has been filled. 
+           >0 : means there is not enough data into src. Provides the expected size to successfully decode header. 
+           errorCode, which can be tested using ZSTD_isError() (For example, if it's not a ZSTD header) 
+ 
+  Then, you can optionally insert a dictionary. 
+  This operation must mimic the compressor behavior, otherwise decompression will fail or be corrupted. 
+ 
+  Then it's possible to start decompression. 
+  Use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively. 
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue(). 
+  ZSTD_decompressContinue() requires this exact amount of bytes, or it will fail. 
+  ZSTD_decompressContinue() needs previous data blocks during decompression, up to (1 << windowlog). 
+  They should preferably be located contiguously, prior to current block. Alternatively, a round buffer is also possible. 
+ 
+  @result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst'. 
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header. 
+ 
+  A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero. 
+  Context can then be reset to start a new decompression. 
+*/ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+/* ****************************************************************** 
+   Error codes and messages 
+   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/zstd 
+****************************************************************** */ 
+/* Note : this module is expected to remain private, do not expose it */ 
+ 
+#ifndef ERROR_H_MODULE 
+#define ERROR_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* ***************************************** 
+*  Includes 
+******************************************/ 
+#include <stddef.h>        /* size_t, ptrdiff_t */ 
+ 
+ 
+/* ***************************************** 
+*  Compiler-specific 
+******************************************/ 
+#if defined(__GNUC__) 
+#  define ERR_STATIC static __attribute__((unused)) 
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+#  define ERR_STATIC static inline 
+#elif defined(_MSC_VER) 
+#  define ERR_STATIC static __inline 
+#else 
+#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */ 
+#endif 
+ 
+ 
+/* ***************************************** 
+*  Error Codes 
+******************************************/ 
+#define PREFIX(name) ZSTD_error_##name 
+ 
+#ifdef ERROR 
+#  undef ERROR   /* reported already defined on VS 2015 by Rich Geldreich */ 
+#endif 
+#define ERROR(name) (size_t)-PREFIX(name) 
+ 
+ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); } 
+ 
+ 
+/* ***************************************** 
+*  Error Strings 
+******************************************/ 
+ 
+ERR_STATIC const char* ERR_getErrorName(size_t code) 
+{ 
+    static const char* codeError = "Unspecified error code"; 
+    switch( (size_t)(0-code) ) 
+    { 
+    case ZSTD_error_No_Error: return "No error detected"; 
+    case ZSTD_error_GENERIC:  return "Error (generic)"; 
+    case ZSTD_error_prefix_unknown: return "Unknown frame descriptor"; 
+    case ZSTD_error_frameParameter_unsupported: return "Unsupported frame parameter"; 
+    case ZSTD_error_frameParameter_unsupportedBy32bitsImplementation: return "Frame parameter unsupported in 32-bits mode"; 
+    case ZSTD_error_init_missing: return "Context should be init first"; 
+    case ZSTD_error_memory_allocation: return "Allocation error : not enough memory"; 
+    case ZSTD_error_dstSize_tooSmall: return "Destination buffer is too small"; 
+    case ZSTD_error_srcSize_wrong: return "Src size incorrect"; 
+    case ZSTD_error_corruption_detected: return "Corrupted block detected"; 
+    case ZSTD_error_tableLog_tooLarge: return "tableLog requires too much memory"; 
+    case ZSTD_error_maxSymbolValue_tooLarge: return "Unsupported max possible Symbol Value : too large"; 
+    case ZSTD_error_maxSymbolValue_tooSmall: return "Specified maxSymbolValue is too small"; 
+    case ZSTD_error_maxCode: 
+    default: return codeError; 
+    } 
+} 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* ERROR_H_MODULE */ 
+ 
+ 
+#endif  /* ZSTD_STATIC_H */ 
+ 
+ 
+/* 
+    zstd_internal - common functions to include 
+    Header File for include 
+    Copyright (C) 2014-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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+#ifndef ZSTD_CCOMMON_H_MODULE 
+#define ZSTD_CCOMMON_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/* ************************************* 
+*  Common macros 
+***************************************/ 
+#define MIN(a,b) ((a)<(b) ? (a) : (b)) 
+#define MAX(a,b) ((a)>(b) ? (a) : (b)) 
+ 
+ 
+/* ************************************* 
+*  Common constants 
+***************************************/ 
+#define ZSTD_MAGICNUMBER 0xFD2FB524   /* v0.4 */ 
+ 
+#define KB *(1 <<10) 
+#define MB *(1 <<20) 
+#define GB *(1U<<30) 
+ 
+#define BLOCKSIZE (128 KB)                 /* define, for static allocation */ 
+ 
+static const size_t ZSTD_blockHeaderSize = 3; 
+static const size_t ZSTD_frameHeaderSize_min = 5; 
+#define ZSTD_frameHeaderSize_max 5         /* define, for static allocation */ 
+ 
+#define BIT7 128 
+#define BIT6  64 
+#define BIT5  32 
+#define BIT4  16 
+#define BIT1   2 
+#define BIT0   1 
+ 
+#define IS_RAW BIT0 
+#define IS_RLE BIT1 
+ 
+#define MINMATCH 4 
+#define REPCODE_STARTVALUE 4 
+ 
+#define MLbits   7 
+#define LLbits   6 
+#define Offbits  5 
+#define MaxML  ((1<<MLbits) - 1) 
+#define MaxLL  ((1<<LLbits) - 1) 
+#define MaxOff ((1<<Offbits)- 1) 
+#define MLFSELog   10 
+#define LLFSELog   10 
+#define OffFSELog   9 
+#define MaxSeq MAX(MaxLL, MaxML) 
+ 
+#define MIN_SEQUENCES_SIZE (2 /*seqNb*/ + 2 /*dumps*/ + 3 /*seqTables*/ + 1 /*bitStream*/) 
+#define MIN_CBLOCK_SIZE (3 /*litCSize*/ + MIN_SEQUENCES_SIZE) 
+ 
+typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t; 
+ 
+ 
+/* ****************************************** 
+*  Shared functions to include for inlining 
+********************************************/ 
+static void ZSTD_copy8(void* dst, const void* src) { memcpy(dst, src, 8); } 
+ 
+#define COPY8(d,s) { ZSTD_copy8(d,s); d+=8; s+=8; } 
+ 
+/*! ZSTD_wildcopy : custom version of memcpy(), can copy up to 7-8 bytes too many */ 
+static void ZSTD_wildcopy(void* dst, const void* src, size_t length) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + length; 
+    do 
+        COPY8(op, ip) 
+    while (op < oend); 
+} 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+ 
+/* ****************************************************************** 
+   FSE : Finite State Entropy coder 
+   header file 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef FSE_H 
+#define FSE_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* ***************************************** 
+*  Includes 
+******************************************/ 
+#include <stddef.h>    /* size_t, ptrdiff_t */ 
+ 
+ 
+/* ***************************************** 
+*  FSE simple functions 
+******************************************/ 
+static size_t FSE_decompress(void* dst,  size_t maxDstSize, 
+                const void* cSrc, size_t cSrcSize); 
+/*! 
+FSE_decompress(): 
+    Decompress FSE data from buffer 'cSrc', of size 'cSrcSize', 
+    into already allocated destination buffer 'dst', of size 'maxDstSize'. 
+    return : size of regenerated data (<= maxDstSize) 
+             or an error code, which can be tested using FSE_isError() 
+ 
+    ** Important ** : FSE_decompress() doesn't decompress non-compressible nor RLE data !!! 
+    Why ? : making this distinction requires a header. 
+    Header management is intentionally delegated to the user layer, which can better manage special cases. 
+*/ 
+ 
+ 
+/* ***************************************** 
+*  Tool functions 
+******************************************/ 
+/* Error Management */ 
+static unsigned    FSE_isError(size_t code);        /* tells if a return value is an error code */ 
+ 
+ 
+ 
+/* ***************************************** 
+*  FSE detailed API 
+******************************************/ 
+/*! 
+FSE_compress() does the following: 
+1. count symbol occurrence from source[] into table count[] 
+2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog) 
+3. save normalized counters to memory buffer using writeNCount() 
+4. build encoding table 'CTable' from normalized counters 
+5. encode the data stream using encoding table 'CTable' 
+ 
+FSE_decompress() does the following: 
+1. read normalized counters with readNCount() 
+2. build decoding table 'DTable' from normalized counters 
+3. decode the data stream using decoding table 'DTable' 
+ 
+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 provide normalized distribution using external method. 
+*/ 
+ 
+ 
+/* *** DECOMPRESSION *** */ 
+ 
+/*! 
+FSE_readNCount(): 
+   Read compactly saved 'normalizedCounter' from 'rBuffer'. 
+   return : size read from 'rBuffer' 
+            or an errorCode, which can be tested using FSE_isError() 
+            maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */ 
+static  size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize); 
+ 
+/*! 
+Constructor and Destructor of type FSE_DTable 
+    Note that its size depends on 'tableLog' */ 
+typedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */ 
+ 
+/*! 
+FSE_buildDTable(): 
+   Builds 'dt', which must be already allocated, using FSE_createDTable() 
+   return : 0, 
+            or an errorCode, which can be tested using FSE_isError() */ 
+static size_t FSE_buildDTable ( FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog); 
+ 
+/*! 
+FSE_decompress_usingDTable(): 
+   Decompress compressed source 'cSrc' of size 'cSrcSize' using 'dt' 
+   into 'dst' which must be already allocated. 
+   return : size of regenerated data (necessarily <= maxDstSize) 
+            or an errorCode, which can be tested using FSE_isError() */ 
+static  size_t FSE_decompress_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const FSE_DTable* dt); 
+ 
+/*! 
+Tutorial : 
+---------- 
+(Note : these functions only decompress FSE-compressed blocks. 
+ If block is uncompressed, use memcpy() instead 
+ If block is a single repeated byte, use memset() instead ) 
+ 
+The first step is to obtain the normalized frequencies of symbols. 
+This can be performed by FSE_readNCount() if it was saved using FSE_writeNCount(). 
+'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short. 
+In practice, that means it's necessary to know 'maxSymbolValue' beforehand, 
+or size the table to handle worst case situations (typically 256). 
+FSE_readNCount() will provide 'tableLog' and 'maxSymbolValue'. 
+The result of FSE_readNCount() is the number of bytes read from 'rBuffer'. 
+Note that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that. 
+If there is an error, the function will return an error code, which can be tested using FSE_isError(). 
+ 
+The next step is to build the decompression tables 'FSE_DTable' from 'normalizedCounter'. 
+This is performed by the function FSE_buildDTable(). 
+The space required by 'FSE_DTable' must be already allocated using FSE_createDTable(). 
+If there is an error, the function will return an error code, which can be tested using FSE_isError(). 
+ 
+'FSE_DTable' can then be used to decompress 'cSrc', with FSE_decompress_usingDTable(). 
+'cSrcSize' must be strictly correct, otherwise decompression will fail. 
+FSE_decompress_usingDTable() result will tell how many bytes were regenerated (<=maxDstSize). 
+If there is an error, the function will return an error code, which can be tested using FSE_isError(). (ex: dst buffer too small) 
+*/ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* FSE_H */ 
+ 
+ 
+/* ****************************************************************** 
+   bitstream 
+   Part of NewGen Entropy library 
+   header file (to include) 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef BITSTREAM_H_MODULE 
+#define BITSTREAM_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* 
+*  This API consists of small unitary functions, which highly benefit from being inlined. 
+*  Since link-time-optimization is not available for all compilers, 
+*  these functions are defined into a .h to be included. 
+*/ 
+ 
+/********************************************** 
+*  bitStream decompression API (read backward) 
+**********************************************/ 
+typedef struct 
+{ 
+    size_t   bitContainer; 
+    unsigned bitsConsumed; 
+    const char* ptr; 
+    const char* start; 
+} BIT_DStream_t; 
+ 
+typedef enum { BIT_DStream_unfinished = 0, 
+               BIT_DStream_endOfBuffer = 1, 
+               BIT_DStream_completed = 2, 
+               BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */ 
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */ 
+ 
+MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize); 
+MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits); 
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD); 
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD); 
+ 
+ 
+/* 
+* Start by invoking BIT_initDStream(). 
+* A chunk of the bitStream is then stored into a local register. 
+* 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 manually filled from memory by the BIT_reloadDStream() method. 
+* A reload guarantee a minimum of ((8*sizeof(size_t))-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() 
+*/ 
+ 
+ 
+/****************************************** 
+*  unsafe API 
+******************************************/ 
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits); 
+/* faster, but works only if nbBits >= 1 */ 
+ 
+ 
+ 
+/**************************************************************** 
+*  Helper functions 
+****************************************************************/ 
+MEM_STATIC unsigned BIT_highbit32 (register U32 val) 
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
+    unsigned long r=0; 
+    _BitScanReverse ( &r, val ); 
+    return (unsigned) r; 
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */ 
+    return 31 - __builtin_clz (val); 
+#   else   /* Software version */ 
+    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 }; 
+    U32 v = val; 
+    unsigned r; 
+    v |= v >> 1; 
+    v |= v >> 2; 
+    v |= v >> 4; 
+    v |= v >> 8; 
+    v |= v >> 16; 
+    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27]; 
+    return r; 
+#   endif 
+} 
+ 
+ 
+/********************************************************** 
+* bitStream decoding 
+**********************************************************/ 
+ 
+/*!BIT_initDStream 
+*  Initialize a BIT_DStream_t. 
+*  @bitD : a pointer to an already allocated BIT_DStream_t structure 
+*  @srcBuffer must point at the beginning of a bitStream 
+*  @srcSize must be the exact size of the bitStream 
+*  @result : size of stream (== srcSize) or an errorCode if a problem is detected 
+*/ 
+MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize) 
+{ 
+    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); } 
+ 
+    if (srcSize >=  sizeof(size_t))   /* normal case */ 
+    { 
+        U32 contain32; 
+        bitD->start = (const char*)srcBuffer; 
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t); 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr); 
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1]; 
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */ 
+        bitD->bitsConsumed = 8 - BIT_highbit32(contain32); 
+    } 
+    else 
+    { 
+        U32 contain32; 
+        bitD->start = (const char*)srcBuffer; 
+        bitD->ptr   = bitD->start; 
+        bitD->bitContainer = *(const BYTE*)(bitD->start); 
+        switch(srcSize) 
+        { 
+            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16); 
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24); 
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32); 
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; 
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; 
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8; 
+            default:; 
+        } 
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1]; 
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */ 
+        bitD->bitsConsumed = 8 - BIT_highbit32(contain32); 
+        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8; 
+    } 
+ 
+    return srcSize; 
+} 
+ 
+/*!BIT_lookBits 
+ * Provides next n bits from local register 
+ * local register is not modified (bits are still present for next read/look) 
+ * On 32-bits, maxNbBits==25 
+ * On 64-bits, maxNbBits==57 
+ * @return : value extracted 
+ */ 
+MEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1; 
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask); 
+} 
+ 
+/*! BIT_lookBitsFast : 
+*   unsafe version; only works only if nbBits >= 1 */ 
+MEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1; 
+    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask); 
+} 
+ 
+MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    bitD->bitsConsumed += nbBits; 
+} 
+ 
+/*!BIT_readBits 
+ * Read next n bits from local register. 
+ * pay attention to not read more than nbBits contained into local register. 
+ * @return : extracted value. 
+ */ 
+MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t value = BIT_lookBits(bitD, nbBits); 
+    BIT_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+/*!BIT_readBitsFast : 
+*  unsafe version; only works only if nbBits >= 1 */ 
+MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t value = BIT_lookBitsFast(bitD, nbBits); 
+    BIT_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD) 
+{ 
+	if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */ 
+		return BIT_DStream_overflow; 
+ 
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) 
+    { 
+        bitD->ptr -= bitD->bitsConsumed >> 3; 
+        bitD->bitsConsumed &= 7; 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr); 
+        return BIT_DStream_unfinished; 
+    } 
+    if (bitD->ptr == bitD->start) 
+    { 
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer; 
+        return BIT_DStream_completed; 
+    } 
+    { 
+        U32 nbBytes = bitD->bitsConsumed >> 3; 
+        BIT_DStream_status result = BIT_DStream_unfinished; 
+        if (bitD->ptr - nbBytes < bitD->start) 
+        { 
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */ 
+            result = BIT_DStream_endOfBuffer; 
+        } 
+        bitD->ptr -= nbBytes; 
+        bitD->bitsConsumed -= nbBytes*8; 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */ 
+        return result; 
+    } 
+} 
+ 
+/*! BIT_endOfDStream 
+*   @return Tells if DStream has reached its exact end 
+*/ 
+MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream) 
+{ 
+    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8)); 
+} 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* BITSTREAM_H_MODULE */ 
+ 
+ 
+ 
+/* ****************************************************************** 
+   FSE : Finite State Entropy coder 
+   header file for static linking (only) 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef FSE_STATIC_H 
+#define FSE_STATIC_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* ***************************************** 
+*  Static allocation 
+*******************************************/ 
+/* FSE buffer bounds */ 
+#define FSE_NCOUNTBOUND 512 
+#define FSE_BLOCKBOUND(size) (size + (size>>7)) 
+#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */ 
+ 
+/* It is possible to statically allocate FSE CTable/DTable as a table of unsigned using below macros */ 
+#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2)) 
+#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog)) 
+ 
+ 
+/* ***************************************** 
+*  FSE advanced API 
+*******************************************/ 
+static size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits); 
+/* build a fake FSE_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */ 
+ 
+static size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue); 
+/* build a fake FSE_DTable, designed to always generate the same symbolValue */ 
+ 
+ 
+ 
+/* ***************************************** 
+*  FSE symbol decompression API 
+*******************************************/ 
+typedef struct 
+{ 
+    size_t      state; 
+    const void* table;   /* precise table may vary, depending on U16 */ 
+} FSE_DState_t; 
+ 
+ 
+static void     FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt); 
+ 
+static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD); 
+ 
+static unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr); 
+ 
+/*! 
+Let's now decompose FSE_decompress_usingDTable() into its unitary components. 
+You will decode FSE-encoded symbols from the bitStream, 
+and also any other bitFields you put in, **in reverse order**. 
+ 
+You will need a few variables to track your bitStream. They are : 
+ 
+BIT_DStream_t DStream;    // Stream context 
+FSE_DState_t  DState;     // State context. Multiple ones are possible 
+FSE_DTable*   DTablePtr;  // Decoding table, provided by FSE_buildDTable() 
+ 
+The first thing to do is to init the bitStream. 
+    errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize); 
+ 
+You should then retrieve your initial state(s) 
+(in reverse flushing order if you have several ones) : 
+    errorCode = FSE_initDState(&DState, &DStream, DTablePtr); 
+ 
+You can then decode your data, symbol after symbol. 
+For information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'. 
+Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out). 
+    unsigned char symbol = FSE_decodeSymbol(&DState, &DStream); 
+ 
+You can retrieve any bitfield you eventually stored into the bitStream (in reverse order) 
+Note : maximum allowed nbBits is 25, for 32-bits compatibility 
+    size_t bitField = BIT_readBits(&DStream, nbBits); 
+ 
+All above operations only read from local register (which size depends on size_t). 
+Refueling the register from memory is manually performed by the reload method. 
+    endSignal = FSE_reloadDStream(&DStream); 
+ 
+BIT_reloadDStream() result tells if there is still some more data to read from DStream. 
+BIT_DStream_unfinished : there is still some data left into the DStream. 
+BIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled. 
+BIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed. 
+BIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted. 
+ 
+When reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop, 
+to properly detect the exact end of stream. 
+After each decoded symbol, check if DStream is fully consumed using this simple test : 
+    BIT_reloadDStream(&DStream) >= BIT_DStream_completed 
+ 
+When it's done, verify decompression is fully completed, by checking both DStream and the relevant states. 
+Checking if DStream has reached its end is performed by : 
+    BIT_endOfDStream(&DStream); 
+Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible. 
+    FSE_endOfDState(&DState); 
+*/ 
+ 
+ 
+/* ***************************************** 
+*  FSE unsafe API 
+*******************************************/ 
+static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD); 
+/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */ 
+ 
+ 
+/* ***************************************** 
+*  Implementation of inlined functions 
+*******************************************/ 
+/* decompression */ 
+ 
+typedef struct { 
+    U16 tableLog; 
+    U16 fastMode; 
+} FSE_DTableHeader;   /* sizeof U32 */ 
+ 
+typedef struct 
+{ 
+    unsigned short newState; 
+    unsigned char  symbol; 
+    unsigned char  nbBits; 
+} FSE_decode_t;   /* size == U32 */ 
+ 
+MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt) 
+{ 
+    FSE_DTableHeader DTableH; 
+    memcpy(&DTableH, dt, sizeof(DTableH)); 
+    DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog); 
+    BIT_reloadDStream(bitD); 
+    DStatePtr->table = dt + 1; 
+} 
+ 
+MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) 
+{ 
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    const U32  nbBits = DInfo.nbBits; 
+    BYTE symbol = DInfo.symbol; 
+    size_t lowBits = BIT_readBits(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD) 
+{ 
+    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    const U32 nbBits = DInfo.nbBits; 
+    BYTE symbol = DInfo.symbol; 
+    size_t lowBits = BIT_readBitsFast(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr) 
+{ 
+    return DStatePtr->state == 0; 
+} 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* FSE_STATIC_H */ 
+ 
+/* ****************************************************************** 
+   FSE : Finite State Entropy coder 
+   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 
+****************************************************************** */ 
+ 
+#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 */ 
+ 
+/* ************************************************************** 
+*  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 
+ 
+ 
+/* ************************************************************** 
+*  Dependencies 
+****************************************************************/ 
+#include <stdlib.h>     /* malloc, free, qsort */ 
+#include <string.h>     /* memcpy, memset */ 
+#include <stdio.h>      /* printf (debug) */ 
+ 
+ 
+/* *************************************************************** 
+*  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 
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#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) 
+ 
+static U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; } 
+ 
+ 
+static size_t FSE_buildDTable(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) 
+{ 
+    FSE_DTableHeader DTableH; 
+    void* const tdPtr = dt+1;   /* because dt is unsigned, 32-bits aligned on 32-bits */ 
+    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*) (tdPtr); 
+    const U32 tableSize = 1 << tableLog; 
+    const U32 tableMask = tableSize-1; 
+    const U32 step = FSE_tableStep(tableSize); 
+    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1]; 
+    U32 position = 0; 
+    U32 highThreshold = tableSize-1; 
+    const S16 largeLimit= (S16)(1 << (tableLog-1)); 
+    U32 noLarge = 1; 
+    U32 s; 
+ 
+    /* 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 */ 
+    DTableH.tableLog = (U16)tableLog; 
+    for (s=0; s<=maxSymbolValue; s++) 
+    { 
+        if (normalizedCounter[s]==-1) 
+        { 
+            tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s; 
+            symbolNext[s] = 1; 
+        } 
+        else 
+        { 
+            if (normalizedCounter[s] >= largeLimit) noLarge=0; 
+            symbolNext[s] = normalizedCounter[s]; 
+        } 
+    } 
+ 
+    /* Spread symbols */ 
+    for (s=0; s<=maxSymbolValue; 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 i; 
+        for (i=0; i<tableSize; i++) 
+        { 
+            FSE_FUNCTION_TYPE symbol = (FSE_FUNCTION_TYPE)(tableDecode[i].symbol); 
+            U16 nextState = symbolNext[symbol]++; 
+            tableDecode[i].nbBits = (BYTE) (tableLog - BIT_highbit32 ((U32)nextState) ); 
+            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize); 
+        } 
+    } 
+ 
+    DTableH.fastMode = (U16)noLarge; 
+    memcpy(dt, &DTableH, sizeof(DTableH)); 
+    return 0; 
+} 
+ 
+ 
+#ifndef FSE_COMMONDEFS_ONLY 
+/****************************************** 
+*  FSE helper functions 
+******************************************/ 
+static unsigned FSE_isError(size_t code) { return ERR_isError(code); } 
+ 
+ 
+/**************************************************************** 
+*  FSE NCount encoding-decoding 
+****************************************************************/ 
+static short FSE_abs(short a) 
+{ 
+    return a<0 ? -a : a; 
+} 
+ 
+static 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; 
+        } 
+        { 
+            const short 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); 
+            } 
+        } 
+    } 
+    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; 
+} 
+ 
+ 
+/********************************************************* 
+*  Decompression (Byte symbols) 
+*********************************************************/ 
+static 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; 
+} 
+ 
+ 
+static 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 maxSymbolValue = tableMask; 
+    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<=maxSymbolValue; 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; 
+    size_t errorCode; 
+ 
+    /* Init */ 
+    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 ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) ) 
+            break; 
+ 
+        *op++ = FSE_GETSYMBOL(&state1); 
+ 
+        if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) ) 
+            break; 
+ 
+        *op++ = FSE_GETSYMBOL(&state2); 
+    } 
+ 
+    /* end ? */ 
+    if (BIT_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2)) 
+        return op-ostart; 
+ 
+    if (op==omax) return ERROR(dstSize_tooSmall);   /* dst buffer is full, but cSrc unfinished */ 
+ 
+    return ERROR(corruption_detected); 
+} 
+ 
+ 
+static size_t FSE_decompress_usingDTable(void* dst, size_t originalSize, 
+                            const void* cSrc, size_t cSrcSize, 
+                            const FSE_DTable* dt) 
+{ 
+    FSE_DTableHeader DTableH; 
+    U32 fastMode; 
+ 
+    memcpy(&DTableH, dt, sizeof(DTableH)); 
+    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); 
+} 
+ 
+ 
+static 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; 
+    size_t errorCode; 
+ 
+    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */ 
+ 
+    /* normal FSE decoding mode */ 
+    errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize); 
+    if (FSE_isError(errorCode)) return errorCode; 
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */ 
+    ip += errorCode; 
+    cSrcSize -= errorCode; 
+ 
+    errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog); 
+    if (FSE_isError(errorCode)) return errorCode; 
+ 
+    /* always return, even if it is an error code */ 
+    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt); 
+} 
+ 
+ 
+ 
+#endif   /* FSE_COMMONDEFS_ONLY */ 
+ 
+ 
+/* ****************************************************************** 
+   Huff0 : Huffman coder, part of New Generation Entropy library 
+   header file 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef HUFF0_H 
+#define HUFF0_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* **************************************** 
+*  Dependency 
+******************************************/ 
+#include <stddef.h>    /* size_t */ 
+ 
+ 
+/* **************************************** 
+*  Huff0 simple functions 
+******************************************/ 
+static size_t HUF_decompress(void* dst,  size_t dstSize, 
+                const void* cSrc, size_t cSrcSize); 
+/*! 
+HUF_decompress(): 
+    Decompress Huff0 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 
+******************************************/ 
+/* Error Management */ 
+static unsigned    HUF_isError(size_t code);        /* tells if a return value is an error code */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif   /* HUFF0_H */ 
+ 
+ 
+/* ****************************************************************** 
+   Huff0 : Huffman coder, part of New Generation Entropy library 
+   header file for static linking (only) 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef HUFF0_STATIC_H 
+#define HUFF0_STATIC_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+ 
+/* **************************************** 
+*  Static allocation macros 
+******************************************/ 
+/* static allocation of Huff0's DTable */ 
+#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog))  /* nb Cells; use unsigned short for X2, unsigned int for X4 */ 
+#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 
+******************************************/ 
+static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */ 
+static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */ 
+ 
+ 
+/* **************************************** 
+*  Huff0 detailed API 
+******************************************/ 
+/*! 
+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 
+ 
+*/ 
+static size_t HUF_readDTableX2 (unsigned short* DTable, const void* src, size_t srcSize); 
+static size_t HUF_readDTableX4 (unsigned* DTable, const void* src, size_t srcSize); 
+ 
+static size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable); 
+static size_t HUF_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable); 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* HUFF0_STATIC_H */ 
+ 
+ 
+ 
+/* ****************************************************************** 
+   Huff0 : Huffman coder, part of New Generation Entropy library 
+   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+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+****************************************************************** */ 
+ 
+/* ************************************************************** 
+*  Compiler specifics 
+****************************************************************/ 
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+/* inline is defined */ 
+#elif defined(_MSC_VER) 
+#  define inline __inline 
+#else 
+#  define inline /* disable inline */ 
+#endif 
+ 
+ 
+#ifdef _MSC_VER    /* Visual Studio */ 
+#  define FORCE_INLINE static __forceinline 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#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) */ 
+ 
+ 
+/* ************************************************************** 
+*  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 
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
+static unsigned HUF_isError(size_t code) { return ERR_isError(code); } 
+#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */ 
+ 
+ 
+ 
+/*-******************************************************* 
+*  Huff0 : Huffman block decompression 
+*********************************************************/ 
+typedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2;   /* single-symbol decoding */ 
+ 
+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4;  /* double-symbols decoding */ 
+ 
+typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t; 
+ 
+/*! HUF_readStats 
+    Read compact Huffman tree, saved by HUF_writeCTable 
+    @huffWeight : destination buffer 
+    @return : size read from `src` 
+*/ 
+static size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats, 
+                            U32* nbSymbolsPtr, U32* tableLogPtr, 
+                            const void* src, size_t srcSize) 
+{ 
+    U32 weightTotal; 
+    U32 tableLog; 
+    const BYTE* ip = (const BYTE*) src; 
+    size_t iSize = ip[0]; 
+    size_t oSize; 
+    U32 n; 
+ 
+    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    if (iSize >= 128)  /* special header */ 
+    { 
+        if (iSize >= (242))   /* RLE */ 
+        { 
+            static int 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; 
+            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; 
+    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) */ 
+    tableLog = BIT_highbit32(weightTotal) + 1; 
+    if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected); 
+    { 
+        U32 total = 1 << tableLog; 
+        U32 rest = total - weightTotal; 
+        U32 verif = 1 << BIT_highbit32(rest); 
+        U32 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); 
+    *tableLogPtr = tableLog; 
+    return iSize+1; 
+} 
+ 
+ 
+/**************************/ 
+/* single-symbol decoding */ 
+/**************************/ 
+ 
+static size_t HUF_readDTableX2 (U16* DTable, const void* src, size_t srcSize) 
+{ 
+    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1]; 
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];   /* large enough for values from 0 to 16 */ 
+    U32 tableLog = 0; 
+    size_t iSize; 
+    U32 nbSymbols = 0; 
+    U32 n; 
+    U32 nextRankStart; 
+    void* const dtPtr = DTable + 1; 
+    HUF_DEltX2* const dt = (HUF_DEltX2*)dtPtr; 
+ 
+    HUF_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */ 
+    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    iSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize); 
+    if (HUF_isError(iSize)) return iSize; 
+ 
+    /* check result */ 
+    if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge);   /* DTable is too small */ 
+    DTable[0] = (U16)tableLog;   /* maybe should separate sizeof DTable, as allocated, from used size of DTable, in case of DTable re-use */ 
+ 
+    /* Prepare ranks */ 
+    nextRankStart = 0; 
+    for (n=1; n<=tableLog; n++) 
+    { 
+        U32 current = nextRankStart; 
+        nextRankStart += (rankVal[n] << (n-1)); 
+        rankVal[n] = current; 
+    } 
+ 
+    /* fill DTable */ 
+    for (n=0; n<nbSymbols; n++) 
+    { 
+        const U32 w = huffWeight[n]; 
+        const U32 length = (1 << w) >> 1; 
+        U32 i; 
+        HUF_DEltX2 D; 
+        D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w); 
+        for (i = rankVal[w]; i < rankVal[w] + length; i++) 
+            dt[i] = D; 
+        rankVal[w] += length; 
+    } 
+ 
+    return iSize; 
+} 
+ 
+static BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog) 
+{ 
+        const size_t val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */ 
+        const BYTE c = dt[val].byte; 
+        BIT_skipBits(Dstream, dt[val].nbBits); 
+        return c; 
+} 
+ 
+#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \ 
+    *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog) 
+ 
+#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \ 
+    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \ 
+        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) 
+ 
+#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \ 
+    if (MEM_64bits()) \ 
+        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) 
+ 
+static inline size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog) 
+{ 
+    BYTE* const pStart = p; 
+ 
+    /* up to 4 symbols at a time */ 
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4)) 
+    { 
+        HUF_DECODE_SYMBOLX2_2(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX2_1(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX2_2(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr); 
+    } 
+ 
+    /* closer to the end */ 
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd)) 
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr); 
+ 
+    /* no more data to retrieve from bitstream, hence no need to reload */ 
+    while (p < pEnd) 
+        HUF_DECODE_SYMBOLX2_0(p, bitDPtr); 
+ 
+    return pEnd-pStart; 
+} 
+ 
+ 
+static size_t HUF_decompress4X2_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const U16* DTable) 
+{ 
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */ 
+ 
+    { 
+        const BYTE* const istart = (const BYTE*) cSrc; 
+        BYTE* const ostart = (BYTE*) dst; 
+        BYTE* const oend = ostart + dstSize; 
+        const void* const dtPtr = DTable; 
+        const HUF_DEltX2* const dt = ((const HUF_DEltX2*)dtPtr) +1; 
+        const U32 dtLog = DTable[0]; 
+        size_t errorCode; 
+ 
+        /* Init */ 
+        BIT_DStream_t bitD1; 
+        BIT_DStream_t bitD2; 
+        BIT_DStream_t bitD3; 
+        BIT_DStream_t bitD4; 
+        const size_t length1 = MEM_readLE16(istart); 
+        const size_t length2 = MEM_readLE16(istart+2); 
+        const size_t length3 = MEM_readLE16(istart+4); 
+        size_t length4; 
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */ 
+        const BYTE* const istart2 = istart1 + length1; 
+        const BYTE* const istart3 = istart2 + length2; 
+        const BYTE* const istart4 = istart3 + length3; 
+        const size_t segmentSize = (dstSize+3) / 4; 
+        BYTE* const opStart2 = ostart + segmentSize; 
+        BYTE* const opStart3 = opStart2 + segmentSize; 
+        BYTE* const opStart4 = opStart3 + segmentSize; 
+        BYTE* op1 = ostart; 
+        BYTE* op2 = opStart2; 
+        BYTE* op3 = opStart3; 
+        BYTE* op4 = opStart4; 
+        U32 endSignal; 
+ 
+        length4 = cSrcSize - (length1 + length2 + length3 + 6); 
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */ 
+        errorCode = BIT_initDStream(&bitD1, istart1, length1); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD2, istart2, length2); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD3, istart3, length3); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD4, istart4, length4); 
+        if (HUF_isError(errorCode)) return errorCode; 
+ 
+        /* 16-32 symbols per loop (4-8 symbols per stream) */ 
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); 
+        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; ) 
+        { 
+            HUF_DECODE_SYMBOLX2_2(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX2_2(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX2_2(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX2_2(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX2_1(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX2_1(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX2_1(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX2_1(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX2_2(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX2_2(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX2_2(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX2_2(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX2_0(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX2_0(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX2_0(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX2_0(op4, &bitD4); 
+ 
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); 
+        } 
+ 
+        /* check corruption */ 
+        if (op1 > opStart2) return ERROR(corruption_detected); 
+        if (op2 > opStart3) return ERROR(corruption_detected); 
+        if (op3 > opStart4) return ERROR(corruption_detected); 
+        /* note : op4 supposed already verified within main loop */ 
+ 
+        /* finish bitStreams one by one */ 
+        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog); 
+        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog); 
+        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog); 
+        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog); 
+ 
+        /* check */ 
+        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4); 
+        if (!endSignal) return ERROR(corruption_detected); 
+ 
+        /* decoded size */ 
+        return dstSize; 
+    } 
+} 
+ 
+ 
+static size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+    size_t errorCode; 
+ 
+    errorCode = HUF_readDTableX2 (DTable, cSrc, cSrcSize); 
+    if (HUF_isError(errorCode)) return errorCode; 
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += errorCode; 
+    cSrcSize -= errorCode; 
+ 
+    return HUF_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable); 
+} 
+ 
+ 
+/***************************/ 
+/* double-symbols decoding */ 
+/***************************/ 
+ 
+static void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed, 
+                           const U32* rankValOrigin, const int minWeight, 
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize, 
+                           U32 nbBitsBaseline, U16 baseSeq) 
+{ 
+    HUF_DEltX4 DElt; 
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1]; 
+    U32 s; 
+ 
+    /* get pre-calculated rankVal */ 
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal)); 
+ 
+    /* fill skipped values */ 
+    if (minWeight>1) 
+    { 
+        U32 i, skipSize = rankVal[minWeight]; 
+        MEM_writeLE16(&(DElt.sequence), baseSeq); 
+        DElt.nbBits   = (BYTE)(consumed); 
+        DElt.length   = 1; 
+        for (i = 0; i < skipSize; i++) 
+            DTable[i] = DElt; 
+    } 
+ 
+    /* fill DTable */ 
+    for (s=0; s<sortedListSize; s++)   /* note : sortedSymbols already skipped */ 
+    { 
+        const U32 symbol = sortedSymbols[s].symbol; 
+        const U32 weight = sortedSymbols[s].weight; 
+        const U32 nbBits = nbBitsBaseline - weight; 
+        const U32 length = 1 << (sizeLog-nbBits); 
+        const U32 start = rankVal[weight]; 
+        U32 i = start; 
+        const U32 end = start + length; 
+ 
+        MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8))); 
+        DElt.nbBits = (BYTE)(nbBits + consumed); 
+        DElt.length = 2; 
+        do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */ 
+ 
+        rankVal[weight] += length; 
+    } 
+} 
+ 
+typedef U32 rankVal_t[HUF_ABSOLUTEMAX_TABLELOG][HUF_ABSOLUTEMAX_TABLELOG + 1]; 
+ 
+static void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog, 
+                           const sortedSymbol_t* sortedList, const U32 sortedListSize, 
+                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight, 
+                           const U32 nbBitsBaseline) 
+{ 
+    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1]; 
+    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */ 
+    const U32 minBits  = nbBitsBaseline - maxWeight; 
+    U32 s; 
+ 
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal)); 
+ 
+    /* fill DTable */ 
+    for (s=0; s<sortedListSize; s++) 
+    { 
+        const U16 symbol = sortedList[s].symbol; 
+        const U32 weight = sortedList[s].weight; 
+        const U32 nbBits = nbBitsBaseline - weight; 
+        const U32 start = rankVal[weight]; 
+        const U32 length = 1 << (targetLog-nbBits); 
+ 
+        if (targetLog-nbBits >= minBits)   /* enough room for a second symbol */ 
+        { 
+            U32 sortedRank; 
+            int minWeight = nbBits + scaleLog; 
+            if (minWeight < 1) minWeight = 1; 
+            sortedRank = rankStart[minWeight]; 
+            HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits, 
+                           rankValOrigin[nbBits], minWeight, 
+                           sortedList+sortedRank, sortedListSize-sortedRank, 
+                           nbBitsBaseline, symbol); 
+        } 
+        else 
+        { 
+            U32 i; 
+            const U32 end = start + length; 
+            HUF_DEltX4 DElt; 
+ 
+            MEM_writeLE16(&(DElt.sequence), symbol); 
+            DElt.nbBits   = (BYTE)(nbBits); 
+            DElt.length   = 1; 
+            for (i = start; i < end; i++) 
+                DTable[i] = DElt; 
+        } 
+        rankVal[weight] += length; 
+    } 
+} 
+ 
+static size_t HUF_readDTableX4 (U32* DTable, const void* src, size_t srcSize) 
+{ 
+    BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1]; 
+    sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1]; 
+    U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 }; 
+    U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 }; 
+    U32* const rankStart = rankStart0+1; 
+    rankVal_t rankVal; 
+    U32 tableLog, maxW, sizeOfSort, nbSymbols; 
+    const U32 memLog = DTable[0]; 
+    size_t iSize; 
+    void* dtPtr = DTable; 
+    HUF_DEltX4* const dt = ((HUF_DEltX4*)dtPtr) + 1; 
+ 
+    HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */ 
+    if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge); 
+    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize); 
+    if (HUF_isError(iSize)) return iSize; 
+ 
+    /* check result */ 
+    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */ 
+ 
+    /* find maxWeight */ 
+    for (maxW = tableLog; rankStats[maxW]==0; maxW--) 
+        { if (!maxW) return ERROR(GENERIC); }  /* necessarily finds a solution before maxW==0 */ 
+ 
+    /* Get start index of each weight */ 
+    { 
+        U32 w, nextRankStart = 0; 
+        for (w=1; w<=maxW; w++) 
+        { 
+            U32 current = nextRankStart; 
+            nextRankStart += rankStats[w]; 
+            rankStart[w] = current; 
+        } 
+        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/ 
+        sizeOfSort = nextRankStart; 
+    } 
+ 
+    /* sort symbols by weight */ 
+    { 
+        U32 s; 
+        for (s=0; s<nbSymbols; s++) 
+        { 
+            U32 w = weightList[s]; 
+            U32 r = rankStart[w]++; 
+            sortedSymbol[r].symbol = (BYTE)s; 
+            sortedSymbol[r].weight = (BYTE)w; 
+        } 
+        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */ 
+    } 
+ 
+    /* Build rankVal */ 
+    { 
+        const U32 minBits = tableLog+1 - maxW; 
+        U32 nextRankVal = 0; 
+        U32 w, consumed; 
+        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */ 
+        U32* rankVal0 = rankVal[0]; 
+        for (w=1; w<=maxW; w++) 
+        { 
+            U32 current = nextRankVal; 
+            nextRankVal += rankStats[w] << (w+rescale); 
+            rankVal0[w] = current; 
+        } 
+        for (consumed = minBits; consumed <= memLog - minBits; consumed++) 
+        { 
+            U32* rankValPtr = rankVal[consumed]; 
+            for (w = 1; w <= maxW; w++) 
+            { 
+                rankValPtr[w] = rankVal0[w] >> consumed; 
+            } 
+        } 
+    } 
+ 
+    HUF_fillDTableX4(dt, memLog, 
+                   sortedSymbol, sizeOfSort, 
+                   rankStart0, rankVal, maxW, 
+                   tableLog+1); 
+ 
+    return iSize; 
+} 
+ 
+ 
+static U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog) 
+{ 
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    memcpy(op, dt+val, 2); 
+    BIT_skipBits(DStream, dt[val].nbBits); 
+    return dt[val].length; 
+} 
+ 
+static U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog) 
+{ 
+    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    memcpy(op, dt+val, 1); 
+    if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits); 
+    else 
+    { 
+        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) 
+        { 
+            BIT_skipBits(DStream, dt[val].nbBits); 
+            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8)) 
+                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */ 
+        } 
+    } 
+    return 1; 
+} 
+ 
+ 
+#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \ 
+    ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+#define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \ 
+    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \ 
+        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+#define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \ 
+    if (MEM_64bits()) \ 
+        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+static inline size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog) 
+{ 
+    BYTE* const pStart = p; 
+ 
+    /* up to 8 symbols at a time */ 
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd-7)) 
+    { 
+        HUF_DECODE_SYMBOLX4_2(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX4_1(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX4_2(p, bitDPtr); 
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr); 
+    } 
+ 
+    /* closer to the end */ 
+    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-2)) 
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr); 
+ 
+    while (p <= pEnd-2) 
+        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */ 
+ 
+    if (p < pEnd) 
+        p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog); 
+ 
+    return p-pStart; 
+} 
+ 
+static size_t HUF_decompress4X4_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const U32* DTable) 
+{ 
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */ 
+ 
+    { 
+        const BYTE* const istart = (const BYTE*) cSrc; 
+        BYTE* const ostart = (BYTE*) dst; 
+        BYTE* const oend = ostart + dstSize; 
+        const void* const dtPtr = DTable; 
+        const HUF_DEltX4* const dt = ((const HUF_DEltX4*)dtPtr) +1; 
+        const U32 dtLog = DTable[0]; 
+        size_t errorCode; 
+ 
+        /* Init */ 
+        BIT_DStream_t bitD1; 
+        BIT_DStream_t bitD2; 
+        BIT_DStream_t bitD3; 
+        BIT_DStream_t bitD4; 
+        const size_t length1 = MEM_readLE16(istart); 
+        const size_t length2 = MEM_readLE16(istart+2); 
+        const size_t length3 = MEM_readLE16(istart+4); 
+        size_t length4; 
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */ 
+        const BYTE* const istart2 = istart1 + length1; 
+        const BYTE* const istart3 = istart2 + length2; 
+        const BYTE* const istart4 = istart3 + length3; 
+        const size_t segmentSize = (dstSize+3) / 4; 
+        BYTE* const opStart2 = ostart + segmentSize; 
+        BYTE* const opStart3 = opStart2 + segmentSize; 
+        BYTE* const opStart4 = opStart3 + segmentSize; 
+        BYTE* op1 = ostart; 
+        BYTE* op2 = opStart2; 
+        BYTE* op3 = opStart3; 
+        BYTE* op4 = opStart4; 
+        U32 endSignal; 
+ 
+        length4 = cSrcSize - (length1 + length2 + length3 + 6); 
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */ 
+        errorCode = BIT_initDStream(&bitD1, istart1, length1); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD2, istart2, length2); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD3, istart3, length3); 
+        if (HUF_isError(errorCode)) return errorCode; 
+        errorCode = BIT_initDStream(&bitD4, istart4, length4); 
+        if (HUF_isError(errorCode)) return errorCode; 
+ 
+        /* 16-32 symbols per loop (4-8 symbols per stream) */ 
+        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); 
+        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; ) 
+        { 
+            HUF_DECODE_SYMBOLX4_2(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX4_2(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX4_2(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX4_2(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX4_1(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX4_1(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX4_1(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX4_1(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX4_2(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX4_2(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX4_2(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX4_2(op4, &bitD4); 
+            HUF_DECODE_SYMBOLX4_0(op1, &bitD1); 
+            HUF_DECODE_SYMBOLX4_0(op2, &bitD2); 
+            HUF_DECODE_SYMBOLX4_0(op3, &bitD3); 
+            HUF_DECODE_SYMBOLX4_0(op4, &bitD4); 
+ 
+            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4); 
+        } 
+ 
+        /* check corruption */ 
+        if (op1 > opStart2) return ERROR(corruption_detected); 
+        if (op2 > opStart3) return ERROR(corruption_detected); 
+        if (op3 > opStart4) return ERROR(corruption_detected); 
+        /* note : op4 supposed already verified within main loop */ 
+ 
+        /* finish bitStreams one by one */ 
+        HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog); 
+        HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog); 
+        HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog); 
+        HUF_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog); 
+ 
+        /* check */ 
+        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4); 
+        if (!endSignal) return ERROR(corruption_detected); 
+ 
+        /* decoded size */ 
+        return dstSize; 
+    } 
+} 
+ 
+ 
+static size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
+    size_t hSize = HUF_readDTableX4 (DTable, cSrc, cSrcSize); 
+    if (HUF_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; 
+    cSrcSize -= hSize; 
+ 
+    return HUF_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable); 
+} 
+ 
+ 
+/**********************************/ 
+/* Generic decompression selector */ 
+/**********************************/ 
+ 
+typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t; 
+static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] = 
+{ 
+    /* single, double, quad */ 
+    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */ 
+    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */ 
+    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */ 
+    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */ 
+    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */ 
+    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */ 
+    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */ 
+    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */ 
+    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */ 
+    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */ 
+    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */ 
+    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */ 
+    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */ 
+    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */ 
+    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */ 
+    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */ 
+}; 
+ 
+typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); 
+ 
+static size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
     static const decompressionAlgo decompress[3] = { HUF_decompress4X2, HUF_decompress4X4, NULL };
-    /* estimate decompression time */
-    U32 Q;
-    const U32 D256 = (U32)(dstSize >> 8);
-    U32 Dtime[3];
-    U32 algoNb = 0;
-    int n;
-
-    /* validation checks */
-    if (dstSize == 0) return ERROR(dstSize_tooSmall);
-    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
-    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
-    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
-
-    /* decoder timing evaluation */
-    Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */
-    for (n=0; n<3; n++)
-        Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256);
-
-    Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */
-
-    if (Dtime[1] < Dtime[0]) algoNb = 1;
-
-    return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
-
-    //return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize);   /* multi-streams single-symbol decoding */
-    //return HUF_decompress4X4(dst, dstSize, cSrc, cSrcSize);   /* multi-streams double-symbols decoding */
-    //return HUF_decompress4X6(dst, dstSize, cSrc, cSrcSize);   /* multi-streams quad-symbols decoding */
-}
-
-
-
-#endif   /* ZSTD_CCOMMON_H_MODULE */
-
-
-/*
-    zstd - decompression module fo v0.4 legacy format
-    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 source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-
-/* ***************************************************************
-*  Tuning parameters
-*****************************************************************/
-/*!
- * HEAPMODE :
- * Select how default decompression function ZSTD_decompress() will allocate memory,
- * in memory stack (0), or in memory heap (1, requires malloc())
- */
-#ifndef ZSTD_HEAPMODE
-#  define ZSTD_HEAPMODE 1
-#endif
-
-
-/* *******************************************************
-*  Includes
-*********************************************************/
-#include <stdlib.h>      /* calloc */
-#include <string.h>      /* memcpy, memmove */
-#include <stdio.h>       /* debug : printf */
-
-
-/* *******************************************************
-*  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 : 4324)        /* disable: C4324: padded structure */
-#else
-#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#  ifdef __GNUC__
-#    define FORCE_INLINE static inline __attribute__((always_inline))
-#  else
-#    define FORCE_INLINE static inline
-#  endif
-#endif
-
-
-/* *************************************
-*  Local types
-***************************************/
-typedef struct
-{
-    blockType_t blockType;
-    U32 origSize;
-} blockProperties_t;
-
-
-/* *******************************************************
-*  Memory operations
-**********************************************************/
-static void ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
-
-
-/* *************************************
-*  Error Management
-***************************************/
-
-/*! ZSTD_isError
-*   tells if a return value is an error code */
-static unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }
-
-
-/* *************************************************************
-*   Context management
-***************************************************************/
-typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,
-               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock } ZSTD_dStage;
-
-struct ZSTDv04_Dctx_s
-{
-    U32 LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)];
-    U32 OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)];
-    U32 MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)];
-    const void* previousDstEnd;
-    const void* base;
-    const void* vBase;
-    const void* dictEnd;
-    size_t expected;
-    size_t headerSize;
-    ZSTD_parameters params;
-    blockType_t bType;
-    ZSTD_dStage stage;
-    const BYTE* litPtr;
-    size_t litBufSize;
-    size_t litSize;
-    BYTE litBuffer[BLOCKSIZE + 8 /* margin for wildcopy */];
-    BYTE headerBuffer[ZSTD_frameHeaderSize_max];
-};  /* typedef'd to ZSTD_DCtx within "zstd_static.h" */
-
-static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx)
-{
-    dctx->expected = ZSTD_frameHeaderSize_min;
-    dctx->stage = ZSTDds_getFrameHeaderSize;
-    dctx->previousDstEnd = NULL;
-    dctx->base = NULL;
-    dctx->vBase = NULL;
-    dctx->dictEnd = NULL;
-    return 0;
-}
-
-static ZSTD_DCtx* ZSTD_createDCtx(void)
-{
-    ZSTD_DCtx* dctx = (ZSTD_DCtx*)malloc(sizeof(ZSTD_DCtx));
-    if (dctx==NULL) return NULL;
-    ZSTD_resetDCtx(dctx);
-    return dctx;
-}
-
-static size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
-{
-    free(dctx);
-    return 0;
-}
-
-
-/* *************************************************************
-*   Decompression section
-***************************************************************/
-/** ZSTD_decodeFrameHeader_Part1
-*   decode the 1st part of the Frame Header, which tells Frame Header size.
-*   srcSize must be == ZSTD_frameHeaderSize_min
-*   @return : the full size of the Frame Header */
-static size_t ZSTD_decodeFrameHeader_Part1(ZSTD_DCtx* zc, const void* src, size_t srcSize)
-{
-    U32 magicNumber;
-    if (srcSize != ZSTD_frameHeaderSize_min) return ERROR(srcSize_wrong);
-    magicNumber = MEM_readLE32(src);
-    if (magicNumber != ZSTD_MAGICNUMBER) return ERROR(prefix_unknown);
-    zc->headerSize = ZSTD_frameHeaderSize_min;
-    return zc->headerSize;
-}
-
-
-static size_t ZSTD_getFrameParams(ZSTD_parameters* params, const void* src, size_t srcSize)
-{
-    U32 magicNumber;
-    if (srcSize < ZSTD_frameHeaderSize_min) return ZSTD_frameHeaderSize_max;
-    magicNumber = MEM_readLE32(src);
-    if (magicNumber != ZSTD_MAGICNUMBER) return ERROR(prefix_unknown);
-    memset(params, 0, sizeof(*params));
-    params->windowLog = (((const BYTE*)src)[4] & 15) + ZSTD_WINDOWLOG_ABSOLUTEMIN;
-    if ((((const BYTE*)src)[4] >> 4) != 0) return ERROR(frameParameter_unsupported);   /* reserved bits */
-    return 0;
-}
-
-/** ZSTD_decodeFrameHeader_Part2
-*   decode the full Frame Header
-*   srcSize must be the size provided by ZSTD_decodeFrameHeader_Part1
-*   @return : 0, or an error code, which can be tested using ZSTD_isError() */
-static size_t ZSTD_decodeFrameHeader_Part2(ZSTD_DCtx* zc, const void* src, size_t srcSize)
-{
-    size_t result;
-    if (srcSize != zc->headerSize) return ERROR(srcSize_wrong);
-    result = ZSTD_getFrameParams(&(zc->params), src, srcSize);
-    if ((MEM_32bits()) && (zc->params.windowLog > 25)) return ERROR(frameParameter_unsupportedBy32bitsImplementation);
-    return result;
-}
-
-
-static size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
-{
-    const BYTE* const in = (const BYTE* const)src;
-    BYTE headerFlags;
-    U32 cSize;
-
-    if (srcSize < 3) return ERROR(srcSize_wrong);
-
-    headerFlags = *in;
-    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);
-
-    bpPtr->blockType = (blockType_t)(headerFlags >> 6);
-    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;
-
-    if (bpPtr->blockType == bt_end) return 0;
-    if (bpPtr->blockType == bt_rle) return 1;
-    return cSize;
-}
-
-static size_t ZSTD_copyRawBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall);
-    memcpy(dst, src, srcSize);
-    return srcSize;
-}
-
-
-/** ZSTD_decompressLiterals
-    @return : nb of bytes read from src, or an error code*/
-static size_t ZSTD_decompressLiterals(void* dst, size_t* maxDstSizePtr,
-                                const void* src, size_t srcSize)
-{
-    const BYTE* ip = (const BYTE*)src;
-
-    const size_t litSize = (MEM_readLE32(src) & 0x1FFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
-    const size_t litCSize = (MEM_readLE32(ip+2) & 0xFFFFFF) >> 5;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
-
-    if (litSize > *maxDstSizePtr) return ERROR(corruption_detected);
-    if (litCSize + 5 > srcSize) return ERROR(corruption_detected);
-
-    if (HUF_isError(HUF_decompress(dst, litSize, ip+5, litCSize))) return ERROR(corruption_detected);
-
-    *maxDstSizePtr = litSize;
-    return litCSize + 5;
-}
-
-
-/** ZSTD_decodeLiteralsBlock
-    @return : nb of bytes read from src (< srcSize ) */
-static size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,
-                          const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */
-{
-    const BYTE* const istart = (const BYTE*) src;
-
-    /* any compressed block with literals segment must be at least this size */
-    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
-
-    switch(*istart & 3)
-    {
-    /* compressed */
-    case 0:
-        {
-            size_t litSize = BLOCKSIZE;
-            const size_t readSize = ZSTD_decompressLiterals(dctx->litBuffer, &litSize, src, srcSize);
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litBufSize = BLOCKSIZE+8;
-            dctx->litSize = litSize;
-            return readSize;   /* works if it's an error too */
-        }
-    case IS_RAW:
-        {
-            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
-            if (litSize > srcSize-11)   /* risk of reading too far with wildcopy */
-            {
-                if (litSize > srcSize-3) return ERROR(corruption_detected);
-                memcpy(dctx->litBuffer, istart, litSize);
-                dctx->litPtr = dctx->litBuffer;
-                dctx->litBufSize = BLOCKSIZE+8;
-                dctx->litSize = litSize;
-                return litSize+3;
-            }
-            /* direct reference into compressed stream */
-            dctx->litPtr = istart+3;
-            dctx->litBufSize = srcSize-3;
-            dctx->litSize = litSize;
-            return litSize+3;        }
-    case IS_RLE:
-        {
-            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */
-            if (litSize > BLOCKSIZE) return ERROR(corruption_detected);
-            memset(dctx->litBuffer, istart[3], litSize);
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litBufSize = BLOCKSIZE+8;
-            dctx->litSize = litSize;
-            return 4;
-        }
-    default:
-        return ERROR(corruption_detected);   /* forbidden nominal case */
-    }
-}
-
-
-static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,
-                         FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb,
-                         const void* src, size_t srcSize)
-{
-    const BYTE* const istart = (const BYTE* const)src;
-    const BYTE* ip = istart;
-    const BYTE* const iend = istart + srcSize;
-    U32 LLtype, Offtype, MLtype;
-    U32 LLlog, Offlog, MLlog;
-    size_t dumpsLength;
-
-    /* check */
-    if (srcSize < 5) return ERROR(srcSize_wrong);
-
-    /* SeqHead */
-    *nbSeq = MEM_readLE16(ip); ip+=2;
-    LLtype  = *ip >> 6;
-    Offtype = (*ip >> 4) & 3;
-    MLtype  = (*ip >> 2) & 3;
-    if (*ip & 2)
-    {
-        dumpsLength  = ip[2];
-        dumpsLength += ip[1] << 8;
-        ip += 3;
-    }
-    else
-    {
-        dumpsLength  = ip[1];
-        dumpsLength += (ip[0] & 1) << 8;
-        ip += 2;
-    }
-    *dumpsPtr = ip;
-    ip += dumpsLength;
-    *dumpsLengthPtr = dumpsLength;
-
-    /* check */
-    if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */
-
-    /* sequences */
-    {
-        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL >= MaxOff */
-        size_t headerSize;
-
-        /* Build DTables */
-        switch(LLtype)
-        {
-        U32 max;
-        case bt_rle :
-            LLlog = 0;
-            FSE_buildDTable_rle(DTableLL, *ip++); break;
-        case bt_raw :
-            LLlog = LLbits;
-            FSE_buildDTable_raw(DTableLL, LLbits); break;
-        default :
-            max = MaxLL;
-            headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);
-            if (FSE_isError(headerSize)) return ERROR(GENERIC);
-            if (LLlog > LLFSELog) return ERROR(corruption_detected);
-            ip += headerSize;
-            FSE_buildDTable(DTableLL, norm, max, LLlog);
-        }
-
-        switch(Offtype)
-        {
-        U32 max;
-        case bt_rle :
-            Offlog = 0;
-            if (ip > iend-2) return ERROR(srcSize_wrong);   /* min : "raw", hence no header, but at least xxLog bits */
-            FSE_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */
-            break;
-        case bt_raw :
-            Offlog = Offbits;
-            FSE_buildDTable_raw(DTableOffb, Offbits); break;
-        default :
-            max = MaxOff;
-            headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);
-            if (FSE_isError(headerSize)) return ERROR(GENERIC);
-            if (Offlog > OffFSELog) return ERROR(corruption_detected);
-            ip += headerSize;
-            FSE_buildDTable(DTableOffb, norm, max, Offlog);
-        }
-
-        switch(MLtype)
-        {
-        U32 max;
-        case bt_rle :
-            MLlog = 0;
-            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */
-            FSE_buildDTable_rle(DTableML, *ip++); break;
-        case bt_raw :
-            MLlog = MLbits;
-            FSE_buildDTable_raw(DTableML, MLbits); break;
-        default :
-            max = MaxML;
-            headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);
-            if (FSE_isError(headerSize)) return ERROR(GENERIC);
-            if (MLlog > MLFSELog) return ERROR(corruption_detected);
-            ip += headerSize;
-            FSE_buildDTable(DTableML, norm, max, MLlog);
-        }
-    }
-
-    return ip-istart;
-}
-
-
-typedef struct {
-    size_t litLength;
-    size_t offset;
-    size_t matchLength;
-} seq_t;
-
-typedef struct {
-    BIT_DStream_t DStream;
-    FSE_DState_t stateLL;
-    FSE_DState_t stateOffb;
-    FSE_DState_t stateML;
-    size_t prevOffset;
-    const BYTE* dumps;
-    const BYTE* dumpsEnd;
-} seqState_t;
-
-
-static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState)
-{
-    size_t litLength;
-    size_t prevOffset;
-    size_t offset;
-    size_t matchLength;
-    const BYTE* dumps = seqState->dumps;
-    const BYTE* const de = seqState->dumpsEnd;
-
-    /* Literal length */
-    litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream));
-    prevOffset = litLength ? seq->offset : seqState->prevOffset;
-    if (litLength == MaxLL)
-    {
-        U32 add = *dumps++;
-        if (add < 255) litLength += add;
-        else
-        {
-            litLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */
-            dumps += 3;
-        }
-        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */
-    }
-
-    /* Offset */
-    {
-        static const U32 offsetPrefix[MaxOff+1] = {
-                1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256,
-                512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
-                524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 };
-        U32 offsetCode, nbBits;
-        offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream));   /* <= maxOff, by table construction */
-        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));
-        nbBits = offsetCode - 1;
-        if (offsetCode==0) nbBits = 0;   /* cmove */
-        offset = offsetPrefix[offsetCode] + BIT_readBits(&(seqState->DStream), nbBits);
-        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream));
-        if (offsetCode==0) offset = prevOffset;   /* cmove */
-        if (offsetCode | !litLength) seqState->prevOffset = seq->offset;   /* cmove */
-    }
-
-    /* MatchLength */
-    matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream));
-    if (matchLength == MaxML)
-    {
-        U32 add = *dumps++;
-        if (add < 255) matchLength += add;
-        else
-        {
-            matchLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */
-            dumps += 3;
-        }
-        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */
-    }
-    matchLength += MINMATCH;
-
-    /* save result */
-    seq->litLength = litLength;
-    seq->offset = offset;
-    seq->matchLength = matchLength;
-    seqState->dumps = dumps;
-}
-
-
-static size_t ZSTD_execSequence(BYTE* op,
-                                BYTE* const oend, seq_t sequence,
-                                const BYTE** litPtr, const BYTE* const litLimit_8,
-                                const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)
-{
-    static const int dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */
-    static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 };   /* substracted */
-    BYTE* const oLitEnd = op + sequence.litLength;
-    const size_t sequenceLength = sequence.litLength + sequence.matchLength;
-    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */
-    BYTE* const oend_8 = oend-8;
-    const BYTE* const litEnd = *litPtr + sequence.litLength;
-    const BYTE* match = oLitEnd - sequence.offset;
-
-    /* check */
-    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */
-    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */
-    if (litEnd > litLimit_8) return ERROR(corruption_detected);   /* risk read beyond lit buffer */
-
-    /* copy Literals */
-    ZSTD_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */
-    op = oLitEnd;
-    *litPtr = litEnd;   /* update for next sequence */
-
-    /* copy Match */
-    if (sequence.offset > (size_t)(oLitEnd - base))
-    {
-        /* offset beyond prefix */
-        if (sequence.offset > (size_t)(oLitEnd - vBase))
-            return ERROR(corruption_detected);
-        match = dictEnd - (base-match);
-        if (match + sequence.matchLength <= dictEnd)
-        {
-            memmove(oLitEnd, match, sequence.matchLength);
-            return sequenceLength;
-        }
-        /* span extDict & currentPrefixSegment */
-        {
-            size_t length1 = dictEnd - match;
-            memmove(oLitEnd, match, length1);
-            op = oLitEnd + length1;
-            sequence.matchLength -= length1;
-            match = base;
-        }
-    }
-
-    /* match within prefix */
-    if (sequence.offset < 8)
-    {
-        /* close range match, overlap */
-        const int sub2 = dec64table[sequence.offset];
-        op[0] = match[0];
-        op[1] = match[1];
-        op[2] = match[2];
-        op[3] = match[3];
-        match += dec32table[sequence.offset];
-        ZSTD_copy4(op+4, match);
-        match -= sub2;
-    }
-    else
-    {
-        ZSTD_copy8(op, match);
-    }
-    op += 8; match += 8;
-
-    if (oMatchEnd > oend-12)
-    {
-        if (op < oend_8)
-        {
-            ZSTD_wildcopy(op, match, oend_8 - op);
-            match += oend_8 - op;
-            op = oend_8;
-        }
-        while (op < oMatchEnd) *op++ = *match++;
-    }
-    else
-    {
-        ZSTD_wildcopy(op, match, sequence.matchLength-8);   /* works even if matchLength < 8 */
-    }
-    return sequenceLength;
-}
-
-
-static size_t ZSTD_decompressSequences(
-                               ZSTD_DCtx* dctx,
-                               void* dst, size_t maxDstSize,
-                         const void* seqStart, size_t seqSize)
-{
-    const BYTE* ip = (const BYTE*)seqStart;
-    const BYTE* const iend = ip + seqSize;
-    BYTE* const ostart = (BYTE* const)dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + maxDstSize;
-    size_t errorCode, dumpsLength;
-    const BYTE* litPtr = dctx->litPtr;
-    const BYTE* const litLimit_8 = litPtr + dctx->litBufSize - 8;
-    const BYTE* const litEnd = litPtr + dctx->litSize;
-    int nbSeq;
-    const BYTE* dumps;
-    U32* DTableLL = dctx->LLTable;
-    U32* DTableML = dctx->MLTable;
-    U32* DTableOffb = dctx->OffTable;
-    const BYTE* const base = (const BYTE*) (dctx->base);
-    const BYTE* const vBase = (const BYTE*) (dctx->vBase);
-    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
-
-    /* Build Decoding Tables */
-    errorCode = ZSTD_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,
-                                      DTableLL, DTableML, DTableOffb,
-                                      ip, iend-ip);
-    if (ZSTD_isError(errorCode)) return errorCode;
-    ip += errorCode;
-
-    /* Regen sequences */
-    {
-        seq_t sequence;
-        seqState_t seqState;
-
-        memset(&sequence, 0, sizeof(sequence));
-        sequence.offset = 4;
-        seqState.dumps = dumps;
-        seqState.dumpsEnd = dumps + dumpsLength;
-        seqState.prevOffset = 4;
-        errorCode = BIT_initDStream(&(seqState.DStream), ip, iend-ip);
-        if (ERR_isError(errorCode)) return ERROR(corruption_detected);
-        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
-        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
-        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
-
-        for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && nbSeq ; )
-        {
-            size_t oneSeqSize;
-            nbSeq--;
-            ZSTD_decodeSequence(&sequence, &seqState);
-            oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litLimit_8, base, vBase, dictEnd);
-            if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
-            op += oneSeqSize;
-        }
-
-        /* check if reached exact end */
-        if ( !BIT_endOfDStream(&(seqState.DStream)) ) return ERROR(corruption_detected);   /* DStream should be entirely and exactly consumed; otherwise data is corrupted */
-
-        /* last literal segment */
-        {
-            size_t lastLLSize = litEnd - litPtr;
-            if (litPtr > litEnd) return ERROR(corruption_detected);
-            if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);
-            if (op != litPtr) memcpy(op, litPtr, lastLLSize);
-            op += lastLLSize;
-        }
-    }
-
-    return op-ostart;
-}
-
-
-static void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst)
-{
-    if (dst != dctx->previousDstEnd)   /* not contiguous */
-    {
-        dctx->dictEnd = dctx->previousDstEnd;
-        dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));
-        dctx->base = dst;
-        dctx->previousDstEnd = dst;
-    }
-}
-
-
-static size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
-                            void* dst, size_t maxDstSize,
-                      const void* src, size_t srcSize)
-{
-    /* blockType == blockCompressed */
-    const BYTE* ip = (const BYTE*)src;
-
-    /* Decode literals sub-block */
-    size_t litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize);
-    if (ZSTD_isError(litCSize)) return litCSize;
-    ip += litCSize;
-    srcSize -= litCSize;
-
-    return ZSTD_decompressSequences(dctx, dst, maxDstSize, ip, srcSize);
-}
-
-
-static size_t ZSTD_decompress_usingDict(ZSTD_DCtx* ctx,
-                                 void* dst, size_t maxDstSize,
-                                 const void* src, size_t srcSize,
-                                 const void* dict, size_t dictSize)
-{
-    const BYTE* ip = (const BYTE*)src;
-    const BYTE* iend = ip + srcSize;
-    BYTE* const ostart = (BYTE* const)dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + maxDstSize;
-    size_t remainingSize = srcSize;
-    blockProperties_t blockProperties;
-
-    /* init */
-    ZSTD_resetDCtx(ctx);
-    if (dict)
-    {
-        ZSTD_decompress_insertDictionary(ctx, dict, dictSize);
-        ctx->dictEnd = ctx->previousDstEnd;
-        ctx->vBase = (const char*)dst - ((const char*)(ctx->previousDstEnd) - (const char*)(ctx->base));
-        ctx->base = dst;
-    }
-    else
-    {
-        ctx->vBase = ctx->base = ctx->dictEnd = dst;
-    }
-
-    /* Frame Header */
-    {
-        size_t frameHeaderSize;
-        if (srcSize < ZSTD_frameHeaderSize_min+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
-        frameHeaderSize = ZSTD_decodeFrameHeader_Part1(ctx, src, ZSTD_frameHeaderSize_min);
-        if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;
-        if (srcSize < frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
-        ip += frameHeaderSize; remainingSize -= frameHeaderSize;
-        frameHeaderSize = ZSTD_decodeFrameHeader_Part2(ctx, src, frameHeaderSize);
-        if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;
-    }
-
-    /* Loop on each block */
-    while (1)
-    {
-        size_t decodedSize=0;
-        size_t cBlockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties);
-        if (ZSTD_isError(cBlockSize)) return cBlockSize;
-
-        ip += ZSTD_blockHeaderSize;
-        remainingSize -= ZSTD_blockHeaderSize;
-        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);
-
-        switch(blockProperties.blockType)
-        {
-        case bt_compressed:
-            decodedSize = ZSTD_decompressBlock_internal(ctx, op, oend-op, ip, cBlockSize);
-            break;
-        case bt_raw :
-            decodedSize = ZSTD_copyRawBlock(op, oend-op, ip, cBlockSize);
-            break;
-        case bt_rle :
-            return ERROR(GENERIC);   /* not yet supported */
-            break;
-        case bt_end :
-            /* end of frame */
-            if (remainingSize) return ERROR(srcSize_wrong);
-            break;
-        default:
-            return ERROR(GENERIC);   /* impossible */
-        }
-        if (cBlockSize == 0) break;   /* bt_end */
-
-        if (ZSTD_isError(decodedSize)) return decodedSize;
-        op += decodedSize;
-        ip += cBlockSize;
-        remainingSize -= cBlockSize;
-    }
-
-    return op-ostart;
-}
-
-
-/* ******************************
-*  Streaming Decompression API
-********************************/
-static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx)
-{
-    return dctx->expected;
-}
-
-static size_t ZSTD_decompressContinue(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    /* Sanity check */
-    if (srcSize != ctx->expected) return ERROR(srcSize_wrong);
-    ZSTD_checkContinuity(ctx, dst);
-
-    /* Decompress : frame header; part 1 */
-    switch (ctx->stage)
-    {
-    case ZSTDds_getFrameHeaderSize :
+    /* estimate decompression time */ 
+    U32 Q; 
+    const U32 D256 = (U32)(dstSize >> 8); 
+    U32 Dtime[3]; 
+    U32 algoNb = 0; 
+    int n; 
+ 
+    /* validation checks */ 
+    if (dstSize == 0) return ERROR(dstSize_tooSmall); 
+    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */ 
+    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */ 
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */ 
+ 
+    /* decoder timing evaluation */ 
+    Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */ 
+    for (n=0; n<3; n++) 
+        Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256); 
+ 
+    Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */ 
+ 
+    if (Dtime[1] < Dtime[0]) algoNb = 1; 
+ 
+    return decompress[algoNb](dst, dstSize, cSrc, cSrcSize); 
+ 
+    //return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize);   /* multi-streams single-symbol decoding */ 
+    //return HUF_decompress4X4(dst, dstSize, cSrc, cSrcSize);   /* multi-streams double-symbols decoding */ 
+    //return HUF_decompress4X6(dst, dstSize, cSrc, cSrcSize);   /* multi-streams quad-symbols decoding */ 
+} 
+ 
+ 
+ 
+#endif   /* ZSTD_CCOMMON_H_MODULE */ 
+ 
+ 
+/* 
+    zstd - decompression module fo v0.4 legacy format 
+    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 source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+ 
+/* *************************************************************** 
+*  Tuning parameters 
+*****************************************************************/ 
+/*! 
+ * HEAPMODE : 
+ * Select how default decompression function ZSTD_decompress() will allocate memory, 
+ * in memory stack (0), or in memory heap (1, requires malloc()) 
+ */ 
+#ifndef ZSTD_HEAPMODE 
+#  define ZSTD_HEAPMODE 1 
+#endif 
+ 
+ 
+/* ******************************************************* 
+*  Includes 
+*********************************************************/ 
+#include <stdlib.h>      /* calloc */ 
+#include <string.h>      /* memcpy, memmove */ 
+#include <stdio.h>       /* debug : printf */ 
+ 
+ 
+/* ******************************************************* 
+*  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 : 4324)        /* disable: C4324: padded structure */ 
+#else 
+#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) 
+#  ifdef __GNUC__ 
+#    define FORCE_INLINE static inline __attribute__((always_inline)) 
+#  else 
+#    define FORCE_INLINE static inline 
+#  endif 
+#endif 
+ 
+ 
+/* ************************************* 
+*  Local types 
+***************************************/ 
+typedef struct 
+{ 
+    blockType_t blockType; 
+    U32 origSize; 
+} blockProperties_t; 
+ 
+ 
+/* ******************************************************* 
+*  Memory operations 
+**********************************************************/ 
+static void ZSTD_copy4(void* dst, const void* src) { memcpy(dst, src, 4); } 
+ 
+ 
+/* ************************************* 
+*  Error Management 
+***************************************/ 
+ 
+/*! ZSTD_isError 
+*   tells if a return value is an error code */ 
+static unsigned ZSTD_isError(size_t code) { return ERR_isError(code); } 
+ 
+ 
+/* ************************************************************* 
+*   Context management 
+***************************************************************/ 
+typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader, 
+               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock } ZSTD_dStage; 
+ 
+struct ZSTDv04_Dctx_s 
+{ 
+    U32 LLTable[FSE_DTABLE_SIZE_U32(LLFSELog)]; 
+    U32 OffTable[FSE_DTABLE_SIZE_U32(OffFSELog)]; 
+    U32 MLTable[FSE_DTABLE_SIZE_U32(MLFSELog)]; 
+    const void* previousDstEnd; 
+    const void* base; 
+    const void* vBase; 
+    const void* dictEnd; 
+    size_t expected; 
+    size_t headerSize; 
+    ZSTD_parameters params; 
+    blockType_t bType; 
+    ZSTD_dStage stage; 
+    const BYTE* litPtr; 
+    size_t litBufSize; 
+    size_t litSize; 
+    BYTE litBuffer[BLOCKSIZE + 8 /* margin for wildcopy */]; 
+    BYTE headerBuffer[ZSTD_frameHeaderSize_max]; 
+};  /* typedef'd to ZSTD_DCtx within "zstd_static.h" */ 
+ 
+static size_t ZSTD_resetDCtx(ZSTD_DCtx* dctx) 
+{ 
+    dctx->expected = ZSTD_frameHeaderSize_min; 
+    dctx->stage = ZSTDds_getFrameHeaderSize; 
+    dctx->previousDstEnd = NULL; 
+    dctx->base = NULL; 
+    dctx->vBase = NULL; 
+    dctx->dictEnd = NULL; 
+    return 0; 
+} 
+ 
+static ZSTD_DCtx* ZSTD_createDCtx(void) 
+{ 
+    ZSTD_DCtx* dctx = (ZSTD_DCtx*)malloc(sizeof(ZSTD_DCtx)); 
+    if (dctx==NULL) return NULL; 
+    ZSTD_resetDCtx(dctx); 
+    return dctx; 
+} 
+ 
+static size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx) 
+{ 
+    free(dctx); 
+    return 0; 
+} 
+ 
+ 
+/* ************************************************************* 
+*   Decompression section 
+***************************************************************/ 
+/** ZSTD_decodeFrameHeader_Part1 
+*   decode the 1st part of the Frame Header, which tells Frame Header size. 
+*   srcSize must be == ZSTD_frameHeaderSize_min 
+*   @return : the full size of the Frame Header */ 
+static size_t ZSTD_decodeFrameHeader_Part1(ZSTD_DCtx* zc, const void* src, size_t srcSize) 
+{ 
+    U32 magicNumber; 
+    if (srcSize != ZSTD_frameHeaderSize_min) return ERROR(srcSize_wrong); 
+    magicNumber = MEM_readLE32(src); 
+    if (magicNumber != ZSTD_MAGICNUMBER) return ERROR(prefix_unknown); 
+    zc->headerSize = ZSTD_frameHeaderSize_min; 
+    return zc->headerSize; 
+} 
+ 
+ 
+static size_t ZSTD_getFrameParams(ZSTD_parameters* params, const void* src, size_t srcSize) 
+{ 
+    U32 magicNumber; 
+    if (srcSize < ZSTD_frameHeaderSize_min) return ZSTD_frameHeaderSize_max; 
+    magicNumber = MEM_readLE32(src); 
+    if (magicNumber != ZSTD_MAGICNUMBER) return ERROR(prefix_unknown); 
+    memset(params, 0, sizeof(*params)); 
+    params->windowLog = (((const BYTE*)src)[4] & 15) + ZSTD_WINDOWLOG_ABSOLUTEMIN; 
+    if ((((const BYTE*)src)[4] >> 4) != 0) return ERROR(frameParameter_unsupported);   /* reserved bits */ 
+    return 0; 
+} 
+ 
+/** ZSTD_decodeFrameHeader_Part2 
+*   decode the full Frame Header 
+*   srcSize must be the size provided by ZSTD_decodeFrameHeader_Part1 
+*   @return : 0, or an error code, which can be tested using ZSTD_isError() */ 
+static size_t ZSTD_decodeFrameHeader_Part2(ZSTD_DCtx* zc, const void* src, size_t srcSize) 
+{ 
+    size_t result; 
+    if (srcSize != zc->headerSize) return ERROR(srcSize_wrong); 
+    result = ZSTD_getFrameParams(&(zc->params), src, srcSize); 
+    if ((MEM_32bits()) && (zc->params.windowLog > 25)) return ERROR(frameParameter_unsupportedBy32bitsImplementation); 
+    return result; 
+} 
+ 
+ 
+static size_t ZSTD_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr) 
+{ 
+    const BYTE* const in = (const BYTE* const)src; 
+    BYTE headerFlags; 
+    U32 cSize; 
+ 
+    if (srcSize < 3) return ERROR(srcSize_wrong); 
+ 
+    headerFlags = *in; 
+    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16); 
+ 
+    bpPtr->blockType = (blockType_t)(headerFlags >> 6); 
+    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0; 
+ 
+    if (bpPtr->blockType == bt_end) return 0; 
+    if (bpPtr->blockType == bt_rle) return 1; 
+    return cSize; 
+} 
+ 
+static size_t ZSTD_copyRawBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall); 
+    memcpy(dst, src, srcSize); 
+    return srcSize; 
+} 
+ 
+ 
+/** ZSTD_decompressLiterals 
+    @return : nb of bytes read from src, or an error code*/ 
+static size_t ZSTD_decompressLiterals(void* dst, size_t* maxDstSizePtr, 
+                                const void* src, size_t srcSize) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+ 
+    const size_t litSize = (MEM_readLE32(src) & 0x1FFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */ 
+    const size_t litCSize = (MEM_readLE32(ip+2) & 0xFFFFFF) >> 5;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */ 
+ 
+    if (litSize > *maxDstSizePtr) return ERROR(corruption_detected); 
+    if (litCSize + 5 > srcSize) return ERROR(corruption_detected); 
+ 
+    if (HUF_isError(HUF_decompress(dst, litSize, ip+5, litCSize))) return ERROR(corruption_detected); 
+ 
+    *maxDstSizePtr = litSize; 
+    return litCSize + 5; 
+} 
+ 
+ 
+/** ZSTD_decodeLiteralsBlock 
+    @return : nb of bytes read from src (< srcSize ) */ 
+static size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx, 
+                          const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */ 
+{ 
+    const BYTE* const istart = (const BYTE*) src; 
+ 
+    /* any compressed block with literals segment must be at least this size */ 
+    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected); 
+ 
+    switch(*istart & 3) 
+    { 
+    /* compressed */ 
+    case 0: 
+        { 
+            size_t litSize = BLOCKSIZE; 
+            const size_t readSize = ZSTD_decompressLiterals(dctx->litBuffer, &litSize, src, srcSize); 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litBufSize = BLOCKSIZE+8; 
+            dctx->litSize = litSize; 
+            return readSize;   /* works if it's an error too */ 
+        } 
+    case IS_RAW: 
+        { 
+            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */ 
+            if (litSize > srcSize-11)   /* risk of reading too far with wildcopy */ 
+            { 
+                if (litSize > srcSize-3) return ERROR(corruption_detected); 
+                memcpy(dctx->litBuffer, istart, litSize); 
+                dctx->litPtr = dctx->litBuffer; 
+                dctx->litBufSize = BLOCKSIZE+8; 
+                dctx->litSize = litSize; 
+                return litSize+3; 
+            } 
+            /* direct reference into compressed stream */ 
+            dctx->litPtr = istart+3; 
+            dctx->litBufSize = srcSize-3; 
+            dctx->litSize = litSize; 
+            return litSize+3;        } 
+    case IS_RLE: 
+        { 
+            const size_t litSize = (MEM_readLE32(istart) & 0xFFFFFF) >> 2;   /* no buffer issue : srcSize >= MIN_CBLOCK_SIZE */ 
+            if (litSize > BLOCKSIZE) return ERROR(corruption_detected); 
+            memset(dctx->litBuffer, istart[3], litSize); 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litBufSize = BLOCKSIZE+8; 
+            dctx->litSize = litSize; 
+            return 4; 
+        } 
+    default: 
+        return ERROR(corruption_detected);   /* forbidden nominal case */ 
+    } 
+} 
+ 
+ 
+static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr, 
+                         FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb, 
+                         const void* src, size_t srcSize) 
+{ 
+    const BYTE* const istart = (const BYTE* const)src; 
+    const BYTE* ip = istart; 
+    const BYTE* const iend = istart + srcSize; 
+    U32 LLtype, Offtype, MLtype; 
+    U32 LLlog, Offlog, MLlog; 
+    size_t dumpsLength; 
+ 
+    /* check */ 
+    if (srcSize < 5) return ERROR(srcSize_wrong); 
+ 
+    /* SeqHead */ 
+    *nbSeq = MEM_readLE16(ip); ip+=2; 
+    LLtype  = *ip >> 6; 
+    Offtype = (*ip >> 4) & 3; 
+    MLtype  = (*ip >> 2) & 3; 
+    if (*ip & 2) 
+    { 
+        dumpsLength  = ip[2]; 
+        dumpsLength += ip[1] << 8; 
+        ip += 3; 
+    } 
+    else 
+    { 
+        dumpsLength  = ip[1]; 
+        dumpsLength += (ip[0] & 1) << 8; 
+        ip += 2; 
+    } 
+    *dumpsPtr = ip; 
+    ip += dumpsLength; 
+    *dumpsLengthPtr = dumpsLength; 
+ 
+    /* check */ 
+    if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */ 
+ 
+    /* sequences */ 
+    { 
+        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL >= MaxOff */ 
+        size_t headerSize; 
+ 
+        /* Build DTables */ 
+        switch(LLtype) 
+        { 
+        U32 max; 
+        case bt_rle : 
+            LLlog = 0; 
+            FSE_buildDTable_rle(DTableLL, *ip++); break; 
+        case bt_raw : 
+            LLlog = LLbits; 
+            FSE_buildDTable_raw(DTableLL, LLbits); break; 
+        default : 
+            max = MaxLL; 
+            headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip); 
+            if (FSE_isError(headerSize)) return ERROR(GENERIC); 
+            if (LLlog > LLFSELog) return ERROR(corruption_detected); 
+            ip += headerSize; 
+            FSE_buildDTable(DTableLL, norm, max, LLlog); 
+        } 
+ 
+        switch(Offtype) 
+        { 
+        U32 max; 
+        case bt_rle : 
+            Offlog = 0; 
+            if (ip > iend-2) return ERROR(srcSize_wrong);   /* min : "raw", hence no header, but at least xxLog bits */ 
+            FSE_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */ 
+            break; 
+        case bt_raw : 
+            Offlog = Offbits; 
+            FSE_buildDTable_raw(DTableOffb, Offbits); break; 
+        default : 
+            max = MaxOff; 
+            headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip); 
+            if (FSE_isError(headerSize)) return ERROR(GENERIC); 
+            if (Offlog > OffFSELog) return ERROR(corruption_detected); 
+            ip += headerSize; 
+            FSE_buildDTable(DTableOffb, norm, max, Offlog); 
+        } 
+ 
+        switch(MLtype) 
+        { 
+        U32 max; 
+        case bt_rle : 
+            MLlog = 0; 
+            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */ 
+            FSE_buildDTable_rle(DTableML, *ip++); break; 
+        case bt_raw : 
+            MLlog = MLbits; 
+            FSE_buildDTable_raw(DTableML, MLbits); break; 
+        default : 
+            max = MaxML; 
+            headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip); 
+            if (FSE_isError(headerSize)) return ERROR(GENERIC); 
+            if (MLlog > MLFSELog) return ERROR(corruption_detected); 
+            ip += headerSize; 
+            FSE_buildDTable(DTableML, norm, max, MLlog); 
+        } 
+    } 
+ 
+    return ip-istart; 
+} 
+ 
+ 
+typedef struct { 
+    size_t litLength; 
+    size_t offset; 
+    size_t matchLength; 
+} seq_t; 
+ 
+typedef struct { 
+    BIT_DStream_t DStream; 
+    FSE_DState_t stateLL; 
+    FSE_DState_t stateOffb; 
+    FSE_DState_t stateML; 
+    size_t prevOffset; 
+    const BYTE* dumps; 
+    const BYTE* dumpsEnd; 
+} seqState_t; 
+ 
+ 
+static void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState) 
+{ 
+    size_t litLength; 
+    size_t prevOffset; 
+    size_t offset; 
+    size_t matchLength; 
+    const BYTE* dumps = seqState->dumps; 
+    const BYTE* const de = seqState->dumpsEnd; 
+ 
+    /* Literal length */ 
+    litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream)); 
+    prevOffset = litLength ? seq->offset : seqState->prevOffset; 
+    if (litLength == MaxLL) 
+    { 
+        U32 add = *dumps++; 
+        if (add < 255) litLength += add; 
+        else 
+        { 
+            litLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */ 
+            dumps += 3; 
+        } 
+        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */ 
+    } 
+ 
+    /* Offset */ 
+    { 
+        static const U32 offsetPrefix[MaxOff+1] = { 
+                1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256, 
+                512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 
+                524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 }; 
+        U32 offsetCode, nbBits; 
+        offsetCode = FSE_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream));   /* <= maxOff, by table construction */ 
+        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream)); 
+        nbBits = offsetCode - 1; 
+        if (offsetCode==0) nbBits = 0;   /* cmove */ 
+        offset = offsetPrefix[offsetCode] + BIT_readBits(&(seqState->DStream), nbBits); 
+        if (MEM_32bits()) BIT_reloadDStream(&(seqState->DStream)); 
+        if (offsetCode==0) offset = prevOffset;   /* cmove */ 
+        if (offsetCode | !litLength) seqState->prevOffset = seq->offset;   /* cmove */ 
+    } 
+ 
+    /* MatchLength */ 
+    matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream)); 
+    if (matchLength == MaxML) 
+    { 
+        U32 add = *dumps++; 
+        if (add < 255) matchLength += add; 
+        else 
+        { 
+            matchLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */ 
+            dumps += 3; 
+        } 
+        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */ 
+    } 
+    matchLength += MINMATCH; 
+ 
+    /* save result */ 
+    seq->litLength = litLength; 
+    seq->offset = offset; 
+    seq->matchLength = matchLength; 
+    seqState->dumps = dumps; 
+} 
+ 
+ 
+static size_t ZSTD_execSequence(BYTE* op, 
+                                BYTE* const oend, seq_t sequence, 
+                                const BYTE** litPtr, const BYTE* const litLimit_8, 
+                                const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd) 
+{ 
+    static const int dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */ 
+    static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 };   /* substracted */ 
+    BYTE* const oLitEnd = op + sequence.litLength; 
+    const size_t sequenceLength = sequence.litLength + sequence.matchLength; 
+    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */ 
+    BYTE* const oend_8 = oend-8; 
+    const BYTE* const litEnd = *litPtr + sequence.litLength; 
+    const BYTE* match = oLitEnd - sequence.offset; 
+ 
+    /* check */ 
+    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */ 
+    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */ 
+    if (litEnd > litLimit_8) return ERROR(corruption_detected);   /* risk read beyond lit buffer */ 
+ 
+    /* copy Literals */ 
+    ZSTD_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */ 
+    op = oLitEnd; 
+    *litPtr = litEnd;   /* update for next sequence */ 
+ 
+    /* copy Match */ 
+    if (sequence.offset > (size_t)(oLitEnd - base)) 
+    { 
+        /* offset beyond prefix */ 
+        if (sequence.offset > (size_t)(oLitEnd - vBase)) 
+            return ERROR(corruption_detected); 
+        match = dictEnd - (base-match); 
+        if (match + sequence.matchLength <= dictEnd) 
+        { 
+            memmove(oLitEnd, match, sequence.matchLength); 
+            return sequenceLength; 
+        } 
+        /* span extDict & currentPrefixSegment */ 
+        { 
+            size_t length1 = dictEnd - match; 
+            memmove(oLitEnd, match, length1); 
+            op = oLitEnd + length1; 
+            sequence.matchLength -= length1; 
+            match = base; 
+        } 
+    } 
+ 
+    /* match within prefix */ 
+    if (sequence.offset < 8) 
+    { 
+        /* close range match, overlap */ 
+        const int sub2 = dec64table[sequence.offset]; 
+        op[0] = match[0]; 
+        op[1] = match[1]; 
+        op[2] = match[2]; 
+        op[3] = match[3]; 
+        match += dec32table[sequence.offset]; 
+        ZSTD_copy4(op+4, match); 
+        match -= sub2; 
+    } 
+    else 
+    { 
+        ZSTD_copy8(op, match); 
+    } 
+    op += 8; match += 8; 
+ 
+    if (oMatchEnd > oend-12) 
+    { 
+        if (op < oend_8) 
+        { 
+            ZSTD_wildcopy(op, match, oend_8 - op); 
+            match += oend_8 - op; 
+            op = oend_8; 
+        } 
+        while (op < oMatchEnd) *op++ = *match++; 
+    } 
+    else 
+    { 
+        ZSTD_wildcopy(op, match, sequence.matchLength-8);   /* works even if matchLength < 8 */ 
+    } 
+    return sequenceLength; 
+} 
+ 
+ 
+static size_t ZSTD_decompressSequences( 
+                               ZSTD_DCtx* dctx, 
+                               void* dst, size_t maxDstSize, 
+                         const void* seqStart, size_t seqSize) 
+{ 
+    const BYTE* ip = (const BYTE*)seqStart; 
+    const BYTE* const iend = ip + seqSize; 
+    BYTE* const ostart = (BYTE* const)dst; 
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + maxDstSize; 
+    size_t errorCode, dumpsLength; 
+    const BYTE* litPtr = dctx->litPtr; 
+    const BYTE* const litLimit_8 = litPtr + dctx->litBufSize - 8; 
+    const BYTE* const litEnd = litPtr + dctx->litSize; 
+    int nbSeq; 
+    const BYTE* dumps; 
+    U32* DTableLL = dctx->LLTable; 
+    U32* DTableML = dctx->MLTable; 
+    U32* DTableOffb = dctx->OffTable; 
+    const BYTE* const base = (const BYTE*) (dctx->base); 
+    const BYTE* const vBase = (const BYTE*) (dctx->vBase); 
+    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd); 
+ 
+    /* Build Decoding Tables */ 
+    errorCode = ZSTD_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength, 
+                                      DTableLL, DTableML, DTableOffb, 
+                                      ip, iend-ip); 
+    if (ZSTD_isError(errorCode)) return errorCode; 
+    ip += errorCode; 
+ 
+    /* Regen sequences */ 
+    { 
+        seq_t sequence; 
+        seqState_t seqState; 
+ 
+        memset(&sequence, 0, sizeof(sequence)); 
+        sequence.offset = 4; 
+        seqState.dumps = dumps; 
+        seqState.dumpsEnd = dumps + dumpsLength; 
+        seqState.prevOffset = 4; 
+        errorCode = BIT_initDStream(&(seqState.DStream), ip, iend-ip); 
+        if (ERR_isError(errorCode)) return ERROR(corruption_detected); 
+        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL); 
+        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb); 
+        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML); 
+ 
+        for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && nbSeq ; ) 
+        { 
+            size_t oneSeqSize; 
+            nbSeq--; 
+            ZSTD_decodeSequence(&sequence, &seqState); 
+            oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litLimit_8, base, vBase, dictEnd); 
+            if (ZSTD_isError(oneSeqSize)) return oneSeqSize; 
+            op += oneSeqSize; 
+        } 
+ 
+        /* check if reached exact end */ 
+        if ( !BIT_endOfDStream(&(seqState.DStream)) ) return ERROR(corruption_detected);   /* DStream should be entirely and exactly consumed; otherwise data is corrupted */ 
+ 
+        /* last literal segment */ 
+        { 
+            size_t lastLLSize = litEnd - litPtr; 
+            if (litPtr > litEnd) return ERROR(corruption_detected); 
+            if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall); 
+            if (op != litPtr) memcpy(op, litPtr, lastLLSize); 
+            op += lastLLSize; 
+        } 
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+static void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst) 
+{ 
+    if (dst != dctx->previousDstEnd)   /* not contiguous */ 
+    { 
+        dctx->dictEnd = dctx->previousDstEnd; 
+        dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base)); 
+        dctx->base = dst; 
+        dctx->previousDstEnd = dst; 
+    } 
+} 
+ 
+ 
+static size_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx, 
+                            void* dst, size_t maxDstSize, 
+                      const void* src, size_t srcSize) 
+{ 
+    /* blockType == blockCompressed */ 
+    const BYTE* ip = (const BYTE*)src; 
+ 
+    /* Decode literals sub-block */ 
+    size_t litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize); 
+    if (ZSTD_isError(litCSize)) return litCSize; 
+    ip += litCSize; 
+    srcSize -= litCSize; 
+ 
+    return ZSTD_decompressSequences(dctx, dst, maxDstSize, ip, srcSize); 
+} 
+ 
+ 
+static size_t ZSTD_decompress_usingDict(ZSTD_DCtx* ctx, 
+                                 void* dst, size_t maxDstSize, 
+                                 const void* src, size_t srcSize, 
+                                 const void* dict, size_t dictSize) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    const BYTE* iend = ip + srcSize; 
+    BYTE* const ostart = (BYTE* const)dst; 
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + maxDstSize; 
+    size_t remainingSize = srcSize; 
+    blockProperties_t blockProperties; 
+ 
+    /* init */ 
+    ZSTD_resetDCtx(ctx); 
+    if (dict) 
+    { 
+        ZSTD_decompress_insertDictionary(ctx, dict, dictSize); 
+        ctx->dictEnd = ctx->previousDstEnd; 
+        ctx->vBase = (const char*)dst - ((const char*)(ctx->previousDstEnd) - (const char*)(ctx->base)); 
+        ctx->base = dst; 
+    } 
+    else 
+    { 
+        ctx->vBase = ctx->base = ctx->dictEnd = dst; 
+    } 
+ 
+    /* Frame Header */ 
+    { 
+        size_t frameHeaderSize; 
+        if (srcSize < ZSTD_frameHeaderSize_min+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong); 
+        frameHeaderSize = ZSTD_decodeFrameHeader_Part1(ctx, src, ZSTD_frameHeaderSize_min); 
+        if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize; 
+        if (srcSize < frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong); 
+        ip += frameHeaderSize; remainingSize -= frameHeaderSize; 
+        frameHeaderSize = ZSTD_decodeFrameHeader_Part2(ctx, src, frameHeaderSize); 
+        if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize; 
+    } 
+ 
+    /* Loop on each block */ 
+    while (1) 
+    { 
+        size_t decodedSize=0; 
+        size_t cBlockSize = ZSTD_getcBlockSize(ip, iend-ip, &blockProperties); 
+        if (ZSTD_isError(cBlockSize)) return cBlockSize; 
+ 
+        ip += ZSTD_blockHeaderSize; 
+        remainingSize -= ZSTD_blockHeaderSize; 
+        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong); 
+ 
+        switch(blockProperties.blockType) 
+        { 
+        case bt_compressed: 
+            decodedSize = ZSTD_decompressBlock_internal(ctx, op, oend-op, ip, cBlockSize); 
+            break; 
+        case bt_raw : 
+            decodedSize = ZSTD_copyRawBlock(op, oend-op, ip, cBlockSize); 
+            break; 
+        case bt_rle : 
+            return ERROR(GENERIC);   /* not yet supported */ 
+            break; 
+        case bt_end : 
+            /* end of frame */ 
+            if (remainingSize) return ERROR(srcSize_wrong); 
+            break; 
+        default: 
+            return ERROR(GENERIC);   /* impossible */ 
+        } 
+        if (cBlockSize == 0) break;   /* bt_end */ 
+ 
+        if (ZSTD_isError(decodedSize)) return decodedSize; 
+        op += decodedSize; 
+        ip += cBlockSize; 
+        remainingSize -= cBlockSize; 
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+/* ****************************** 
+*  Streaming Decompression API 
+********************************/ 
+static size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) 
+{ 
+    return dctx->expected; 
+} 
+ 
+static size_t ZSTD_decompressContinue(ZSTD_DCtx* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    /* Sanity check */ 
+    if (srcSize != ctx->expected) return ERROR(srcSize_wrong); 
+    ZSTD_checkContinuity(ctx, dst); 
+ 
+    /* Decompress : frame header; part 1 */ 
+    switch (ctx->stage) 
+    { 
+    case ZSTDds_getFrameHeaderSize : 
         /* get frame header size */
         if (srcSize != ZSTD_frameHeaderSize_min) return ERROR(srcSize_wrong);   /* impossible */
         ctx->headerSize = ZSTD_decodeFrameHeader_Part1(ctx, src, ZSTD_frameHeaderSize_min);
@@ -3628,432 +3628,432 @@ static size_t ZSTD_decompressContinue(ZSTD_DCtx* ctx, void* dst, size_t maxDstSi
         if (ctx->headerSize > ZSTD_frameHeaderSize_min) return ERROR(GENERIC);   /* impossible */
         ctx->expected = 0;   /* not necessary to copy more */
         /* fallthrough */
-    case ZSTDds_decodeFrameHeader:
+    case ZSTDds_decodeFrameHeader: 
         /* get frame header */
         {   size_t const result = ZSTD_decodeFrameHeader_Part2(ctx, ctx->headerBuffer, ctx->headerSize);
-            if (ZSTD_isError(result)) return result;
-            ctx->expected = ZSTD_blockHeaderSize;
-            ctx->stage = ZSTDds_decodeBlockHeader;
-            return 0;
-        }
-    case ZSTDds_decodeBlockHeader:
+            if (ZSTD_isError(result)) return result; 
+            ctx->expected = ZSTD_blockHeaderSize; 
+            ctx->stage = ZSTDds_decodeBlockHeader; 
+            return 0; 
+        } 
+    case ZSTDds_decodeBlockHeader: 
         /* Decode block header */
         {   blockProperties_t bp;
             size_t const blockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
-            if (ZSTD_isError(blockSize)) return blockSize;
-            if (bp.blockType == bt_end)
-            {
-                ctx->expected = 0;
-                ctx->stage = ZSTDds_getFrameHeaderSize;
-            }
-            else
-            {
-                ctx->expected = blockSize;
-                ctx->bType = bp.blockType;
-                ctx->stage = ZSTDds_decompressBlock;
-            }
-            return 0;
-        }
-    case ZSTDds_decompressBlock:
-        {
-            /* Decompress : block content */
-            size_t rSize;
-            switch(ctx->bType)
-            {
-            case bt_compressed:
-                rSize = ZSTD_decompressBlock_internal(ctx, dst, maxDstSize, src, srcSize);
-                break;
-            case bt_raw :
-                rSize = ZSTD_copyRawBlock(dst, maxDstSize, src, srcSize);
-                break;
-            case bt_rle :
-                return ERROR(GENERIC);   /* not yet handled */
-                break;
-            case bt_end :   /* should never happen (filtered at phase 1) */
-                rSize = 0;
-                break;
-            default:
-                return ERROR(GENERIC);
-            }
-            ctx->stage = ZSTDds_decodeBlockHeader;
-            ctx->expected = ZSTD_blockHeaderSize;
-            ctx->previousDstEnd = (char*)dst + rSize;
-            return rSize;
-        }
-    default:
-        return ERROR(GENERIC);   /* impossible */
-    }
-}
-
-
-static void ZSTD_decompress_insertDictionary(ZSTD_DCtx* ctx, const void* dict, size_t dictSize)
-{
-    ctx->dictEnd = ctx->previousDstEnd;
-    ctx->vBase = (const char*)dict - ((const char*)(ctx->previousDstEnd) - (const char*)(ctx->base));
-    ctx->base = dict;
-    ctx->previousDstEnd = (const char*)dict + dictSize;
-}
-
-
-
-/*
-    Buffered version of Zstd compression library
-    Copyright (C) 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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-
-/* The objects defined into this file should be considered experimental.
- * They are not labelled stable, as their prototype may change in the future.
- * You can use them for tests, provide feedback, or if you can endure risk of future changes.
- */
-
-/* *************************************
-*  Includes
-***************************************/
-#include <stdlib.h>
-
-
-/** ************************************************
-*  Streaming decompression
-*
-*  A ZBUFF_DCtx object is required to track streaming operation.
-*  Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources.
-*  Use ZBUFF_decompressInit() to start a new decompression operation.
-*  ZBUFF_DCtx objects can be reused multiple times.
-*
-*  Use ZBUFF_decompressContinue() repetitively to consume your input.
-*  *srcSizePtr and *maxDstSizePtr can be any size.
-*  The function will report how many bytes were read or written by modifying *srcSizePtr and *maxDstSizePtr.
-*  Note that it may not consume the entire input, in which case it's up to the caller to call again the function with remaining input.
-*  The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst .
-*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency)
-*            or 0 when a frame is completely decoded
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  Hint : recommended buffer sizes (not compulsory)
-*  output : 128 KB block size is the internal unit, it ensures it's always possible to write a full block when it's decoded.
-*  input : just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
-* **************************************************/
-
-typedef enum { ZBUFFds_init, ZBUFFds_readHeader, ZBUFFds_loadHeader, ZBUFFds_decodeHeader,
-               ZBUFFds_read, ZBUFFds_load, ZBUFFds_flush } ZBUFF_dStage;
-
-/* *** Resource management *** */
-
-#define ZSTD_frameHeaderSize_max 5   /* too magical, should come from reference */
-struct ZBUFFv04_DCtx_s {
-    ZSTD_DCtx* zc;
-    ZSTD_parameters params;
-    char* inBuff;
-    size_t inBuffSize;
-    size_t inPos;
-    char* outBuff;
-    size_t outBuffSize;
-    size_t outStart;
-    size_t outEnd;
-    size_t hPos;
-    const char* dict;
-    size_t dictSize;
-    ZBUFF_dStage stage;
-    unsigned char headerBuffer[ZSTD_frameHeaderSize_max];
-};   /* typedef'd to ZBUFF_DCtx within "zstd_buffered.h" */
-
-typedef ZBUFFv04_DCtx ZBUFF_DCtx;
-
-
-static ZBUFF_DCtx* ZBUFF_createDCtx(void)
-{
-    ZBUFF_DCtx* zbc = (ZBUFF_DCtx*)malloc(sizeof(ZBUFF_DCtx));
-    if (zbc==NULL) return NULL;
-    memset(zbc, 0, sizeof(*zbc));
-    zbc->zc = ZSTD_createDCtx();
-    zbc->stage = ZBUFFds_init;
-    return zbc;
-}
-
-static size_t ZBUFF_freeDCtx(ZBUFF_DCtx* zbc)
-{
-    if (zbc==NULL) return 0;   /* support free on null */
-    ZSTD_freeDCtx(zbc->zc);
-    free(zbc->inBuff);
-    free(zbc->outBuff);
-    free(zbc);
-    return 0;
-}
-
-
-/* *** Initialization *** */
-
-static size_t ZBUFF_decompressInit(ZBUFF_DCtx* zbc)
-{
-    zbc->stage = ZBUFFds_readHeader;
-    zbc->hPos = zbc->inPos = zbc->outStart = zbc->outEnd = zbc->dictSize = 0;
-    return ZSTD_resetDCtx(zbc->zc);
-}
-
-
-static size_t ZBUFF_decompressWithDictionary(ZBUFF_DCtx* zbc, const void* src, size_t srcSize)
-{
-    zbc->dict = (const char*)src;
-    zbc->dictSize = srcSize;
-    return 0;
-}
-
-static size_t ZBUFF_limitCopy(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    size_t length = MIN(maxDstSize, srcSize);
-    memcpy(dst, src, length);
-    return length;
-}
-
-/* *** Decompression *** */
-
-static size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbc, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr)
-{
-    const char* const istart = (const char*)src;
-    const char* ip = istart;
-    const char* const iend = istart + *srcSizePtr;
-    char* const ostart = (char*)dst;
-    char* op = ostart;
-    char* const oend = ostart + *maxDstSizePtr;
-    U32 notDone = 1;
-
-    while (notDone)
-    {
-        switch(zbc->stage)
-        {
-
-        case ZBUFFds_init :
-            return ERROR(init_missing);
-
-        case ZBUFFds_readHeader :
-            /* read header from src */
+            if (ZSTD_isError(blockSize)) return blockSize; 
+            if (bp.blockType == bt_end) 
+            { 
+                ctx->expected = 0; 
+                ctx->stage = ZSTDds_getFrameHeaderSize; 
+            } 
+            else 
+            { 
+                ctx->expected = blockSize; 
+                ctx->bType = bp.blockType; 
+                ctx->stage = ZSTDds_decompressBlock; 
+            } 
+            return 0; 
+        } 
+    case ZSTDds_decompressBlock: 
+        { 
+            /* Decompress : block content */ 
+            size_t rSize; 
+            switch(ctx->bType) 
+            { 
+            case bt_compressed: 
+                rSize = ZSTD_decompressBlock_internal(ctx, dst, maxDstSize, src, srcSize); 
+                break; 
+            case bt_raw : 
+                rSize = ZSTD_copyRawBlock(dst, maxDstSize, src, srcSize); 
+                break; 
+            case bt_rle : 
+                return ERROR(GENERIC);   /* not yet handled */ 
+                break; 
+            case bt_end :   /* should never happen (filtered at phase 1) */ 
+                rSize = 0; 
+                break; 
+            default: 
+                return ERROR(GENERIC); 
+            } 
+            ctx->stage = ZSTDds_decodeBlockHeader; 
+            ctx->expected = ZSTD_blockHeaderSize; 
+            ctx->previousDstEnd = (char*)dst + rSize; 
+            return rSize; 
+        } 
+    default: 
+        return ERROR(GENERIC);   /* impossible */ 
+    } 
+} 
+ 
+ 
+static void ZSTD_decompress_insertDictionary(ZSTD_DCtx* ctx, const void* dict, size_t dictSize) 
+{ 
+    ctx->dictEnd = ctx->previousDstEnd; 
+    ctx->vBase = (const char*)dict - ((const char*)(ctx->previousDstEnd) - (const char*)(ctx->base)); 
+    ctx->base = dict; 
+    ctx->previousDstEnd = (const char*)dict + dictSize; 
+} 
+ 
+ 
+ 
+/* 
+    Buffered version of Zstd compression library 
+    Copyright (C) 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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+ 
+/* The objects defined into this file should be considered experimental. 
+ * They are not labelled stable, as their prototype may change in the future. 
+ * You can use them for tests, provide feedback, or if you can endure risk of future changes. 
+ */ 
+ 
+/* ************************************* 
+*  Includes 
+***************************************/ 
+#include <stdlib.h> 
+ 
+ 
+/** ************************************************ 
+*  Streaming decompression 
+* 
+*  A ZBUFF_DCtx object is required to track streaming operation. 
+*  Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources. 
+*  Use ZBUFF_decompressInit() to start a new decompression operation. 
+*  ZBUFF_DCtx objects can be reused multiple times. 
+* 
+*  Use ZBUFF_decompressContinue() repetitively to consume your input. 
+*  *srcSizePtr and *maxDstSizePtr can be any size. 
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *maxDstSizePtr. 
+*  Note that it may not consume the entire input, in which case it's up to the caller to call again the function with remaining input. 
+*  The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst . 
+*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency) 
+*            or 0 when a frame is completely decoded 
+*            or an error code, which can be tested using ZBUFF_isError(). 
+* 
+*  Hint : recommended buffer sizes (not compulsory) 
+*  output : 128 KB block size is the internal unit, it ensures it's always possible to write a full block when it's decoded. 
+*  input : just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 . 
+* **************************************************/ 
+ 
+typedef enum { ZBUFFds_init, ZBUFFds_readHeader, ZBUFFds_loadHeader, ZBUFFds_decodeHeader, 
+               ZBUFFds_read, ZBUFFds_load, ZBUFFds_flush } ZBUFF_dStage; 
+ 
+/* *** Resource management *** */ 
+ 
+#define ZSTD_frameHeaderSize_max 5   /* too magical, should come from reference */ 
+struct ZBUFFv04_DCtx_s { 
+    ZSTD_DCtx* zc; 
+    ZSTD_parameters params; 
+    char* inBuff; 
+    size_t inBuffSize; 
+    size_t inPos; 
+    char* outBuff; 
+    size_t outBuffSize; 
+    size_t outStart; 
+    size_t outEnd; 
+    size_t hPos; 
+    const char* dict; 
+    size_t dictSize; 
+    ZBUFF_dStage stage; 
+    unsigned char headerBuffer[ZSTD_frameHeaderSize_max]; 
+};   /* typedef'd to ZBUFF_DCtx within "zstd_buffered.h" */ 
+ 
+typedef ZBUFFv04_DCtx ZBUFF_DCtx; 
+ 
+ 
+static ZBUFF_DCtx* ZBUFF_createDCtx(void) 
+{ 
+    ZBUFF_DCtx* zbc = (ZBUFF_DCtx*)malloc(sizeof(ZBUFF_DCtx)); 
+    if (zbc==NULL) return NULL; 
+    memset(zbc, 0, sizeof(*zbc)); 
+    zbc->zc = ZSTD_createDCtx(); 
+    zbc->stage = ZBUFFds_init; 
+    return zbc; 
+} 
+ 
+static size_t ZBUFF_freeDCtx(ZBUFF_DCtx* zbc) 
+{ 
+    if (zbc==NULL) return 0;   /* support free on null */ 
+    ZSTD_freeDCtx(zbc->zc); 
+    free(zbc->inBuff); 
+    free(zbc->outBuff); 
+    free(zbc); 
+    return 0; 
+} 
+ 
+ 
+/* *** Initialization *** */ 
+ 
+static size_t ZBUFF_decompressInit(ZBUFF_DCtx* zbc) 
+{ 
+    zbc->stage = ZBUFFds_readHeader; 
+    zbc->hPos = zbc->inPos = zbc->outStart = zbc->outEnd = zbc->dictSize = 0; 
+    return ZSTD_resetDCtx(zbc->zc); 
+} 
+ 
+ 
+static size_t ZBUFF_decompressWithDictionary(ZBUFF_DCtx* zbc, const void* src, size_t srcSize) 
+{ 
+    zbc->dict = (const char*)src; 
+    zbc->dictSize = srcSize; 
+    return 0; 
+} 
+ 
+static size_t ZBUFF_limitCopy(void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    size_t length = MIN(maxDstSize, srcSize); 
+    memcpy(dst, src, length); 
+    return length; 
+} 
+ 
+/* *** Decompression *** */ 
+ 
+static size_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbc, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr) 
+{ 
+    const char* const istart = (const char*)src; 
+    const char* ip = istart; 
+    const char* const iend = istart + *srcSizePtr; 
+    char* const ostart = (char*)dst; 
+    char* op = ostart; 
+    char* const oend = ostart + *maxDstSizePtr; 
+    U32 notDone = 1; 
+ 
+    while (notDone) 
+    { 
+        switch(zbc->stage) 
+        { 
+ 
+        case ZBUFFds_init : 
+            return ERROR(init_missing); 
+ 
+        case ZBUFFds_readHeader : 
+            /* read header from src */ 
             {   size_t const headerSize = ZSTD_getFrameParams(&(zbc->params), src, *srcSizePtr);
-                if (ZSTD_isError(headerSize)) return headerSize;
+                if (ZSTD_isError(headerSize)) return headerSize; 
                 if (headerSize) {
-                    /* not enough input to decode header : tell how many bytes would be necessary */
-                    memcpy(zbc->headerBuffer+zbc->hPos, src, *srcSizePtr);
-                    zbc->hPos += *srcSizePtr;
-                    *maxDstSizePtr = 0;
-                    zbc->stage = ZBUFFds_loadHeader;
-                    return headerSize - zbc->hPos;
-                }
-                zbc->stage = ZBUFFds_decodeHeader;
-                break;
-            }
-
-        case ZBUFFds_loadHeader:
-            /* complete header from src */
+                    /* not enough input to decode header : tell how many bytes would be necessary */ 
+                    memcpy(zbc->headerBuffer+zbc->hPos, src, *srcSizePtr); 
+                    zbc->hPos += *srcSizePtr; 
+                    *maxDstSizePtr = 0; 
+                    zbc->stage = ZBUFFds_loadHeader; 
+                    return headerSize - zbc->hPos; 
+                } 
+                zbc->stage = ZBUFFds_decodeHeader; 
+                break; 
+            } 
+ 
+        case ZBUFFds_loadHeader: 
+            /* complete header from src */ 
             {   size_t headerSize = ZBUFF_limitCopy(
-                    zbc->headerBuffer + zbc->hPos, ZSTD_frameHeaderSize_max - zbc->hPos,
-                    src, *srcSizePtr);
-                zbc->hPos += headerSize;
-                ip += headerSize;
-                headerSize = ZSTD_getFrameParams(&(zbc->params), zbc->headerBuffer, zbc->hPos);
-                if (ZSTD_isError(headerSize)) return headerSize;
-                if (headerSize) {
-                    /* not enough input to decode header : tell how many bytes would be necessary */
-                    *maxDstSizePtr = 0;
-                    return headerSize - zbc->hPos;
-            }   }
+                    zbc->headerBuffer + zbc->hPos, ZSTD_frameHeaderSize_max - zbc->hPos, 
+                    src, *srcSizePtr); 
+                zbc->hPos += headerSize; 
+                ip += headerSize; 
+                headerSize = ZSTD_getFrameParams(&(zbc->params), zbc->headerBuffer, zbc->hPos); 
+                if (ZSTD_isError(headerSize)) return headerSize; 
+                if (headerSize) { 
+                    /* not enough input to decode header : tell how many bytes would be necessary */ 
+                    *maxDstSizePtr = 0; 
+                    return headerSize - zbc->hPos; 
+            }   } 
             /* intentional fallthrough */
-
-        case ZBUFFds_decodeHeader:
-                /* apply header to create / resize buffers */
+ 
+        case ZBUFFds_decodeHeader: 
+                /* apply header to create / resize buffers */ 
                 {   size_t const neededOutSize = (size_t)1 << zbc->params.windowLog;
                     size_t const neededInSize = BLOCKSIZE;   /* a block is never > BLOCKSIZE */
-                    if (zbc->inBuffSize < neededInSize) {
-                        free(zbc->inBuff);
-                        zbc->inBuffSize = neededInSize;
-                        zbc->inBuff = (char*)malloc(neededInSize);
-                        if (zbc->inBuff == NULL) return ERROR(memory_allocation);
-                    }
-                    if (zbc->outBuffSize < neededOutSize) {
-                        free(zbc->outBuff);
-                        zbc->outBuffSize = neededOutSize;
-                        zbc->outBuff = (char*)malloc(neededOutSize);
-                        if (zbc->outBuff == NULL) return ERROR(memory_allocation);
-                }   }
-                if (zbc->dictSize)
-                    ZSTD_decompress_insertDictionary(zbc->zc, zbc->dict, zbc->dictSize);
-                if (zbc->hPos) {
-                    /* some data already loaded into headerBuffer : transfer into inBuff */
-                    memcpy(zbc->inBuff, zbc->headerBuffer, zbc->hPos);
-                    zbc->inPos = zbc->hPos;
-                    zbc->hPos = 0;
-                    zbc->stage = ZBUFFds_load;
-                    break;
-                }
-                zbc->stage = ZBUFFds_read;
-
-        case ZBUFFds_read:
-            {
-                size_t neededInSize = ZSTD_nextSrcSizeToDecompress(zbc->zc);
-                if (neededInSize==0)   /* end of frame */
-                {
-                    zbc->stage = ZBUFFds_init;
-                    notDone = 0;
-                    break;
-                }
-                if ((size_t)(iend-ip) >= neededInSize)
-                {
-                    /* directly decode from src */
-                    size_t decodedSize = ZSTD_decompressContinue(zbc->zc,
-                        zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart,
-                        ip, neededInSize);
-                    if (ZSTD_isError(decodedSize)) return decodedSize;
-                    ip += neededInSize;
-                    if (!decodedSize) break;   /* this was just a header */
-                    zbc->outEnd = zbc->outStart +  decodedSize;
-                    zbc->stage = ZBUFFds_flush;
-                    break;
-                }
-                if (ip==iend) { notDone = 0; break; }   /* no more input */
-                zbc->stage = ZBUFFds_load;
-            }
-
-        case ZBUFFds_load:
-            {
-                size_t neededInSize = ZSTD_nextSrcSizeToDecompress(zbc->zc);
-                size_t toLoad = neededInSize - zbc->inPos;   /* should always be <= remaining space within inBuff */
-                size_t loadedSize;
-                if (toLoad > zbc->inBuffSize - zbc->inPos) return ERROR(corruption_detected);   /* should never happen */
-                loadedSize = ZBUFF_limitCopy(zbc->inBuff + zbc->inPos, toLoad, ip, iend-ip);
-                ip += loadedSize;
-                zbc->inPos += loadedSize;
-                if (loadedSize < toLoad) { notDone = 0; break; }   /* not enough input, wait for more */
-                {
-                    size_t decodedSize = ZSTD_decompressContinue(zbc->zc,
-                        zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart,
-                        zbc->inBuff, neededInSize);
-                    if (ZSTD_isError(decodedSize)) return decodedSize;
-                    zbc->inPos = 0;   /* input is consumed */
-                    if (!decodedSize) { zbc->stage = ZBUFFds_read; break; }   /* this was just a header */
-                    zbc->outEnd = zbc->outStart +  decodedSize;
-                    zbc->stage = ZBUFFds_flush;
-                    // break; /* ZBUFFds_flush follows */
-                }
-            }
-        case ZBUFFds_flush:
-            {
-                size_t toFlushSize = zbc->outEnd - zbc->outStart;
-                size_t flushedSize = ZBUFF_limitCopy(op, oend-op, zbc->outBuff + zbc->outStart, toFlushSize);
-                op += flushedSize;
-                zbc->outStart += flushedSize;
-                if (flushedSize == toFlushSize)
-                {
-                    zbc->stage = ZBUFFds_read;
-                    if (zbc->outStart + BLOCKSIZE > zbc->outBuffSize)
-                        zbc->outStart = zbc->outEnd = 0;
-                    break;
-                }
-                /* cannot flush everything */
-                notDone = 0;
-                break;
-            }
-        default: return ERROR(GENERIC);   /* impossible */
-        }
-    }
-
-    *srcSizePtr = ip-istart;
-    *maxDstSizePtr = op-ostart;
-
-    {
-        size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zbc->zc);
-        if (nextSrcSizeHint > 3) nextSrcSizeHint+= 3;   /* get the next block header while at it */
-        nextSrcSizeHint -= zbc->inPos;   /* already loaded*/
-        return nextSrcSizeHint;
-    }
-}
-
-
-/* *************************************
-*  Tool functions
-***************************************/
-unsigned ZBUFFv04_isError(size_t errorCode) { return ERR_isError(errorCode); }
-const char* ZBUFFv04_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
-
-size_t ZBUFFv04_recommendedDInSize()  { return BLOCKSIZE + 3; }
-size_t ZBUFFv04_recommendedDOutSize() { return BLOCKSIZE; }
-
-
-
-/*- ========================================================================= -*/
-
-/* final wrapping stage */
-
-size_t ZSTDv04_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    return ZSTD_decompress_usingDict(dctx, dst, maxDstSize, src, srcSize, NULL, 0);
-}
-
-size_t ZSTDv04_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE==1)
-    size_t regenSize;
-    ZSTD_DCtx* dctx = ZSTD_createDCtx();
-    if (dctx==NULL) return ERROR(memory_allocation);
-    regenSize = ZSTDv04_decompressDCtx(dctx, dst, maxDstSize, src, srcSize);
-    ZSTD_freeDCtx(dctx);
-    return regenSize;
-#else
-    ZSTD_DCtx dctx;
+                    if (zbc->inBuffSize < neededInSize) { 
+                        free(zbc->inBuff); 
+                        zbc->inBuffSize = neededInSize; 
+                        zbc->inBuff = (char*)malloc(neededInSize); 
+                        if (zbc->inBuff == NULL) return ERROR(memory_allocation); 
+                    } 
+                    if (zbc->outBuffSize < neededOutSize) { 
+                        free(zbc->outBuff); 
+                        zbc->outBuffSize = neededOutSize; 
+                        zbc->outBuff = (char*)malloc(neededOutSize); 
+                        if (zbc->outBuff == NULL) return ERROR(memory_allocation); 
+                }   } 
+                if (zbc->dictSize) 
+                    ZSTD_decompress_insertDictionary(zbc->zc, zbc->dict, zbc->dictSize); 
+                if (zbc->hPos) { 
+                    /* some data already loaded into headerBuffer : transfer into inBuff */ 
+                    memcpy(zbc->inBuff, zbc->headerBuffer, zbc->hPos); 
+                    zbc->inPos = zbc->hPos; 
+                    zbc->hPos = 0; 
+                    zbc->stage = ZBUFFds_load; 
+                    break; 
+                } 
+                zbc->stage = ZBUFFds_read; 
+ 
+        case ZBUFFds_read: 
+            { 
+                size_t neededInSize = ZSTD_nextSrcSizeToDecompress(zbc->zc); 
+                if (neededInSize==0)   /* end of frame */ 
+                { 
+                    zbc->stage = ZBUFFds_init; 
+                    notDone = 0; 
+                    break; 
+                } 
+                if ((size_t)(iend-ip) >= neededInSize) 
+                { 
+                    /* directly decode from src */ 
+                    size_t decodedSize = ZSTD_decompressContinue(zbc->zc, 
+                        zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart, 
+                        ip, neededInSize); 
+                    if (ZSTD_isError(decodedSize)) return decodedSize; 
+                    ip += neededInSize; 
+                    if (!decodedSize) break;   /* this was just a header */ 
+                    zbc->outEnd = zbc->outStart +  decodedSize; 
+                    zbc->stage = ZBUFFds_flush; 
+                    break; 
+                } 
+                if (ip==iend) { notDone = 0; break; }   /* no more input */ 
+                zbc->stage = ZBUFFds_load; 
+            } 
+ 
+        case ZBUFFds_load: 
+            { 
+                size_t neededInSize = ZSTD_nextSrcSizeToDecompress(zbc->zc); 
+                size_t toLoad = neededInSize - zbc->inPos;   /* should always be <= remaining space within inBuff */ 
+                size_t loadedSize; 
+                if (toLoad > zbc->inBuffSize - zbc->inPos) return ERROR(corruption_detected);   /* should never happen */ 
+                loadedSize = ZBUFF_limitCopy(zbc->inBuff + zbc->inPos, toLoad, ip, iend-ip); 
+                ip += loadedSize; 
+                zbc->inPos += loadedSize; 
+                if (loadedSize < toLoad) { notDone = 0; break; }   /* not enough input, wait for more */ 
+                { 
+                    size_t decodedSize = ZSTD_decompressContinue(zbc->zc, 
+                        zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart, 
+                        zbc->inBuff, neededInSize); 
+                    if (ZSTD_isError(decodedSize)) return decodedSize; 
+                    zbc->inPos = 0;   /* input is consumed */ 
+                    if (!decodedSize) { zbc->stage = ZBUFFds_read; break; }   /* this was just a header */ 
+                    zbc->outEnd = zbc->outStart +  decodedSize; 
+                    zbc->stage = ZBUFFds_flush; 
+                    // break; /* ZBUFFds_flush follows */ 
+                } 
+            } 
+        case ZBUFFds_flush: 
+            { 
+                size_t toFlushSize = zbc->outEnd - zbc->outStart; 
+                size_t flushedSize = ZBUFF_limitCopy(op, oend-op, zbc->outBuff + zbc->outStart, toFlushSize); 
+                op += flushedSize; 
+                zbc->outStart += flushedSize; 
+                if (flushedSize == toFlushSize) 
+                { 
+                    zbc->stage = ZBUFFds_read; 
+                    if (zbc->outStart + BLOCKSIZE > zbc->outBuffSize) 
+                        zbc->outStart = zbc->outEnd = 0; 
+                    break; 
+                } 
+                /* cannot flush everything */ 
+                notDone = 0; 
+                break; 
+            } 
+        default: return ERROR(GENERIC);   /* impossible */ 
+        } 
+    } 
+ 
+    *srcSizePtr = ip-istart; 
+    *maxDstSizePtr = op-ostart; 
+ 
+    { 
+        size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zbc->zc); 
+        if (nextSrcSizeHint > 3) nextSrcSizeHint+= 3;   /* get the next block header while at it */ 
+        nextSrcSizeHint -= zbc->inPos;   /* already loaded*/ 
+        return nextSrcSizeHint; 
+    } 
+} 
+ 
+ 
+/* ************************************* 
+*  Tool functions 
+***************************************/ 
+unsigned ZBUFFv04_isError(size_t errorCode) { return ERR_isError(errorCode); } 
+const char* ZBUFFv04_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); } 
+ 
+size_t ZBUFFv04_recommendedDInSize()  { return BLOCKSIZE + 3; } 
+size_t ZBUFFv04_recommendedDOutSize() { return BLOCKSIZE; } 
+ 
+ 
+ 
+/*- ========================================================================= -*/ 
+ 
+/* final wrapping stage */ 
+ 
+size_t ZSTDv04_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    return ZSTD_decompress_usingDict(dctx, dst, maxDstSize, src, srcSize, NULL, 0); 
+} 
+ 
+size_t ZSTDv04_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE==1) 
+    size_t regenSize; 
+    ZSTD_DCtx* dctx = ZSTD_createDCtx(); 
+    if (dctx==NULL) return ERROR(memory_allocation); 
+    regenSize = ZSTDv04_decompressDCtx(dctx, dst, maxDstSize, src, srcSize); 
+    ZSTD_freeDCtx(dctx); 
+    return regenSize; 
+#else 
+    ZSTD_DCtx dctx; 
     return ZSTDv04_decompressDCtx(&dctx, dst, maxDstSize, src, srcSize);
-#endif
-}
-
-
-size_t ZSTDv04_resetDCtx(ZSTDv04_Dctx* dctx) { return ZSTD_resetDCtx(dctx); }
-
-size_t ZSTDv04_nextSrcSizeToDecompress(ZSTDv04_Dctx* dctx)
-{
-    return ZSTD_nextSrcSizeToDecompress(dctx);
-}
-
-size_t ZSTDv04_decompressContinue(ZSTDv04_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    return ZSTD_decompressContinue(dctx, dst, maxDstSize, src, srcSize);
-}
-
-
-
-ZBUFFv04_DCtx* ZBUFFv04_createDCtx(void) { return ZBUFF_createDCtx(); }
-size_t      ZBUFFv04_freeDCtx(ZBUFFv04_DCtx* dctx) { return ZBUFF_freeDCtx(dctx); }
-
-size_t ZBUFFv04_decompressInit(ZBUFFv04_DCtx* dctx) { return ZBUFF_decompressInit(dctx); }
-size_t ZBUFFv04_decompressWithDictionary(ZBUFFv04_DCtx* dctx, const void* src, size_t srcSize)
-{ return ZBUFF_decompressWithDictionary(dctx, src, srcSize); }
-
-size_t ZBUFFv04_decompressContinue(ZBUFFv04_DCtx* dctx, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr)
-{
-    return ZBUFF_decompressContinue(dctx, dst, maxDstSizePtr, src, srcSizePtr);
-}
+#endif 
+} 
+ 
+ 
+size_t ZSTDv04_resetDCtx(ZSTDv04_Dctx* dctx) { return ZSTD_resetDCtx(dctx); } 
+ 
+size_t ZSTDv04_nextSrcSizeToDecompress(ZSTDv04_Dctx* dctx) 
+{ 
+    return ZSTD_nextSrcSizeToDecompress(dctx); 
+} 
+ 
+size_t ZSTDv04_decompressContinue(ZSTDv04_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    return ZSTD_decompressContinue(dctx, dst, maxDstSize, src, srcSize); 
+} 
+ 
+ 
+ 
+ZBUFFv04_DCtx* ZBUFFv04_createDCtx(void) { return ZBUFF_createDCtx(); } 
+size_t      ZBUFFv04_freeDCtx(ZBUFFv04_DCtx* dctx) { return ZBUFF_freeDCtx(dctx); } 
+ 
+size_t ZBUFFv04_decompressInit(ZBUFFv04_DCtx* dctx) { return ZBUFF_decompressInit(dctx); } 
+size_t ZBUFFv04_decompressWithDictionary(ZBUFFv04_DCtx* dctx, const void* src, size_t srcSize) 
+{ return ZBUFF_decompressWithDictionary(dctx, src, srcSize); } 
+ 
+size_t ZBUFFv04_decompressContinue(ZBUFFv04_DCtx* dctx, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr) 
+{ 
+    return ZBUFF_decompressContinue(dctx, dst, maxDstSizePtr, src, srcSizePtr); 
+} 
 
 ZSTD_DCtx* ZSTDv04_createDCtx(void) { return ZSTD_createDCtx(); }
 size_t ZSTDv04_freeDCtx(ZSTD_DCtx* dctx) { return ZSTD_freeDCtx(dctx); }
diff --git a/contrib/libs/zstd06/legacy/zstd_v04.h b/contrib/libs/zstd06/legacy/zstd_v04.h
index c539000a32..807d9535e9 100644
--- a/contrib/libs/zstd06/legacy/zstd_v04.h
+++ b/contrib/libs/zstd06/legacy/zstd_v04.h
@@ -1,149 +1,149 @@
 #include <contrib/libs/zstd06/renames.h>
-/*
-    zstd_v04 - decoder for 0.4 format
-    Header File
-    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 :
-    - zstd source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-#pragma once
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* *************************************
-*  Includes
-***************************************/
-#include <stddef.h>   /* size_t */
-
-
-/* *************************************
-*  Simple one-step function
-***************************************/
-/**
-ZSTDv04_decompress() : decompress ZSTD frames compliant with v0.4.x format
-    compressedSize : is the exact source size
-    maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated.
-                      It must be equal or larger than originalSize, otherwise decompression will fail.
-    return : the number of bytes decompressed into destination buffer (originalSize)
-             or an errorCode if it fails (which can be tested using ZSTDv01_isError())
-*/
-size_t ZSTDv04_decompress( void* dst, size_t maxOriginalSize,
-                     const void* src, size_t compressedSize);
-
-/**
-ZSTDv04_isError() : tells if the result of ZSTDv04_decompress() is an error
-*/
-unsigned ZSTDv04_isError(size_t code);
-
-
-/* *************************************
-*  Advanced functions
-***************************************/
-typedef struct ZSTDv04_Dctx_s ZSTDv04_Dctx;
-ZSTDv04_Dctx* ZSTDv04_createDCtx(void);
-size_t ZSTDv04_freeDCtx(ZSTDv04_Dctx* dctx);
-
-size_t ZSTDv04_decompressDCtx(ZSTDv04_Dctx* dctx,
-                              void* dst, size_t maxOriginalSize,
-                        const void* src, size_t compressedSize);
-
-
-/* *************************************
-*  Direct Streaming
-***************************************/
-size_t ZSTDv04_resetDCtx(ZSTDv04_Dctx* dctx);
-
-size_t ZSTDv04_nextSrcSizeToDecompress(ZSTDv04_Dctx* dctx);
-size_t ZSTDv04_decompressContinue(ZSTDv04_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);
-/**
-  Use above functions alternatively.
-  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().
-  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.
-  Result is the number of bytes regenerated within 'dst'.
-  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.
-*/
-
-
-/* *************************************
-*  Buffered Streaming
-***************************************/
-typedef struct ZBUFFv04_DCtx_s ZBUFFv04_DCtx;
-ZBUFFv04_DCtx* ZBUFFv04_createDCtx(void);
-size_t         ZBUFFv04_freeDCtx(ZBUFFv04_DCtx* dctx);
-
-size_t ZBUFFv04_decompressInit(ZBUFFv04_DCtx* dctx);
-size_t ZBUFFv04_decompressWithDictionary(ZBUFFv04_DCtx* dctx, const void* dict, size_t dictSize);
-
-size_t ZBUFFv04_decompressContinue(ZBUFFv04_DCtx* dctx, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr);
-
-/** ************************************************
-*  Streaming decompression
-*
-*  A ZBUFF_DCtx object is required to track streaming operation.
-*  Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources.
-*  Use ZBUFF_decompressInit() to start a new decompression operation.
-*  ZBUFF_DCtx objects can be reused multiple times.
-*
-*  Optionally, a reference to a static dictionary can be set, using ZBUFF_decompressWithDictionary()
-*  It must be the same content as the one set during compression phase.
-*  Dictionary content must remain accessible during the decompression process.
-*
-*  Use ZBUFF_decompressContinue() repetitively to consume your input.
-*  *srcSizePtr and *maxDstSizePtr can be any size.
-*  The function will report how many bytes were read or written by modifying *srcSizePtr and *maxDstSizePtr.
-*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
-*  The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst.
-*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency)
-*            or 0 when a frame is completely decoded
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  Hint : recommended buffer sizes (not compulsory) : ZBUFF_recommendedDInSize / ZBUFF_recommendedDOutSize
-*  output : ZBUFF_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when it's decoded.
-*  input : ZBUFF_recommendedDInSize==128Kb+3; just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
-* **************************************************/
-unsigned ZBUFFv04_isError(size_t errorCode);
-const char* ZBUFFv04_getErrorName(size_t errorCode);
-
-
-/** The below functions provide recommended buffer sizes for Compression or Decompression operations.
-*   These sizes are not compulsory, they just tend to offer better latency */
-size_t ZBUFFv04_recommendedDInSize(void);
-size_t ZBUFFv04_recommendedDOutSize(void);
-
-
-/* *************************************
-*  Prefix - version detection
-***************************************/
-#define ZSTDv04_magicNumber 0xFD2FB524   /* v0.4 */
-
-
-#if defined (__cplusplus)
-}
-#endif
+/* 
+    zstd_v04 - decoder for 0.4 format 
+    Header File 
+    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 : 
+    - zstd source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+#pragma once 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/* ************************************* 
+*  Includes 
+***************************************/ 
+#include <stddef.h>   /* size_t */ 
+ 
+ 
+/* ************************************* 
+*  Simple one-step function 
+***************************************/ 
+/** 
+ZSTDv04_decompress() : decompress ZSTD frames compliant with v0.4.x format 
+    compressedSize : is the exact source size 
+    maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated. 
+                      It must be equal or larger than originalSize, otherwise decompression will fail. 
+    return : the number of bytes decompressed into destination buffer (originalSize) 
+             or an errorCode if it fails (which can be tested using ZSTDv01_isError()) 
+*/ 
+size_t ZSTDv04_decompress( void* dst, size_t maxOriginalSize, 
+                     const void* src, size_t compressedSize); 
+ 
+/** 
+ZSTDv04_isError() : tells if the result of ZSTDv04_decompress() is an error 
+*/ 
+unsigned ZSTDv04_isError(size_t code); 
+ 
+ 
+/* ************************************* 
+*  Advanced functions 
+***************************************/ 
+typedef struct ZSTDv04_Dctx_s ZSTDv04_Dctx; 
+ZSTDv04_Dctx* ZSTDv04_createDCtx(void); 
+size_t ZSTDv04_freeDCtx(ZSTDv04_Dctx* dctx); 
+ 
+size_t ZSTDv04_decompressDCtx(ZSTDv04_Dctx* dctx, 
+                              void* dst, size_t maxOriginalSize, 
+                        const void* src, size_t compressedSize); 
+ 
+ 
+/* ************************************* 
+*  Direct Streaming 
+***************************************/ 
+size_t ZSTDv04_resetDCtx(ZSTDv04_Dctx* dctx); 
+ 
+size_t ZSTDv04_nextSrcSizeToDecompress(ZSTDv04_Dctx* dctx); 
+size_t ZSTDv04_decompressContinue(ZSTDv04_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize); 
+/** 
+  Use above functions alternatively. 
+  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue(). 
+  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block. 
+  Result is the number of bytes regenerated within 'dst'. 
+  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header. 
+*/ 
+ 
+ 
+/* ************************************* 
+*  Buffered Streaming 
+***************************************/ 
+typedef struct ZBUFFv04_DCtx_s ZBUFFv04_DCtx; 
+ZBUFFv04_DCtx* ZBUFFv04_createDCtx(void); 
+size_t         ZBUFFv04_freeDCtx(ZBUFFv04_DCtx* dctx); 
+ 
+size_t ZBUFFv04_decompressInit(ZBUFFv04_DCtx* dctx); 
+size_t ZBUFFv04_decompressWithDictionary(ZBUFFv04_DCtx* dctx, const void* dict, size_t dictSize); 
+ 
+size_t ZBUFFv04_decompressContinue(ZBUFFv04_DCtx* dctx, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr); 
+ 
+/** ************************************************ 
+*  Streaming decompression 
+* 
+*  A ZBUFF_DCtx object is required to track streaming operation. 
+*  Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources. 
+*  Use ZBUFF_decompressInit() to start a new decompression operation. 
+*  ZBUFF_DCtx objects can be reused multiple times. 
+* 
+*  Optionally, a reference to a static dictionary can be set, using ZBUFF_decompressWithDictionary() 
+*  It must be the same content as the one set during compression phase. 
+*  Dictionary content must remain accessible during the decompression process. 
+* 
+*  Use ZBUFF_decompressContinue() repetitively to consume your input. 
+*  *srcSizePtr and *maxDstSizePtr can be any size. 
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *maxDstSizePtr. 
+*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again. 
+*  The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst. 
+*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency) 
+*            or 0 when a frame is completely decoded 
+*            or an error code, which can be tested using ZBUFF_isError(). 
+* 
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFF_recommendedDInSize / ZBUFF_recommendedDOutSize 
+*  output : ZBUFF_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when it's decoded. 
+*  input : ZBUFF_recommendedDInSize==128Kb+3; just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 . 
+* **************************************************/ 
+unsigned ZBUFFv04_isError(size_t errorCode); 
+const char* ZBUFFv04_getErrorName(size_t errorCode); 
+ 
+ 
+/** The below functions provide recommended buffer sizes for Compression or Decompression operations. 
+*   These sizes are not compulsory, they just tend to offer better latency */ 
+size_t ZBUFFv04_recommendedDInSize(void); 
+size_t ZBUFFv04_recommendedDOutSize(void); 
+ 
+ 
+/* ************************************* 
+*  Prefix - version detection 
+***************************************/ 
+#define ZSTDv04_magicNumber 0xFD2FB524   /* v0.4 */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
diff --git a/contrib/libs/zstd06/legacy/zstd_v05.c b/contrib/libs/zstd06/legacy/zstd_v05.c
index f3c720fd26..10a8baaf4d 100644
--- a/contrib/libs/zstd06/legacy/zstd_v05.c
+++ b/contrib/libs/zstd06/legacy/zstd_v05.c
@@ -1,3877 +1,3877 @@
-/* ******************************************************************
-   zstd_v05.c
-   Decompression module for ZSTD v0.5 legacy format
-   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 :
-    - Homepage : http://www.zstd.net/
-****************************************************************** */
-
-/*- Dependencies -*/
-#include "zstd_v05.h"
-
-
-/* ******************************************************************
-   mem.h
-   low-level memory access routines
-   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 :
-    - FSEv05 source repository : https://github.com/Cyan4973/FiniteStateEntropy
-    - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef MEM_H_MODULE
-#define MEM_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/*-****************************************
-*  Dependencies
-******************************************/
-#include <stddef.h>    /* size_t, ptrdiff_t */
-#include <string.h>    /* memcpy */
-
-
-/*-****************************************
-*  Compiler specifics
-******************************************/
-#if defined(__GNUC__)
-#  define MEM_STATIC static __attribute__((unused))
-#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#  define MEM_STATIC static inline
-#elif defined(_MSC_VER)
-#  define MEM_STATIC static __inline
-#else
-#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
-#endif
-
-
-/*-**************************************************************
-*  Basic Types
-*****************************************************************/
-#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-# include <stdint.h>
-  typedef  uint8_t BYTE;
-  typedef uint16_t U16;
-  typedef  int16_t S16;
-  typedef uint32_t U32;
-  typedef  int32_t S32;
-  typedef uint64_t U64;
-  typedef  int64_t S64;
-#else
-  typedef unsigned char       BYTE;
-  typedef unsigned short      U16;
-  typedef   signed short      S16;
-  typedef unsigned int        U32;
-  typedef   signed int        S32;
-  typedef unsigned long long  U64;
-  typedef   signed long long  S64;
-#endif
-
-
-/*-**************************************************************
-*  Memory I/O
-*****************************************************************/
-/* MEM_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 is portable but violate C standard.
- *            It can generate buggy code on targets depending on alignment.
- *            In some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
- * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
- * Prefer these methods in priority order (0 > 1 > 2)
- */
-#ifndef MEM_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 MEM_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 MEM_FORCE_MEMORY_ACCESS 1
-#  endif
-#endif
-
-MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }
-MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }
-
-MEM_STATIC unsigned MEM_isLittleEndian(void)
-{
-    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
-    return one.c[0];
-}
-
-#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)
-
-/* violates C standard, by lying on structure alignment.
-Only use if no other choice to achieve best performance on target platform */
-MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
-MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
-MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
-MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
-MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }
-
-#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_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 { U16 u16; U32 u32; U64 u64; size_t st; } __attribute__((packed)) unalign;
-
-MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
-MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
-MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
-MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; }
-MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign*)memPtr)->u64 = value; }
-
-#else
-
-/* default method, safe and standard.
-   can sometimes prove slower */
-
-MEM_STATIC U16 MEM_read16(const void* memPtr)
-{
-    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC U32 MEM_read32(const void* memPtr)
-{
-    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC U64 MEM_read64(const void* memPtr)
-{
-    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-MEM_STATIC void MEM_write32(void* memPtr, U32 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-MEM_STATIC void MEM_write64(void* memPtr, U64 value)
-{
-    memcpy(memPtr, &value, sizeof(value));
-}
-
-#endif /* MEM_FORCE_MEMORY_ACCESS */
-
-
-MEM_STATIC U16 MEM_readLE16(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read16(memPtr);
-    else {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U16)(p[0] + (p[1]<<8));
-    }
-}
-
-MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)
-{
-    if (MEM_isLittleEndian()) {
-        MEM_write16(memPtr, val);
-    } else {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE)val;
-        p[1] = (BYTE)(val>>8);
-    }
-}
-
-MEM_STATIC U32 MEM_readLE32(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read32(memPtr);
-    else {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));
-    }
-}
-
-MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)
-{
-    if (MEM_isLittleEndian()) {
-        MEM_write32(memPtr, val32);
-    } else {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE)val32;
-        p[1] = (BYTE)(val32>>8);
-        p[2] = (BYTE)(val32>>16);
-        p[3] = (BYTE)(val32>>24);
-    }
-}
-
-MEM_STATIC U64 MEM_readLE64(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read64(memPtr);
-    else {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)
-                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));
-    }
-}
-
-MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)
-{
-    if (MEM_isLittleEndian()) {
-        MEM_write64(memPtr, val64);
-    } else {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE)val64;
-        p[1] = (BYTE)(val64>>8);
-        p[2] = (BYTE)(val64>>16);
-        p[3] = (BYTE)(val64>>24);
-        p[4] = (BYTE)(val64>>32);
-        p[5] = (BYTE)(val64>>40);
-        p[6] = (BYTE)(val64>>48);
-        p[7] = (BYTE)(val64>>56);
-    }
-}
-
-MEM_STATIC size_t MEM_readLEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readLE32(memPtr);
-    else
-        return (size_t)MEM_readLE64(memPtr);
-}
-
-MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val)
-{
-    if (MEM_32bits())
-        MEM_writeLE32(memPtr, (U32)val);
-    else
-        MEM_writeLE64(memPtr, (U64)val);
-}
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* MEM_H_MODULE */
-
-/* ******************************************************************
-   Error codes list
-   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 :
-   - Source repository : https://github.com/Cyan4973/zstd
-****************************************************************** */
-#ifndef ERROR_PUBLIC_H_MODULE
-#define ERROR_PUBLIC_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* ****************************************
-*  error codes list
-******************************************/
-typedef enum {
-  ZSTDv05_error_no_error,
-  ZSTDv05_error_GENERIC,
-  ZSTDv05_error_prefix_unknown,
-  ZSTDv05_error_frameParameter_unsupported,
-  ZSTDv05_error_frameParameter_unsupportedBy32bits,
-  ZSTDv05_error_init_missing,
-  ZSTDv05_error_memory_allocation,
-  ZSTDv05_error_stage_wrong,
-  ZSTDv05_error_dstSize_tooSmall,
-  ZSTDv05_error_srcSize_wrong,
-  ZSTDv05_error_corruption_detected,
-  ZSTDv05_error_tableLog_tooLarge,
-  ZSTDv05_error_maxSymbolValue_tooLarge,
-  ZSTDv05_error_maxSymbolValue_tooSmall,
-  ZSTDv05_error_dictionary_corrupted,
-  ZSTDv05_error_maxCode
-} ZSTDv05_ErrorCode;
-
-/* note : functions provide error codes in reverse negative order,
-          so compare with (size_t)(0-enum) */
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* ERROR_PUBLIC_H_MODULE */
-
-
-/*
-    zstd - standard compression library
-    Header File for static linking only
-    Copyright (C) 2014-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
-*/
-#ifndef ZSTD_STATIC_H
-#define ZSTD_STATIC_H
-
-/* The prototypes defined within this file are considered experimental.
- * They should not be used in the context DLL as they may change in the future.
- * Prefer static linking if you need them, to control breaking version changes issues.
- */
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-
-/*-*************************************
-*  Types
-***************************************/
-#define ZSTDv05_WINDOWLOG_ABSOLUTEMIN 11
-
-
-/*-*************************************
-*  Advanced functions
-***************************************/
-/*- Advanced Decompression functions -*/
-
-/*! ZSTDv05_decompress_usingPreparedDCtx() :
-*   Same as ZSTDv05_decompress_usingDict, but using a reference context `preparedDCtx`, where dictionary has been loaded.
-*   It avoids reloading the dictionary each time.
-*   `preparedDCtx` must have been properly initialized using ZSTDv05_decompressBegin_usingDict().
-*   Requires 2 contexts : 1 for reference, which will not be modified, and 1 to run the decompression operation */
-size_t ZSTDv05_decompress_usingPreparedDCtx(
-                                             ZSTDv05_DCtx* dctx, const ZSTDv05_DCtx* preparedDCtx,
-                                             void* dst, size_t dstCapacity,
-                                       const void* src, size_t srcSize);
-
-
-/* **************************************
-*  Streaming functions (direct mode)
-****************************************/
-size_t ZSTDv05_decompressBegin(ZSTDv05_DCtx* dctx);
-size_t ZSTDv05_decompressBegin_usingDict(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize);
-void   ZSTDv05_copyDCtx(ZSTDv05_DCtx* dctx, const ZSTDv05_DCtx* preparedDCtx);
-
-size_t ZSTDv05_getFrameParams(ZSTDv05_parameters* params, const void* src, size_t srcSize);
-
-size_t ZSTDv05_nextSrcSizeToDecompress(ZSTDv05_DCtx* dctx);
-size_t ZSTDv05_decompressContinue(ZSTDv05_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-/*
-  Streaming decompression, direct mode (bufferless)
-
-  A ZSTDv05_DCtx object is required to track streaming operations.
-  Use ZSTDv05_createDCtx() / ZSTDv05_freeDCtx() to manage it.
-  A ZSTDv05_DCtx object can be re-used multiple times.
-
-  First typical operation is to retrieve frame parameters, using ZSTDv05_getFrameParams().
-  This operation is independent, and just needs enough input data to properly decode the frame header.
-  Objective is to retrieve *params.windowlog, to know minimum amount of memory required during decoding.
-  Result : 0 when successful, it means the ZSTDv05_parameters structure has been filled.
-           >0 : means there is not enough data into src. Provides the expected size to successfully decode header.
-           errorCode, which can be tested using ZSTDv05_isError()
-
-  Start decompression, with ZSTDv05_decompressBegin() or ZSTDv05_decompressBegin_usingDict()
-  Alternatively, you can copy a prepared context, using ZSTDv05_copyDCtx()
-
-  Then use ZSTDv05_nextSrcSizeToDecompress() and ZSTDv05_decompressContinue() alternatively.
-  ZSTDv05_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTDv05_decompressContinue().
-  ZSTDv05_decompressContinue() requires this exact amount of bytes, or it will fail.
-  ZSTDv05_decompressContinue() needs previous data blocks during decompression, up to (1 << windowlog).
-  They should preferably be located contiguously, prior to current block. Alternatively, a round buffer is also possible.
-
-  @result of ZSTDv05_decompressContinue() is the number of bytes regenerated within 'dst'.
-  It can be zero, which is not an error; it just means ZSTDv05_decompressContinue() has decoded some header.
-
-  A frame is fully decoded when ZSTDv05_nextSrcSizeToDecompress() returns zero.
-  Context can then be reset to start a new decompression.
-*/
-
-
-/* **************************************
-*  Block functions
-****************************************/
-/*! Block functions produce and decode raw zstd blocks, without frame metadata.
-    User will have to take in charge required information to regenerate data, such as block sizes.
-
-    A few rules to respect :
-    - Uncompressed block size must be <= 128 KB
-    - Compressing or decompressing requires a context structure
-      + Use ZSTDv05_createCCtx() and ZSTDv05_createDCtx()
-    - It is necessary to init context before starting
-      + compression : ZSTDv05_compressBegin()
-      + decompression : ZSTDv05_decompressBegin()
-      + variants _usingDict() are also allowed
-      + copyCCtx() and copyDCtx() work too
-    - When a block is considered not compressible enough, ZSTDv05_compressBlock() result will be zero.
-      In which case, nothing is produced into `dst`.
-      + User must test for such outcome and deal directly with uncompressed data
-      + ZSTDv05_decompressBlock() doesn't accept uncompressed data as input !!
-*/
-
-size_t ZSTDv05_decompressBlock(ZSTDv05_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* ZSTDv05_STATIC_H */
-
-
-
-/* ******************************************************************
-   Error codes and messages
-   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/zstd
-****************************************************************** */
-/* Note : this module is expected to remain private, do not expose it */
-
-#ifndef ERROR_H_MODULE
-#define ERROR_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-
-/* ****************************************
-*  Compiler-specific
-******************************************/
-#if defined(__GNUC__)
-#  define ERR_STATIC static __attribute__((unused))
-#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#  define ERR_STATIC static inline
-#elif defined(_MSC_VER)
-#  define ERR_STATIC static __inline
-#else
-#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */
-#endif
-
-
-/*-****************************************
-*  Customization
-******************************************/
-typedef ZSTDv05_ErrorCode ERR_enum;
-#define PREFIX(name) ZSTDv05_error_##name
-
-
-/*-****************************************
-*  Error codes handling
-******************************************/
-#ifdef ERROR
-#  undef ERROR   /* reported already defined on VS 2015 (Rich Geldreich) */
-#endif
-#define ERROR(name) (size_t)-PREFIX(name)
-
-ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }
-
-ERR_STATIC ERR_enum ERR_getError(size_t code) { if (!ERR_isError(code)) return (ERR_enum)0; return (ERR_enum) (0-code); }
-
-
-/*-****************************************
-*  Error Strings
-******************************************/
-
-ERR_STATIC const char* ERR_getErrorName(size_t code)
-{
-    static const char* notErrorCode = "Unspecified error code";
-    switch( ERR_getError(code) )
-    {
-    case PREFIX(no_error): return "No error detected";
-    case PREFIX(GENERIC):  return "Error (generic)";
-    case PREFIX(prefix_unknown): return "Unknown frame descriptor";
-    case PREFIX(frameParameter_unsupported): return "Unsupported frame parameter";
-    case PREFIX(frameParameter_unsupportedBy32bits): return "Frame parameter unsupported in 32-bits mode";
-    case PREFIX(init_missing): return "Context should be init first";
-    case PREFIX(memory_allocation): return "Allocation error : not enough memory";
-    case PREFIX(stage_wrong): return "Operation not authorized at current processing stage";
-    case PREFIX(dstSize_tooSmall): return "Destination buffer is too small";
-    case PREFIX(srcSize_wrong): return "Src size incorrect";
-    case PREFIX(corruption_detected): return "Corrupted block detected";
-    case PREFIX(tableLog_tooLarge): return "tableLog requires too much memory";
-    case PREFIX(maxSymbolValue_tooLarge): return "Unsupported max possible Symbol Value : too large";
-    case PREFIX(maxSymbolValue_tooSmall): return "Specified maxSymbolValue is too small";
-    case PREFIX(dictionary_corrupted): return "Dictionary is corrupted";
-    case PREFIX(maxCode):
-    default: return notErrorCode;   /* should be impossible, due to ERR_getError() */
-    }
-}
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* ERROR_H_MODULE */
-/*
-    zstd_internal - common functions to include
-    Header File for include
-    Copyright (C) 2014-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 source repository : https://github.com/Cyan4973/zstd
-*/
-#ifndef ZSTD_CCOMMON_H_MODULE
-#define ZSTD_CCOMMON_H_MODULE
-
-
-
-/*-*************************************
-*  Common macros
-***************************************/
-#define MIN(a,b) ((a)<(b) ? (a) : (b))
-#define MAX(a,b) ((a)>(b) ? (a) : (b))
-
-
-/*-*************************************
-*  Common constants
-***************************************/
-#define ZSTDv05_DICT_MAGIC  0xEC30A435
-
-#define KB *(1 <<10)
-#define MB *(1 <<20)
-#define GB *(1U<<30)
-
-#define BLOCKSIZE (128 KB)                 /* define, for static allocation */
-
-static const size_t ZSTDv05_blockHeaderSize = 3;
-static const size_t ZSTDv05_frameHeaderSize_min = 5;
-#define ZSTDv05_frameHeaderSize_max 5         /* define, for static allocation */
-
-#define BITv057 128
-#define BITv056  64
-#define BITv055  32
-#define BITv054  16
-#define BITv051   2
-#define BITv050   1
-
-#define IS_HUFv05 0
-#define IS_PCH 1
-#define IS_RAW 2
-#define IS_RLE 3
-
-#define MINMATCH 4
-#define REPCODE_STARTVALUE 1
-
-#define Litbits  8
-#define MLbits   7
-#define LLbits   6
-#define Offbits  5
-#define MaxLit ((1<<Litbits) - 1)
-#define MaxML  ((1<<MLbits) - 1)
-#define MaxLL  ((1<<LLbits) - 1)
-#define MaxOff ((1<<Offbits)- 1)
-#define MLFSEv05Log   10
-#define LLFSEv05Log   10
-#define OffFSEv05Log   9
-#define MaxSeq MAX(MaxLL, MaxML)
-
-#define FSEv05_ENCODING_RAW     0
-#define FSEv05_ENCODING_RLE     1
-#define FSEv05_ENCODING_STATIC  2
-#define FSEv05_ENCODING_DYNAMIC 3
-
-
-#define HufLog 12
-
-#define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */
-#define MIN_CBLOCK_SIZE (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */)   /* for a non-null block */
-
-#define WILDCOPY_OVERLENGTH 8
-
-typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t;
-
-
-/*-*******************************************
-*  Shared functions to include for inlining
-*********************************************/
-static void ZSTDv05_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
-
-#define COPY8(d,s) { ZSTDv05_copy8(d,s); d+=8; s+=8; }
-
-/*! ZSTDv05_wildcopy() :
-*   custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0) */
-MEM_STATIC void ZSTDv05_wildcopy(void* dst, const void* src, size_t length)
-{
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + length;
-    do
-        COPY8(op, ip)
-    while (op < oend);
-}
-
-MEM_STATIC unsigned ZSTDv05_highbit(U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
-    unsigned long r=0;
-    _BitScanReverse(&r, val);
-    return (unsigned)r;
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* GCC Intrinsic */
-    return 31 - __builtin_clz(val);
-#   else   /* Software version */
-    static const int DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
-    U32 v = val;
-    int r;
-    v |= v >> 1;
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-    r = DeBruijnClz[(U32)(v * 0x07C4ACDDU) >> 27];
-    return r;
-#   endif
-}
-
-
-/*-*******************************************
-*  Private interfaces
-*********************************************/
-typedef struct {
-    void* buffer;
-    U32*  offsetStart;
-    U32*  offset;
-    BYTE* offCodeStart;
-    BYTE* offCode;
-    BYTE* litStart;
-    BYTE* lit;
-    BYTE* litLengthStart;
-    BYTE* litLength;
-    BYTE* matchLengthStart;
-    BYTE* matchLength;
-    BYTE* dumpsStart;
-    BYTE* dumps;
-    /* opt */
-    U32* matchLengthFreq;
-    U32* litLengthFreq;
-    U32* litFreq;
-    U32* offCodeFreq;
-    U32  matchLengthSum;
-    U32  litLengthSum;
-    U32  litSum;
-    U32  offCodeSum;
-} seqStore_t;
-
-
-
-#endif   /* ZSTDv05_CCOMMON_H_MODULE */
-/* ******************************************************************
-   FSEv05 : Finite State Entropy coder
-   header file
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef FSEv05_H
-#define FSEv05_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* *****************************************
-*  Includes
-******************************************/
-#include <stddef.h>    /* size_t, ptrdiff_t */
-
-
-/*-****************************************
-*  FSEv05 simple functions
-******************************************/
-size_t FSEv05_decompress(void* dst,  size_t maxDstSize,
-                const void* cSrc, size_t cSrcSize);
-/*!
-FSEv05_decompress():
-    Decompress FSEv05 data from buffer 'cSrc', of size 'cSrcSize',
-    into already allocated destination buffer 'dst', of size 'maxDstSize'.
-    return : size of regenerated data (<= maxDstSize)
-             or an error code, which can be tested using FSEv05_isError()
-
-    ** Important ** : FSEv05_decompress() doesn't decompress non-compressible nor RLE data !!!
-    Why ? : making this distinction requires a header.
-    Header management is intentionally delegated to the user layer, which can better manage special cases.
-*/
-
-
-/* *****************************************
-*  Tool functions
-******************************************/
-/* Error Management */
-unsigned    FSEv05_isError(size_t code);        /* tells if a return value is an error code */
-const char* FSEv05_getErrorName(size_t code);   /* provides error code string (useful for debugging) */
-
-
-
-
-/* *****************************************
-*  FSEv05 detailed API
-******************************************/
-/* *** DECOMPRESSION *** */
-
-/*!
-FSEv05_readNCount():
-   Read compactly saved 'normalizedCounter' from 'rBuffer'.
-   return : size read from 'rBuffer'
-            or an errorCode, which can be tested using FSEv05_isError()
-            maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
-size_t FSEv05_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize);
-
-/*!
-Constructor and Destructor of type FSEv05_DTable
-    Note that its size depends on 'tableLog' */
-typedef unsigned FSEv05_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
-FSEv05_DTable* FSEv05_createDTable(unsigned tableLog);
-void        FSEv05_freeDTable(FSEv05_DTable* dt);
-
-/*!
-FSEv05_buildDTable():
-   Builds 'dt', which must be already allocated, using FSEv05_createDTable()
-   return : 0,
-            or an errorCode, which can be tested using FSEv05_isError() */
-size_t FSEv05_buildDTable (FSEv05_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
-
-/*!
-FSEv05_decompress_usingDTable():
-   Decompress compressed source @cSrc of size @cSrcSize using @dt
-   into @dst which must be already allocated.
-   return : size of regenerated data (necessarily <= @dstCapacity)
-            or an errorCode, which can be tested using FSEv05_isError() */
-size_t FSEv05_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSEv05_DTable* dt);
-
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* FSEv05_H */
-/* ******************************************************************
-   bitstream
-   Part of FSEv05 library
-   header file (to include)
-   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 BITv05STREAM_H_MODULE
-#define BITv05STREAM_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/*
-*  This API consists of small unitary functions, which highly benefit from being inlined.
-*  Since link-time-optimization is not available for all compilers,
-*  these functions are defined into a .h to be included.
-*/
-
-
-
-/*-********************************************
-*  bitStream decoding API (read backward)
-**********************************************/
-typedef struct
-{
-    size_t   bitContainer;
-    unsigned bitsConsumed;
-    const char* ptr;
-    const char* start;
-} BITv05_DStream_t;
-
-typedef enum { BITv05_DStream_unfinished = 0,
-               BITv05_DStream_endOfBuffer = 1,
-               BITv05_DStream_completed = 2,
-               BITv05_DStream_overflow = 3 } BITv05_DStream_status;  /* result of BITv05_reloadDStream() */
-               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
-
-MEM_STATIC size_t   BITv05_initDStream(BITv05_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
-MEM_STATIC size_t   BITv05_readBits(BITv05_DStream_t* bitD, unsigned nbBits);
-MEM_STATIC BITv05_DStream_status BITv05_reloadDStream(BITv05_DStream_t* bitD);
-MEM_STATIC unsigned BITv05_endOfDStream(const BITv05_DStream_t* bitD);
-
-
-/*!
-* Start by invoking BITv05_initDStream().
-* A chunk of the bitStream is then stored into a local register.
-* 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 BITv05_reloadDStream() method.
-* A reload guarantee a minimum of ((8*sizeof(size_t))-7) bits when its result is BITv05_DStream_unfinished.
-* Otherwise, it can be less than that, so proceed accordingly.
-* Checking if DStream has reached its end can be performed with BITv05_endOfDStream()
-*/
-
-
-/*-****************************************
-*  unsafe API
-******************************************/
-MEM_STATIC size_t BITv05_readBitsFast(BITv05_DStream_t* bitD, unsigned nbBits);
-/* faster, but works only if nbBits >= 1 */
-
-
-
-/*-**************************************************************
-*  Helper functions
-****************************************************************/
-MEM_STATIC unsigned BITv05_highbit32 (register U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
-    unsigned long r=0;
-    _BitScanReverse ( &r, val );
-    return (unsigned) r;
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
-    return 31 - __builtin_clz (val);
-#   else   /* Software version */
-    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };
-    U32 v = val;
-    unsigned r;
-    v |= v >> 1;
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
-    return r;
-#   endif
-}
-
-
-
-/*-********************************************************
-* bitStream decoding
-**********************************************************/
-/*!BITv05_initDStream
-*  Initialize a BITv05_DStream_t.
-*  @bitD : a pointer to an already allocated BITv05_DStream_t structure
-*  @srcBuffer must point at the beginning of a bitStream
-*  @srcSize must be the exact size of the bitStream
-*  @result : size of stream (== srcSize) or an errorCode if a problem is detected
-*/
-MEM_STATIC size_t BITv05_initDStream(BITv05_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
-{
-    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
-
-    if (srcSize >=  sizeof(size_t)) {  /* normal case */
-        U32 contain32;
-        bitD->start = (const char*)srcBuffer;
-        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t);
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);
-        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
-        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
-        bitD->bitsConsumed = 8 - BITv05_highbit32(contain32);
-    } else {
-        U32 contain32;
-        bitD->start = (const char*)srcBuffer;
-        bitD->ptr   = bitD->start;
-        bitD->bitContainer = *(const BYTE*)(bitD->start);
-        switch(srcSize)
-        {
-            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);
-            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);
-            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);
-            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;
-            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;
-            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8;
-            default:;
-        }
-        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];
-        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */
-        bitD->bitsConsumed = 8 - BITv05_highbit32(contain32);
-        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;
-    }
-
-    return srcSize;
-}
-
-/*!BITv05_lookBits
- * Provides next n bits from local register
- * local register is not modified (bits are still present for next read/look)
- * On 32-bits, maxNbBits==25
- * On 64-bits, maxNbBits==57
- * @return : value extracted
- */
-MEM_STATIC size_t BITv05_lookBits(BITv05_DStream_t* bitD, U32 nbBits)
-{
-    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
-    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
-}
-
-/*! BITv05_lookBitsFast :
-*   unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BITv05_lookBitsFast(BITv05_DStream_t* bitD, U32 nbBits)
-{
-    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;
-    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);
-}
-
-MEM_STATIC void BITv05_skipBits(BITv05_DStream_t* bitD, U32 nbBits)
-{
-    bitD->bitsConsumed += nbBits;
-}
-
-/*!BITv05_readBits
- * Read next n bits from local register.
- * pay attention to not read more than nbBits contained into local register.
- * @return : extracted value.
- */
-MEM_STATIC size_t BITv05_readBits(BITv05_DStream_t* bitD, U32 nbBits)
-{
-    size_t value = BITv05_lookBits(bitD, nbBits);
-    BITv05_skipBits(bitD, nbBits);
-    return value;
-}
-
-/*!BITv05_readBitsFast :
-*  unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BITv05_readBitsFast(BITv05_DStream_t* bitD, U32 nbBits)
-{
-    size_t value = BITv05_lookBitsFast(bitD, nbBits);
-    BITv05_skipBits(bitD, nbBits);
-    return value;
-}
-
-MEM_STATIC BITv05_DStream_status BITv05_reloadDStream(BITv05_DStream_t* bitD)
-{
-	if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
-		return BITv05_DStream_overflow;
-
-    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) {
-        bitD->ptr -= bitD->bitsConsumed >> 3;
-        bitD->bitsConsumed &= 7;
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);
-        return BITv05_DStream_unfinished;
-    }
-    if (bitD->ptr == bitD->start) {
-        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BITv05_DStream_endOfBuffer;
-        return BITv05_DStream_completed;
-    }
-    {
-        U32 nbBytes = bitD->bitsConsumed >> 3;
-        BITv05_DStream_status result = BITv05_DStream_unfinished;
-        if (bitD->ptr - nbBytes < bitD->start) {
-            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
-            result = BITv05_DStream_endOfBuffer;
-        }
-        bitD->ptr -= nbBytes;
-        bitD->bitsConsumed -= nbBytes*8;
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
-        return result;
-    }
-}
-
-/*! BITv05_endOfDStream
-*   @return Tells if DStream has reached its exact end
-*/
-MEM_STATIC unsigned BITv05_endOfDStream(const BITv05_DStream_t* DStream)
-{
-    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
-}
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* BITv05STREAM_H_MODULE */
-/* ******************************************************************
-   FSEv05 : Finite State Entropy coder
-   header file for static linking (only)
-   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 :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-   - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-#ifndef FSEv05_STATIC_H
-#define FSEv05_STATIC_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-
-/* *****************************************
-*  Static allocation
-*******************************************/
-/* It is possible to statically allocate FSEv05 CTable/DTable as a table of unsigned using below macros */
-#define FSEv05_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
-
-
-/* *****************************************
-*  FSEv05 advanced API
-*******************************************/
-size_t FSEv05_buildDTable_raw (FSEv05_DTable* dt, unsigned nbBits);
-/* build a fake FSEv05_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */
-
-size_t FSEv05_buildDTable_rle (FSEv05_DTable* dt, unsigned char symbolValue);
-/* build a fake FSEv05_DTable, designed to always generate the same symbolValue */
-
-
-
-/* *****************************************
-*  FSEv05 symbol decompression API
-*******************************************/
-typedef struct
-{
-    size_t      state;
-    const void* table;   /* precise table may vary, depending on U16 */
-} FSEv05_DState_t;
-
-
-static void     FSEv05_initDState(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD, const FSEv05_DTable* dt);
-
-static unsigned char FSEv05_decodeSymbol(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD);
-
-static unsigned FSEv05_endOfDState(const FSEv05_DState_t* DStatePtr);
-
-/*!
-Let's now decompose FSEv05_decompress_usingDTable() into its unitary components.
-You will decode FSEv05-encoded symbols from the bitStream,
-and also any other bitFields you put in, **in reverse order**.
-
-You will need a few variables to track your bitStream. They are :
-
-BITv05_DStream_t DStream;    // Stream context
-FSEv05_DState_t  DState;     // State context. Multiple ones are possible
-FSEv05_DTable*   DTablePtr;  // Decoding table, provided by FSEv05_buildDTable()
-
-The first thing to do is to init the bitStream.
-    errorCode = BITv05_initDStream(&DStream, srcBuffer, srcSize);
-
-You should then retrieve your initial state(s)
-(in reverse flushing order if you have several ones) :
-    errorCode = FSEv05_initDState(&DState, &DStream, DTablePtr);
-
-You can then decode your data, symbol after symbol.
-For information the maximum number of bits read by FSEv05_decodeSymbol() is 'tableLog'.
-Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).
-    unsigned char symbol = FSEv05_decodeSymbol(&DState, &DStream);
-
-You can retrieve any bitfield you eventually stored into the bitStream (in reverse order)
-Note : maximum allowed nbBits is 25, for 32-bits compatibility
-    size_t bitField = BITv05_readBits(&DStream, nbBits);
-
-All above operations only read from local register (which size depends on size_t).
-Refueling the register from memory is manually performed by the reload method.
-    endSignal = FSEv05_reloadDStream(&DStream);
-
-BITv05_reloadDStream() result tells if there is still some more data to read from DStream.
-BITv05_DStream_unfinished : there is still some data left into the DStream.
-BITv05_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.
-BITv05_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.
-BITv05_DStream_tooFar : Dstream went too far. Decompression result is corrupted.
-
-When reaching end of buffer (BITv05_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,
-to properly detect the exact end of stream.
-After each decoded symbol, check if DStream is fully consumed using this simple test :
-    BITv05_reloadDStream(&DStream) >= BITv05_DStream_completed
-
-When it's done, verify decompression is fully completed, by checking both DStream and the relevant states.
-Checking if DStream has reached its end is performed by :
-    BITv05_endOfDStream(&DStream);
-Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.
-    FSEv05_endOfDState(&DState);
-*/
-
-
-/* *****************************************
-*  FSEv05 unsafe API
-*******************************************/
-static unsigned char FSEv05_decodeSymbolFast(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD);
-/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
-
-
-/* *****************************************
-*  Implementation of inlined functions
-*******************************************/
-/* decompression */
-
-typedef struct {
-    U16 tableLog;
-    U16 fastMode;
-} FSEv05_DTableHeader;   /* sizeof U32 */
-
-typedef struct
-{
-    unsigned short newState;
-    unsigned char  symbol;
-    unsigned char  nbBits;
-} FSEv05_decode_t;   /* size == U32 */
-
-MEM_STATIC void FSEv05_initDState(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD, const FSEv05_DTable* dt)
-{
-    const void* ptr = dt;
-    const FSEv05_DTableHeader* const DTableH = (const FSEv05_DTableHeader*)ptr;
-    DStatePtr->state = BITv05_readBits(bitD, DTableH->tableLog);
-    BITv05_reloadDStream(bitD);
-    DStatePtr->table = dt + 1;
-}
-
-MEM_STATIC size_t FSEv05_getStateValue(FSEv05_DState_t* DStatePtr)
-{
-    return DStatePtr->state;
-}
-
-MEM_STATIC BYTE FSEv05_peakSymbol(FSEv05_DState_t* DStatePtr)
-{
-    const FSEv05_decode_t DInfo = ((const FSEv05_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    return DInfo.symbol;
-}
-
-MEM_STATIC BYTE FSEv05_decodeSymbol(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD)
-{
-    const FSEv05_decode_t DInfo = ((const FSEv05_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    const U32  nbBits = DInfo.nbBits;
-    BYTE symbol = DInfo.symbol;
-    size_t lowBits = BITv05_readBits(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-MEM_STATIC BYTE FSEv05_decodeSymbolFast(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD)
-{
-    const FSEv05_decode_t DInfo = ((const FSEv05_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    const U32 nbBits = DInfo.nbBits;
-    BYTE symbol = DInfo.symbol;
-    size_t lowBits = BITv05_readBitsFast(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-MEM_STATIC unsigned FSEv05_endOfDState(const FSEv05_DState_t* DStatePtr)
-{
-    return DStatePtr->state == 0;
-}
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* FSEv05_STATIC_H */
-/* ******************************************************************
-   FSEv05 : Finite State Entropy coder
-   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 :
-    - FSEv05 source repository : https://github.com/Cyan4973/FiniteStateEntropy
-    - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-
-#ifndef FSEv05_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 FSEv05_MAX_MEMORY_USAGE 14
-#define FSEv05_DEFAULT_MEMORY_USAGE 13
-
-/*!FSEv05_MAX_SYMBOL_VALUE :
-*  Maximum symbol value authorized.
-*  Required for proper stack allocation */
-#define FSEv05_MAX_SYMBOL_VALUE 255
-
-
-/* **************************************************************
-*  template functions type & suffix
-****************************************************************/
-#define FSEv05_FUNCTION_TYPE BYTE
-#define FSEv05_FUNCTION_EXTENSION
-#define FSEv05_DECODE_TYPE FSEv05_decode_t
-
-
-#endif   /* !FSEv05_COMMONDEFS_ONLY */
-
-/* **************************************************************
-*  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) */
-
-
-
-/* ***************************************************************
-*  Constants
-*****************************************************************/
-#define FSEv05_MAX_TABLELOG  (FSEv05_MAX_MEMORY_USAGE-2)
-#define FSEv05_MAX_TABLESIZE (1U<<FSEv05_MAX_TABLELOG)
-#define FSEv05_MAXTABLESIZE_MASK (FSEv05_MAX_TABLESIZE-1)
-#define FSEv05_DEFAULT_TABLELOG (FSEv05_DEFAULT_MEMORY_USAGE-2)
-#define FSEv05_MIN_TABLELOG 5
-
-#define FSEv05_TABLELOG_ABSOLUTE_MAX 15
-#if FSEv05_MAX_TABLELOG > FSEv05_TABLELOG_ABSOLUTE_MAX
-#error "FSEv05_MAX_TABLELOG > FSEv05_TABLELOG_ABSOLUTE_MAX is not supported"
-#endif
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#define FSEv05_STATIC_ASSERT(c) { enum { FSEv05_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-
-
-/* **************************************************************
-*  Complex types
-****************************************************************/
-typedef U32 DTable_max_t[FSEv05_DTABLE_SIZE_U32(FSEv05_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 FSEv05_FUNCTION_EXTENSION
-#  error "FSEv05_FUNCTION_EXTENSION must be defined"
-#endif
-#ifndef FSEv05_FUNCTION_TYPE
-#  error "FSEv05_FUNCTION_TYPE must be defined"
-#endif
-
-/* Function names */
-#define FSEv05_CAT(X,Y) X##Y
-#define FSEv05_FUNCTION_NAME(X,Y) FSEv05_CAT(X,Y)
-#define FSEv05_TYPE_NAME(X,Y) FSEv05_CAT(X,Y)
-
-
-/* Function templates */
-static U32 FSEv05_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }
-
-
-
-FSEv05_DTable* FSEv05_createDTable (unsigned tableLog)
-{
-    if (tableLog > FSEv05_TABLELOG_ABSOLUTE_MAX) tableLog = FSEv05_TABLELOG_ABSOLUTE_MAX;
-    return (FSEv05_DTable*)malloc( FSEv05_DTABLE_SIZE_U32(tableLog) * sizeof (U32) );
-}
-
-void FSEv05_freeDTable (FSEv05_DTable* dt)
-{
-    free(dt);
-}
-
-size_t FSEv05_buildDTable(FSEv05_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
-{
-    FSEv05_DTableHeader DTableH;
-    void* const tdPtr = dt+1;   /* because dt is unsigned, 32-bits aligned on 32-bits */
-    FSEv05_DECODE_TYPE* const tableDecode = (FSEv05_DECODE_TYPE*) (tdPtr);
-    const U32 tableSize = 1 << tableLog;
-    const U32 tableMask = tableSize-1;
-    const U32 step = FSEv05_tableStep(tableSize);
-    U16 symbolNext[FSEv05_MAX_SYMBOL_VALUE+1];
-    U32 position = 0;
-    U32 highThreshold = tableSize-1;
-    const S16 largeLimit= (S16)(1 << (tableLog-1));
-    U32 noLarge = 1;
-    U32 s;
-
-    /* Sanity Checks */
-    if (maxSymbolValue > FSEv05_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
-    if (tableLog > FSEv05_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
-
-    /* Init, lay down lowprob symbols */
-    DTableH.tableLog = (U16)tableLog;
-    for (s=0; s<=maxSymbolValue; s++) {
-        if (normalizedCounter[s]==-1) {
-            tableDecode[highThreshold--].symbol = (FSEv05_FUNCTION_TYPE)s;
-            symbolNext[s] = 1;
-        } else {
-            if (normalizedCounter[s] >= largeLimit) noLarge=0;
-            symbolNext[s] = normalizedCounter[s];
-    }   }
-
-    /* Spread symbols */
-    for (s=0; s<=maxSymbolValue; s++) {
-        int i;
-        for (i=0; i<normalizedCounter[s]; i++) {
-            tableDecode[position].symbol = (FSEv05_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 i;
-        for (i=0; i<tableSize; i++) {
-            FSEv05_FUNCTION_TYPE symbol = (FSEv05_FUNCTION_TYPE)(tableDecode[i].symbol);
-            U16 nextState = symbolNext[symbol]++;
-            tableDecode[i].nbBits = (BYTE) (tableLog - BITv05_highbit32 ((U32)nextState) );
-            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize);
-    }   }
-
-    DTableH.fastMode = (U16)noLarge;
-    memcpy(dt, &DTableH, sizeof(DTableH));
-    return 0;
-}
-
-
-#ifndef FSEv05_COMMONDEFS_ONLY
-/*-****************************************
-*  FSEv05 helper functions
-******************************************/
-unsigned FSEv05_isError(size_t code) { return ERR_isError(code); }
-
-const char* FSEv05_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-
-/*-**************************************************************
-*  FSEv05 NCount encoding-decoding
-****************************************************************/
-static short FSEv05_abs(short a) { return a<0 ? -a : a; }
-
-
-size_t FSEv05_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) + FSEv05_MIN_TABLELOG;   /* extract tableLog */
-    if (nbBits > FSEv05_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;
-        }
-        {
-            const short 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 -= FSEv05_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);
-    }   }
-    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;
-}
-
-
-
-/*-*******************************************************
-*  Decompression (Byte symbols)
-*********************************************************/
-size_t FSEv05_buildDTable_rle (FSEv05_DTable* dt, BYTE symbolValue)
-{
-    void* ptr = dt;
-    FSEv05_DTableHeader* const DTableH = (FSEv05_DTableHeader*)ptr;
-    void* dPtr = dt + 1;
-    FSEv05_decode_t* const cell = (FSEv05_decode_t*)dPtr;
-
-    DTableH->tableLog = 0;
-    DTableH->fastMode = 0;
-
-    cell->newState = 0;
-    cell->symbol = symbolValue;
-    cell->nbBits = 0;
-
-    return 0;
-}
-
-
-size_t FSEv05_buildDTable_raw (FSEv05_DTable* dt, unsigned nbBits)
-{
-    void* ptr = dt;
-    FSEv05_DTableHeader* const DTableH = (FSEv05_DTableHeader*)ptr;
-    void* dPtr = dt + 1;
-    FSEv05_decode_t* const dinfo = (FSEv05_decode_t*)dPtr;
-    const unsigned tableSize = 1 << nbBits;
-    const unsigned tableMask = tableSize - 1;
-    const unsigned maxSymbolValue = tableMask;
-    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<=maxSymbolValue; s++) {
-        dinfo[s].newState = 0;
-        dinfo[s].symbol = (BYTE)s;
-        dinfo[s].nbBits = (BYTE)nbBits;
-    }
-
-    return 0;
-}
-
-FORCE_INLINE size_t FSEv05_decompress_usingDTable_generic(
-          void* dst, size_t maxDstSize,
-    const void* cSrc, size_t cSrcSize,
-    const FSEv05_DTable* dt, const unsigned fast)
-{
-    BYTE* const ostart = (BYTE*) dst;
-    BYTE* op = ostart;
-    BYTE* const omax = op + maxDstSize;
-    BYTE* const olimit = omax-3;
-
-    BITv05_DStream_t bitD;
-    FSEv05_DState_t state1;
-    FSEv05_DState_t state2;
-    size_t errorCode;
-
-    /* Init */
-    errorCode = BITv05_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */
-    if (FSEv05_isError(errorCode)) return errorCode;
-
-    FSEv05_initDState(&state1, &bitD, dt);
-    FSEv05_initDState(&state2, &bitD, dt);
-
-#define FSEv05_GETSYMBOL(statePtr) fast ? FSEv05_decodeSymbolFast(statePtr, &bitD) : FSEv05_decodeSymbol(statePtr, &bitD)
-
-    /* 4 symbols per loop */
-    for ( ; (BITv05_reloadDStream(&bitD)==BITv05_DStream_unfinished) && (op<olimit) ; op+=4) {
-        op[0] = FSEv05_GETSYMBOL(&state1);
-
-        if (FSEv05_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            BITv05_reloadDStream(&bitD);
-
-        op[1] = FSEv05_GETSYMBOL(&state2);
-
-        if (FSEv05_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            { if (BITv05_reloadDStream(&bitD) > BITv05_DStream_unfinished) { op+=2; break; } }
-
-        op[2] = FSEv05_GETSYMBOL(&state1);
-
-        if (FSEv05_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            BITv05_reloadDStream(&bitD);
-
-        op[3] = FSEv05_GETSYMBOL(&state2);
-    }
-
-    /* tail */
-    /* note : BITv05_reloadDStream(&bitD) >= FSEv05_DStream_partiallyFilled; Ends at exactly BITv05_DStream_completed */
-    while (1) {
-        if ( (BITv05_reloadDStream(&bitD)>BITv05_DStream_completed) || (op==omax) || (BITv05_endOfDStream(&bitD) && (fast || FSEv05_endOfDState(&state1))) )
-            break;
-
-        *op++ = FSEv05_GETSYMBOL(&state1);
-
-        if ( (BITv05_reloadDStream(&bitD)>BITv05_DStream_completed) || (op==omax) || (BITv05_endOfDStream(&bitD) && (fast || FSEv05_endOfDState(&state2))) )
-            break;
-
-        *op++ = FSEv05_GETSYMBOL(&state2);
-    }
-
-    /* end ? */
-    if (BITv05_endOfDStream(&bitD) && FSEv05_endOfDState(&state1) && FSEv05_endOfDState(&state2))
-        return op-ostart;
-
-    if (op==omax) return ERROR(dstSize_tooSmall);   /* dst buffer is full, but cSrc unfinished */
-
-    return ERROR(corruption_detected);
-}
-
-
-size_t FSEv05_decompress_usingDTable(void* dst, size_t originalSize,
-                            const void* cSrc, size_t cSrcSize,
-                            const FSEv05_DTable* dt)
-{
-    const void* ptr = dt;
-    const FSEv05_DTableHeader* DTableH = (const FSEv05_DTableHeader*)ptr;
-    const U32 fastMode = DTableH->fastMode;
-
-    /* select fast mode (static) */
-    if (fastMode) return FSEv05_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
-    return FSEv05_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
-}
-
-
-size_t FSEv05_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[FSEv05_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 = FSEv05_MAX_SYMBOL_VALUE;
-    size_t errorCode;
-
-    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */
-
-    /* normal FSEv05 decoding mode */
-    errorCode = FSEv05_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
-    if (FSEv05_isError(errorCode)) return errorCode;
-    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */
-    ip += errorCode;
-    cSrcSize -= errorCode;
-
-    errorCode = FSEv05_buildDTable (dt, counting, maxSymbolValue, tableLog);
-    if (FSEv05_isError(errorCode)) return errorCode;
-
-    /* always return, even if it is an error code */
-    return FSEv05_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);
-}
-
-
-
-#endif   /* FSEv05_COMMONDEFS_ONLY */
-/* ******************************************************************
-   Huff0 : 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 HUFF0_H
-#define HUFF0_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-
-/* ****************************************
-*  Huff0 simple functions
-******************************************/
-size_t HUFv05_decompress(void* dst,  size_t dstSize,
-                const void* cSrc, size_t cSrcSize);
-/*!
-HUFv05_decompress():
-    Decompress Huff0 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 FSEv05, HUFv05_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 HUFv05_isError()
-*/
-
-
-/* ****************************************
-*  Tool functions
-******************************************/
-/* Error Management */
-unsigned    HUFv05_isError(size_t code);        /* tells if a return value is an error code */
-const char* HUFv05_getErrorName(size_t code);   /* provides error code string (useful for debugging) */
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif   /* HUF0_H */
-/* ******************************************************************
-   Huff0 : 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 HUF0_STATIC_H
-#define HUF0_STATIC_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-
-/* ****************************************
-*  Static allocation
-******************************************/
-/* static allocation of Huff0's DTable */
-#define HUFv05_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog))
-#define HUFv05_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
-        unsigned short DTable[HUFv05_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
-#define HUFv05_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \
-        unsigned int DTable[HUFv05_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
-#define HUFv05_CREATE_STATIC_DTABLEX6(DTable, maxTableLog) \
-        unsigned int DTable[HUFv05_DTABLE_SIZE(maxTableLog) * 3 / 2] = { maxTableLog }
-
-
-/* ****************************************
-*  Advanced decompression functions
-******************************************/
-size_t HUFv05_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
-size_t HUFv05_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */
-
-
-/* ****************************************
-*  Huff0 detailed API
-******************************************/
-/*!
-HUFv05_decompress() does the following:
-1. select the decompression algorithm (X2, X4, X6) based on pre-computed heuristics
-2. build Huffman table from save, using HUFv05_readDTableXn()
-3. decode 1 or 4 segments in parallel using HUFv05_decompressSXn_usingDTable
-*/
-size_t HUFv05_readDTableX2 (unsigned short* DTable, const void* src, size_t srcSize);
-size_t HUFv05_readDTableX4 (unsigned* DTable, const void* src, size_t srcSize);
-
-size_t HUFv05_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable);
-size_t HUFv05_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable);
-
-
-/* single stream variants */
-
-size_t HUFv05_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
-size_t HUFv05_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */
-
-size_t HUFv05_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable);
-size_t HUFv05_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable);
-
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* HUF0_STATIC_H */
-/* ******************************************************************
-   Huff0 : Huffman coder, part of New Generation Entropy library
-   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 :
-    - FSEv05+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy
-    - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-
-/* **************************************************************
-*  Compiler specifics
-****************************************************************/
-#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-/* inline is defined */
-#elif defined(_MSC_VER)
-#  define inline __inline
-#else
-#  define inline /* disable inline */
-#endif
-
-
-#ifdef _MSC_VER    /* Visual Studio */
-#  define FORCE_INLINE static __forceinline
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#else
-#  ifdef __GNUC__
-#    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) */
-
-
-/* **************************************************************
-*  Constants
-****************************************************************/
-#define HUFv05_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUFv05_MAX_TABLELOG. Beyond that value, code does not work */
-#define HUFv05_MAX_TABLELOG  12           /* max configured tableLog (for static allocation); can be modified up to HUFv05_ABSOLUTEMAX_TABLELOG */
-#define HUFv05_DEFAULT_TABLELOG  HUFv05_MAX_TABLELOG   /* tableLog by default, when not specified */
-#define HUFv05_MAX_SYMBOL_VALUE 255
-#if (HUFv05_MAX_TABLELOG > HUFv05_ABSOLUTEMAX_TABLELOG)
-#  error "HUFv05_MAX_TABLELOG is too large !"
-#endif
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-unsigned HUFv05_isError(size_t code) { return ERR_isError(code); }
-const char* HUFv05_getErrorName(size_t code) { return ERR_getErrorName(code); }
-#define HUFv05_STATIC_ASSERT(c) { enum { HUFv05_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-
-
-/* *******************************************************
-*  Huff0 : Huffman block decompression
-*********************************************************/
-typedef struct { BYTE byte; BYTE nbBits; } HUFv05_DEltX2;   /* single-symbol decoding */
-
-typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUFv05_DEltX4;  /* double-symbols decoding */
-
-typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
-
-/*! HUFv05_readStats
-    Read compact Huffman tree, saved by HUFv05_writeCTable
-    @huffWeight : destination buffer
-    @return : size read from `src`
-*/
-static size_t HUFv05_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                            U32* nbSymbolsPtr, U32* tableLogPtr,
-                            const void* src, size_t srcSize)
-{
-    U32 weightTotal;
-    U32 tableLog;
-    const BYTE* ip = (const BYTE*) src;
-    size_t iSize = ip[0];
-    size_t oSize;
-    U32 n;
-
-    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */
-
-    if (iSize >= 128)  { /* special header */
-        if (iSize >= (242)) {  /* RLE */
-            static int 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;
-            for (n=0; n<oSize; n+=2) {
-                huffWeight[n]   = ip[n/2] >> 4;
-                huffWeight[n+1] = ip[n/2] & 15;
-    }   }   }
-    else  {   /* header compressed with FSEv05 (normal case) */
-        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
-        oSize = FSEv05_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */
-        if (FSEv05_isError(oSize)) return oSize;
-    }
-
-    /* collect weight stats */
-    memset(rankStats, 0, (HUFv05_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32));
-    weightTotal = 0;
-    for (n=0; n<oSize; n++) {
-        if (huffWeight[n] >= HUFv05_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) */
-    tableLog = BITv05_highbit32(weightTotal) + 1;
-    if (tableLog > HUFv05_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
-    {   /* determine last weight */
-        U32 total = 1 << tableLog;
-        U32 rest = total - weightTotal;
-        U32 verif = 1 << BITv05_highbit32(rest);
-        U32 lastWeight = BITv05_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);
-    *tableLogPtr = tableLog;
-    return iSize+1;
-}
-
-
-/*-***************************/
-/*  single-symbol decoding   */
-/*-***************************/
-
-size_t HUFv05_readDTableX2 (U16* DTable, const void* src, size_t srcSize)
-{
-    BYTE huffWeight[HUFv05_MAX_SYMBOL_VALUE + 1];
-    U32 rankVal[HUFv05_ABSOLUTEMAX_TABLELOG + 1];   /* large enough for values from 0 to 16 */
-    U32 tableLog = 0;
-    size_t iSize;
-    U32 nbSymbols = 0;
-    U32 n;
-    U32 nextRankStart;
-    void* const dtPtr = DTable + 1;
-    HUFv05_DEltX2* const dt = (HUFv05_DEltX2*)dtPtr;
-
-    HUFv05_STATIC_ASSERT(sizeof(HUFv05_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */
-    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUFv05_readStats(huffWeight, HUFv05_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
-    if (HUFv05_isError(iSize)) return iSize;
-
-    /* check result */
-    if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge);   /* DTable is too small */
-    DTable[0] = (U16)tableLog;   /* maybe should separate sizeof allocated DTable, from used size of DTable, in case of re-use */
-
-    /* Prepare ranks */
-    nextRankStart = 0;
-    for (n=1; n<=tableLog; n++) {
-        U32 current = nextRankStart;
-        nextRankStart += (rankVal[n] << (n-1));
-        rankVal[n] = current;
-    }
-
-    /* fill DTable */
-    for (n=0; n<nbSymbols; n++) {
-        const U32 w = huffWeight[n];
-        const U32 length = (1 << w) >> 1;
-        U32 i;
-        HUFv05_DEltX2 D;
-        D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);
-        for (i = rankVal[w]; i < rankVal[w] + length; i++)
-            dt[i] = D;
-        rankVal[w] += length;
-    }
-
-    return iSize;
-}
-
-static BYTE HUFv05_decodeSymbolX2(BITv05_DStream_t* Dstream, const HUFv05_DEltX2* dt, const U32 dtLog)
-{
-        const size_t val = BITv05_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
-        const BYTE c = dt[val].byte;
-        BITv05_skipBits(Dstream, dt[val].nbBits);
-        return c;
-}
-
-#define HUFv05_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
-    *ptr++ = HUFv05_decodeSymbolX2(DStreamPtr, dt, dtLog)
-
-#define HUFv05_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
-    if (MEM_64bits() || (HUFv05_MAX_TABLELOG<=12)) \
-        HUFv05_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
-
-#define HUFv05_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
-    if (MEM_64bits()) \
-        HUFv05_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
-
-static inline size_t HUFv05_decodeStreamX2(BYTE* p, BITv05_DStream_t* const bitDPtr, BYTE* const pEnd, const HUFv05_DEltX2* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 4 symbols at a time */
-    while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p <= pEnd-4)) {
-        HUFv05_DECODE_SYMBOLX2_2(p, bitDPtr);
-        HUFv05_DECODE_SYMBOLX2_1(p, bitDPtr);
-        HUFv05_DECODE_SYMBOLX2_2(p, bitDPtr);
-        HUFv05_DECODE_SYMBOLX2_0(p, bitDPtr);
-    }
-
-    /* closer to the end */
-    while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p < pEnd))
-        HUFv05_DECODE_SYMBOLX2_0(p, bitDPtr);
-
-    /* no more data to retrieve from bitstream, hence no need to reload */
-    while (p < pEnd)
-        HUFv05_DECODE_SYMBOLX2_0(p, bitDPtr);
-
-    return pEnd-pStart;
-}
-
-size_t HUFv05_decompress1X2_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const U16* DTable)
-{
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + dstSize;
-    size_t errorCode;
-    const U32 dtLog = DTable[0];
-    const void* dtPtr = DTable;
-    const HUFv05_DEltX2* const dt = ((const HUFv05_DEltX2*)dtPtr)+1;
-    BITv05_DStream_t bitD;
-    errorCode = BITv05_initDStream(&bitD, cSrc, cSrcSize);
-    if (HUFv05_isError(errorCode)) return errorCode;
-
-    HUFv05_decodeStreamX2(op, &bitD, oend, dt, dtLog);
-
-    /* check */
-    if (!BITv05_endOfDStream(&bitD)) return ERROR(corruption_detected);
-
-    return dstSize;
-}
-
-size_t HUFv05_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUFv05_CREATE_STATIC_DTABLEX2(DTable, HUFv05_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-    size_t errorCode;
-
-    errorCode = HUFv05_readDTableX2 (DTable, cSrc, cSrcSize);
-    if (HUFv05_isError(errorCode)) return errorCode;
-    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += errorCode;
-    cSrcSize -= errorCode;
-
-    return HUFv05_decompress1X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
-}
-
-
-size_t HUFv05_decompress4X2_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const U16* DTable)
-{
-    const BYTE* const istart = (const BYTE*) cSrc;
-    BYTE* const ostart = (BYTE*) dst;
-    BYTE* const oend = ostart + dstSize;
-    const void* const dtPtr = DTable;
-    const HUFv05_DEltX2* const dt = ((const HUFv05_DEltX2*)dtPtr) +1;
-    const U32 dtLog = DTable[0];
-    size_t errorCode;
-
-    /* Init */
-    BITv05_DStream_t bitD1;
-    BITv05_DStream_t bitD2;
-    BITv05_DStream_t bitD3;
-    BITv05_DStream_t bitD4;
-    const size_t length1 = MEM_readLE16(istart);
-    const size_t length2 = MEM_readLE16(istart+2);
-    const size_t length3 = MEM_readLE16(istart+4);
-    size_t length4;
-    const BYTE* const istart1 = istart + 6;  /* jumpTable */
-    const BYTE* const istart2 = istart1 + length1;
-    const BYTE* const istart3 = istart2 + length2;
-    const BYTE* const istart4 = istart3 + length3;
-    const size_t segmentSize = (dstSize+3) / 4;
-    BYTE* const opStart2 = ostart + segmentSize;
-    BYTE* const opStart3 = opStart2 + segmentSize;
-    BYTE* const opStart4 = opStart3 + segmentSize;
-    BYTE* op1 = ostart;
-    BYTE* op2 = opStart2;
-    BYTE* op3 = opStart3;
-    BYTE* op4 = opStart4;
-    U32 endSignal;
-
+/* ****************************************************************** 
+   zstd_v05.c 
+   Decompression module for ZSTD v0.5 legacy format 
+   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 : 
+    - Homepage : http://www.zstd.net/ 
+****************************************************************** */ 
+ 
+/*- Dependencies -*/ 
+#include "zstd_v05.h" 
+ 
+ 
+/* ****************************************************************** 
+   mem.h 
+   low-level memory access routines 
+   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 : 
+    - FSEv05 source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef MEM_H_MODULE 
+#define MEM_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/*-**************************************** 
+*  Dependencies 
+******************************************/ 
+#include <stddef.h>    /* size_t, ptrdiff_t */ 
+#include <string.h>    /* memcpy */ 
+ 
+ 
+/*-**************************************** 
+*  Compiler specifics 
+******************************************/ 
+#if defined(__GNUC__) 
+#  define MEM_STATIC static __attribute__((unused)) 
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+#  define MEM_STATIC static inline 
+#elif defined(_MSC_VER) 
+#  define MEM_STATIC static __inline 
+#else 
+#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */ 
+#endif 
+ 
+ 
+/*-************************************************************** 
+*  Basic Types 
+*****************************************************************/ 
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+# include <stdint.h> 
+  typedef  uint8_t BYTE; 
+  typedef uint16_t U16; 
+  typedef  int16_t S16; 
+  typedef uint32_t U32; 
+  typedef  int32_t S32; 
+  typedef uint64_t U64; 
+  typedef  int64_t S64; 
+#else 
+  typedef unsigned char       BYTE; 
+  typedef unsigned short      U16; 
+  typedef   signed short      S16; 
+  typedef unsigned int        U32; 
+  typedef   signed int        S32; 
+  typedef unsigned long long  U64; 
+  typedef   signed long long  S64; 
+#endif 
+ 
+ 
+/*-************************************************************** 
+*  Memory I/O 
+*****************************************************************/ 
+/* MEM_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 is portable but violate C standard. 
+ *            It can generate buggy code on targets depending on alignment. 
+ *            In some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6) 
+ * See http://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details. 
+ * Prefer these methods in priority order (0 > 1 > 2) 
+ */ 
+#ifndef MEM_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 MEM_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 MEM_FORCE_MEMORY_ACCESS 1 
+#  endif 
+#endif 
+ 
+MEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; } 
+MEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; } 
+ 
+MEM_STATIC unsigned MEM_isLittleEndian(void) 
+{ 
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */ 
+    return one.c[0]; 
+} 
+ 
+#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2) 
+ 
+/* violates C standard, by lying on structure alignment. 
+Only use if no other choice to achieve best performance on target platform */ 
+MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; } 
+MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; } 
+MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; } 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; } 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; } 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; } 
+ 
+#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_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 { U16 u16; U32 u32; U64 u64; size_t st; } __attribute__((packed)) unalign; 
+ 
+MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; } 
+MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; } 
+MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; } 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; } 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; } 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign*)memPtr)->u64 = value; } 
+ 
+#else 
+ 
+/* default method, safe and standard. 
+   can sometimes prove slower */ 
+ 
+MEM_STATIC U16 MEM_read16(const void* memPtr) 
+{ 
+    U16 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC U32 MEM_read32(const void* memPtr) 
+{ 
+    U32 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC U64 MEM_read64(const void* memPtr) 
+{ 
+    U64 val; memcpy(&val, memPtr, sizeof(val)); return val; 
+} 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) 
+{ 
+    memcpy(memPtr, &value, sizeof(value)); 
+} 
+ 
+#endif /* MEM_FORCE_MEMORY_ACCESS */ 
+ 
+ 
+MEM_STATIC U16 MEM_readLE16(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read16(memPtr); 
+    else { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U16)(p[0] + (p[1]<<8)); 
+    } 
+} 
+ 
+MEM_STATIC void MEM_writeLE16(void* memPtr, U16 val) 
+{ 
+    if (MEM_isLittleEndian()) { 
+        MEM_write16(memPtr, val); 
+    } else { 
+        BYTE* p = (BYTE*)memPtr; 
+        p[0] = (BYTE)val; 
+        p[1] = (BYTE)(val>>8); 
+    } 
+} 
+ 
+MEM_STATIC U32 MEM_readLE32(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read32(memPtr); 
+    else { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24)); 
+    } 
+} 
+ 
+MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32) 
+{ 
+    if (MEM_isLittleEndian()) { 
+        MEM_write32(memPtr, val32); 
+    } else { 
+        BYTE* p = (BYTE*)memPtr; 
+        p[0] = (BYTE)val32; 
+        p[1] = (BYTE)(val32>>8); 
+        p[2] = (BYTE)(val32>>16); 
+        p[3] = (BYTE)(val32>>24); 
+    } 
+} 
+ 
+MEM_STATIC U64 MEM_readLE64(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read64(memPtr); 
+    else { 
+        const BYTE* p = (const BYTE*)memPtr; 
+        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24) 
+                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56)); 
+    } 
+} 
+ 
+MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64) 
+{ 
+    if (MEM_isLittleEndian()) { 
+        MEM_write64(memPtr, val64); 
+    } else { 
+        BYTE* p = (BYTE*)memPtr; 
+        p[0] = (BYTE)val64; 
+        p[1] = (BYTE)(val64>>8); 
+        p[2] = (BYTE)(val64>>16); 
+        p[3] = (BYTE)(val64>>24); 
+        p[4] = (BYTE)(val64>>32); 
+        p[5] = (BYTE)(val64>>40); 
+        p[6] = (BYTE)(val64>>48); 
+        p[7] = (BYTE)(val64>>56); 
+    } 
+} 
+ 
+MEM_STATIC size_t MEM_readLEST(const void* memPtr) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_readLE32(memPtr); 
+    else 
+        return (size_t)MEM_readLE64(memPtr); 
+} 
+ 
+MEM_STATIC void MEM_writeLEST(void* memPtr, size_t val) 
+{ 
+    if (MEM_32bits()) 
+        MEM_writeLE32(memPtr, (U32)val); 
+    else 
+        MEM_writeLE64(memPtr, (U64)val); 
+} 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* MEM_H_MODULE */ 
+ 
+/* ****************************************************************** 
+   Error codes list 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/zstd 
+****************************************************************** */ 
+#ifndef ERROR_PUBLIC_H_MODULE 
+#define ERROR_PUBLIC_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* **************************************** 
+*  error codes list 
+******************************************/ 
+typedef enum { 
+  ZSTDv05_error_no_error, 
+  ZSTDv05_error_GENERIC, 
+  ZSTDv05_error_prefix_unknown, 
+  ZSTDv05_error_frameParameter_unsupported, 
+  ZSTDv05_error_frameParameter_unsupportedBy32bits, 
+  ZSTDv05_error_init_missing, 
+  ZSTDv05_error_memory_allocation, 
+  ZSTDv05_error_stage_wrong, 
+  ZSTDv05_error_dstSize_tooSmall, 
+  ZSTDv05_error_srcSize_wrong, 
+  ZSTDv05_error_corruption_detected, 
+  ZSTDv05_error_tableLog_tooLarge, 
+  ZSTDv05_error_maxSymbolValue_tooLarge, 
+  ZSTDv05_error_maxSymbolValue_tooSmall, 
+  ZSTDv05_error_dictionary_corrupted, 
+  ZSTDv05_error_maxCode 
+} ZSTDv05_ErrorCode; 
+ 
+/* note : functions provide error codes in reverse negative order, 
+          so compare with (size_t)(0-enum) */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* ERROR_PUBLIC_H_MODULE */ 
+ 
+ 
+/* 
+    zstd - standard compression library 
+    Header File for static linking only 
+    Copyright (C) 2014-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 
+*/ 
+#ifndef ZSTD_STATIC_H 
+#define ZSTD_STATIC_H 
+ 
+/* The prototypes defined within this file are considered experimental. 
+ * They should not be used in the context DLL as they may change in the future. 
+ * Prefer static linking if you need them, to control breaking version changes issues. 
+ */ 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+ 
+/*-************************************* 
+*  Types 
+***************************************/ 
+#define ZSTDv05_WINDOWLOG_ABSOLUTEMIN 11 
+ 
+ 
+/*-************************************* 
+*  Advanced functions 
+***************************************/ 
+/*- Advanced Decompression functions -*/ 
+ 
+/*! ZSTDv05_decompress_usingPreparedDCtx() : 
+*   Same as ZSTDv05_decompress_usingDict, but using a reference context `preparedDCtx`, where dictionary has been loaded. 
+*   It avoids reloading the dictionary each time. 
+*   `preparedDCtx` must have been properly initialized using ZSTDv05_decompressBegin_usingDict(). 
+*   Requires 2 contexts : 1 for reference, which will not be modified, and 1 to run the decompression operation */ 
+size_t ZSTDv05_decompress_usingPreparedDCtx( 
+                                             ZSTDv05_DCtx* dctx, const ZSTDv05_DCtx* preparedDCtx, 
+                                             void* dst, size_t dstCapacity, 
+                                       const void* src, size_t srcSize); 
+ 
+ 
+/* ************************************** 
+*  Streaming functions (direct mode) 
+****************************************/ 
+size_t ZSTDv05_decompressBegin(ZSTDv05_DCtx* dctx); 
+size_t ZSTDv05_decompressBegin_usingDict(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize); 
+void   ZSTDv05_copyDCtx(ZSTDv05_DCtx* dctx, const ZSTDv05_DCtx* preparedDCtx); 
+ 
+size_t ZSTDv05_getFrameParams(ZSTDv05_parameters* params, const void* src, size_t srcSize); 
+ 
+size_t ZSTDv05_nextSrcSizeToDecompress(ZSTDv05_DCtx* dctx); 
+size_t ZSTDv05_decompressContinue(ZSTDv05_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); 
+ 
+/* 
+  Streaming decompression, direct mode (bufferless) 
+ 
+  A ZSTDv05_DCtx object is required to track streaming operations. 
+  Use ZSTDv05_createDCtx() / ZSTDv05_freeDCtx() to manage it. 
+  A ZSTDv05_DCtx object can be re-used multiple times. 
+ 
+  First typical operation is to retrieve frame parameters, using ZSTDv05_getFrameParams(). 
+  This operation is independent, and just needs enough input data to properly decode the frame header. 
+  Objective is to retrieve *params.windowlog, to know minimum amount of memory required during decoding. 
+  Result : 0 when successful, it means the ZSTDv05_parameters structure has been filled. 
+           >0 : means there is not enough data into src. Provides the expected size to successfully decode header. 
+           errorCode, which can be tested using ZSTDv05_isError() 
+ 
+  Start decompression, with ZSTDv05_decompressBegin() or ZSTDv05_decompressBegin_usingDict() 
+  Alternatively, you can copy a prepared context, using ZSTDv05_copyDCtx() 
+ 
+  Then use ZSTDv05_nextSrcSizeToDecompress() and ZSTDv05_decompressContinue() alternatively. 
+  ZSTDv05_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTDv05_decompressContinue(). 
+  ZSTDv05_decompressContinue() requires this exact amount of bytes, or it will fail. 
+  ZSTDv05_decompressContinue() needs previous data blocks during decompression, up to (1 << windowlog). 
+  They should preferably be located contiguously, prior to current block. Alternatively, a round buffer is also possible. 
+ 
+  @result of ZSTDv05_decompressContinue() is the number of bytes regenerated within 'dst'. 
+  It can be zero, which is not an error; it just means ZSTDv05_decompressContinue() has decoded some header. 
+ 
+  A frame is fully decoded when ZSTDv05_nextSrcSizeToDecompress() returns zero. 
+  Context can then be reset to start a new decompression. 
+*/ 
+ 
+ 
+/* ************************************** 
+*  Block functions 
+****************************************/ 
+/*! Block functions produce and decode raw zstd blocks, without frame metadata. 
+    User will have to take in charge required information to regenerate data, such as block sizes. 
+ 
+    A few rules to respect : 
+    - Uncompressed block size must be <= 128 KB 
+    - Compressing or decompressing requires a context structure 
+      + Use ZSTDv05_createCCtx() and ZSTDv05_createDCtx() 
+    - It is necessary to init context before starting 
+      + compression : ZSTDv05_compressBegin() 
+      + decompression : ZSTDv05_decompressBegin() 
+      + variants _usingDict() are also allowed 
+      + copyCCtx() and copyDCtx() work too 
+    - When a block is considered not compressible enough, ZSTDv05_compressBlock() result will be zero. 
+      In which case, nothing is produced into `dst`. 
+      + User must test for such outcome and deal directly with uncompressed data 
+      + ZSTDv05_decompressBlock() doesn't accept uncompressed data as input !! 
+*/ 
+ 
+size_t ZSTDv05_decompressBlock(ZSTDv05_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); 
+ 
+ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* ZSTDv05_STATIC_H */ 
+ 
+ 
+ 
+/* ****************************************************************** 
+   Error codes and messages 
+   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/zstd 
+****************************************************************** */ 
+/* Note : this module is expected to remain private, do not expose it */ 
+ 
+#ifndef ERROR_H_MODULE 
+#define ERROR_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+ 
+/* **************************************** 
+*  Compiler-specific 
+******************************************/ 
+#if defined(__GNUC__) 
+#  define ERR_STATIC static __attribute__((unused)) 
+#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+#  define ERR_STATIC static inline 
+#elif defined(_MSC_VER) 
+#  define ERR_STATIC static __inline 
+#else 
+#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */ 
+#endif 
+ 
+ 
+/*-**************************************** 
+*  Customization 
+******************************************/ 
+typedef ZSTDv05_ErrorCode ERR_enum; 
+#define PREFIX(name) ZSTDv05_error_##name 
+ 
+ 
+/*-**************************************** 
+*  Error codes handling 
+******************************************/ 
+#ifdef ERROR 
+#  undef ERROR   /* reported already defined on VS 2015 (Rich Geldreich) */ 
+#endif 
+#define ERROR(name) (size_t)-PREFIX(name) 
+ 
+ERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); } 
+ 
+ERR_STATIC ERR_enum ERR_getError(size_t code) { if (!ERR_isError(code)) return (ERR_enum)0; return (ERR_enum) (0-code); } 
+ 
+ 
+/*-**************************************** 
+*  Error Strings 
+******************************************/ 
+ 
+ERR_STATIC const char* ERR_getErrorName(size_t code) 
+{ 
+    static const char* notErrorCode = "Unspecified error code"; 
+    switch( ERR_getError(code) ) 
+    { 
+    case PREFIX(no_error): return "No error detected"; 
+    case PREFIX(GENERIC):  return "Error (generic)"; 
+    case PREFIX(prefix_unknown): return "Unknown frame descriptor"; 
+    case PREFIX(frameParameter_unsupported): return "Unsupported frame parameter"; 
+    case PREFIX(frameParameter_unsupportedBy32bits): return "Frame parameter unsupported in 32-bits mode"; 
+    case PREFIX(init_missing): return "Context should be init first"; 
+    case PREFIX(memory_allocation): return "Allocation error : not enough memory"; 
+    case PREFIX(stage_wrong): return "Operation not authorized at current processing stage"; 
+    case PREFIX(dstSize_tooSmall): return "Destination buffer is too small"; 
+    case PREFIX(srcSize_wrong): return "Src size incorrect"; 
+    case PREFIX(corruption_detected): return "Corrupted block detected"; 
+    case PREFIX(tableLog_tooLarge): return "tableLog requires too much memory"; 
+    case PREFIX(maxSymbolValue_tooLarge): return "Unsupported max possible Symbol Value : too large"; 
+    case PREFIX(maxSymbolValue_tooSmall): return "Specified maxSymbolValue is too small"; 
+    case PREFIX(dictionary_corrupted): return "Dictionary is corrupted"; 
+    case PREFIX(maxCode): 
+    default: return notErrorCode;   /* should be impossible, due to ERR_getError() */ 
+    } 
+} 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* ERROR_H_MODULE */ 
+/* 
+    zstd_internal - common functions to include 
+    Header File for include 
+    Copyright (C) 2014-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 source repository : https://github.com/Cyan4973/zstd 
+*/ 
+#ifndef ZSTD_CCOMMON_H_MODULE 
+#define ZSTD_CCOMMON_H_MODULE 
+ 
+ 
+ 
+/*-************************************* 
+*  Common macros 
+***************************************/ 
+#define MIN(a,b) ((a)<(b) ? (a) : (b)) 
+#define MAX(a,b) ((a)>(b) ? (a) : (b)) 
+ 
+ 
+/*-************************************* 
+*  Common constants 
+***************************************/ 
+#define ZSTDv05_DICT_MAGIC  0xEC30A435 
+ 
+#define KB *(1 <<10) 
+#define MB *(1 <<20) 
+#define GB *(1U<<30) 
+ 
+#define BLOCKSIZE (128 KB)                 /* define, for static allocation */ 
+ 
+static const size_t ZSTDv05_blockHeaderSize = 3; 
+static const size_t ZSTDv05_frameHeaderSize_min = 5; 
+#define ZSTDv05_frameHeaderSize_max 5         /* define, for static allocation */ 
+ 
+#define BITv057 128 
+#define BITv056  64 
+#define BITv055  32 
+#define BITv054  16 
+#define BITv051   2 
+#define BITv050   1 
+ 
+#define IS_HUFv05 0 
+#define IS_PCH 1 
+#define IS_RAW 2 
+#define IS_RLE 3 
+ 
+#define MINMATCH 4 
+#define REPCODE_STARTVALUE 1 
+ 
+#define Litbits  8 
+#define MLbits   7 
+#define LLbits   6 
+#define Offbits  5 
+#define MaxLit ((1<<Litbits) - 1) 
+#define MaxML  ((1<<MLbits) - 1) 
+#define MaxLL  ((1<<LLbits) - 1) 
+#define MaxOff ((1<<Offbits)- 1) 
+#define MLFSEv05Log   10 
+#define LLFSEv05Log   10 
+#define OffFSEv05Log   9 
+#define MaxSeq MAX(MaxLL, MaxML) 
+ 
+#define FSEv05_ENCODING_RAW     0 
+#define FSEv05_ENCODING_RLE     1 
+#define FSEv05_ENCODING_STATIC  2 
+#define FSEv05_ENCODING_DYNAMIC 3 
+ 
+ 
+#define HufLog 12 
+ 
+#define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */ 
+#define MIN_CBLOCK_SIZE (1 /*litCSize*/ + 1 /* RLE or RAW */ + MIN_SEQUENCES_SIZE /* nbSeq==0 */)   /* for a non-null block */ 
+ 
+#define WILDCOPY_OVERLENGTH 8 
+ 
+typedef enum { bt_compressed, bt_raw, bt_rle, bt_end } blockType_t; 
+ 
+ 
+/*-******************************************* 
+*  Shared functions to include for inlining 
+*********************************************/ 
+static void ZSTDv05_copy8(void* dst, const void* src) { memcpy(dst, src, 8); } 
+ 
+#define COPY8(d,s) { ZSTDv05_copy8(d,s); d+=8; s+=8; } 
+ 
+/*! ZSTDv05_wildcopy() : 
+*   custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0) */ 
+MEM_STATIC void ZSTDv05_wildcopy(void* dst, const void* src, size_t length) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + length; 
+    do 
+        COPY8(op, ip) 
+    while (op < oend); 
+} 
+ 
+MEM_STATIC unsigned ZSTDv05_highbit(U32 val) 
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
+    unsigned long r=0; 
+    _BitScanReverse(&r, val); 
+    return (unsigned)r; 
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* GCC Intrinsic */ 
+    return 31 - __builtin_clz(val); 
+#   else   /* Software version */ 
+    static const int DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 }; 
+    U32 v = val; 
+    int r; 
+    v |= v >> 1; 
+    v |= v >> 2; 
+    v |= v >> 4; 
+    v |= v >> 8; 
+    v |= v >> 16; 
+    r = DeBruijnClz[(U32)(v * 0x07C4ACDDU) >> 27]; 
+    return r; 
+#   endif 
+} 
+ 
+ 
+/*-******************************************* 
+*  Private interfaces 
+*********************************************/ 
+typedef struct { 
+    void* buffer; 
+    U32*  offsetStart; 
+    U32*  offset; 
+    BYTE* offCodeStart; 
+    BYTE* offCode; 
+    BYTE* litStart; 
+    BYTE* lit; 
+    BYTE* litLengthStart; 
+    BYTE* litLength; 
+    BYTE* matchLengthStart; 
+    BYTE* matchLength; 
+    BYTE* dumpsStart; 
+    BYTE* dumps; 
+    /* opt */ 
+    U32* matchLengthFreq; 
+    U32* litLengthFreq; 
+    U32* litFreq; 
+    U32* offCodeFreq; 
+    U32  matchLengthSum; 
+    U32  litLengthSum; 
+    U32  litSum; 
+    U32  offCodeSum; 
+} seqStore_t; 
+ 
+ 
+ 
+#endif   /* ZSTDv05_CCOMMON_H_MODULE */ 
+/* ****************************************************************** 
+   FSEv05 : Finite State Entropy coder 
+   header file 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef FSEv05_H 
+#define FSEv05_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* ***************************************** 
+*  Includes 
+******************************************/ 
+#include <stddef.h>    /* size_t, ptrdiff_t */ 
+ 
+ 
+/*-**************************************** 
+*  FSEv05 simple functions 
+******************************************/ 
+size_t FSEv05_decompress(void* dst,  size_t maxDstSize, 
+                const void* cSrc, size_t cSrcSize); 
+/*! 
+FSEv05_decompress(): 
+    Decompress FSEv05 data from buffer 'cSrc', of size 'cSrcSize', 
+    into already allocated destination buffer 'dst', of size 'maxDstSize'. 
+    return : size of regenerated data (<= maxDstSize) 
+             or an error code, which can be tested using FSEv05_isError() 
+ 
+    ** Important ** : FSEv05_decompress() doesn't decompress non-compressible nor RLE data !!! 
+    Why ? : making this distinction requires a header. 
+    Header management is intentionally delegated to the user layer, which can better manage special cases. 
+*/ 
+ 
+ 
+/* ***************************************** 
+*  Tool functions 
+******************************************/ 
+/* Error Management */ 
+unsigned    FSEv05_isError(size_t code);        /* tells if a return value is an error code */ 
+const char* FSEv05_getErrorName(size_t code);   /* provides error code string (useful for debugging) */ 
+ 
+ 
+ 
+ 
+/* ***************************************** 
+*  FSEv05 detailed API 
+******************************************/ 
+/* *** DECOMPRESSION *** */ 
+ 
+/*! 
+FSEv05_readNCount(): 
+   Read compactly saved 'normalizedCounter' from 'rBuffer'. 
+   return : size read from 'rBuffer' 
+            or an errorCode, which can be tested using FSEv05_isError() 
+            maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */ 
+size_t FSEv05_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize); 
+ 
+/*! 
+Constructor and Destructor of type FSEv05_DTable 
+    Note that its size depends on 'tableLog' */ 
+typedef unsigned FSEv05_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */ 
+FSEv05_DTable* FSEv05_createDTable(unsigned tableLog); 
+void        FSEv05_freeDTable(FSEv05_DTable* dt); 
+ 
+/*! 
+FSEv05_buildDTable(): 
+   Builds 'dt', which must be already allocated, using FSEv05_createDTable() 
+   return : 0, 
+            or an errorCode, which can be tested using FSEv05_isError() */ 
+size_t FSEv05_buildDTable (FSEv05_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog); 
+ 
+/*! 
+FSEv05_decompress_usingDTable(): 
+   Decompress compressed source @cSrc of size @cSrcSize using @dt 
+   into @dst which must be already allocated. 
+   return : size of regenerated data (necessarily <= @dstCapacity) 
+            or an errorCode, which can be tested using FSEv05_isError() */ 
+size_t FSEv05_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSEv05_DTable* dt); 
+ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* FSEv05_H */ 
+/* ****************************************************************** 
+   bitstream 
+   Part of FSEv05 library 
+   header file (to include) 
+   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 BITv05STREAM_H_MODULE 
+#define BITv05STREAM_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* 
+*  This API consists of small unitary functions, which highly benefit from being inlined. 
+*  Since link-time-optimization is not available for all compilers, 
+*  these functions are defined into a .h to be included. 
+*/ 
+ 
+ 
+ 
+/*-******************************************** 
+*  bitStream decoding API (read backward) 
+**********************************************/ 
+typedef struct 
+{ 
+    size_t   bitContainer; 
+    unsigned bitsConsumed; 
+    const char* ptr; 
+    const char* start; 
+} BITv05_DStream_t; 
+ 
+typedef enum { BITv05_DStream_unfinished = 0, 
+               BITv05_DStream_endOfBuffer = 1, 
+               BITv05_DStream_completed = 2, 
+               BITv05_DStream_overflow = 3 } BITv05_DStream_status;  /* result of BITv05_reloadDStream() */ 
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */ 
+ 
+MEM_STATIC size_t   BITv05_initDStream(BITv05_DStream_t* bitD, const void* srcBuffer, size_t srcSize); 
+MEM_STATIC size_t   BITv05_readBits(BITv05_DStream_t* bitD, unsigned nbBits); 
+MEM_STATIC BITv05_DStream_status BITv05_reloadDStream(BITv05_DStream_t* bitD); 
+MEM_STATIC unsigned BITv05_endOfDStream(const BITv05_DStream_t* bitD); 
+ 
+ 
+/*! 
+* Start by invoking BITv05_initDStream(). 
+* A chunk of the bitStream is then stored into a local register. 
+* 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 BITv05_reloadDStream() method. 
+* A reload guarantee a minimum of ((8*sizeof(size_t))-7) bits when its result is BITv05_DStream_unfinished. 
+* Otherwise, it can be less than that, so proceed accordingly. 
+* Checking if DStream has reached its end can be performed with BITv05_endOfDStream() 
+*/ 
+ 
+ 
+/*-**************************************** 
+*  unsafe API 
+******************************************/ 
+MEM_STATIC size_t BITv05_readBitsFast(BITv05_DStream_t* bitD, unsigned nbBits); 
+/* faster, but works only if nbBits >= 1 */ 
+ 
+ 
+ 
+/*-************************************************************** 
+*  Helper functions 
+****************************************************************/ 
+MEM_STATIC unsigned BITv05_highbit32 (register U32 val) 
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
+    unsigned long r=0; 
+    _BitScanReverse ( &r, val ); 
+    return (unsigned) r; 
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */ 
+    return 31 - __builtin_clz (val); 
+#   else   /* Software version */ 
+    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 }; 
+    U32 v = val; 
+    unsigned r; 
+    v |= v >> 1; 
+    v |= v >> 2; 
+    v |= v >> 4; 
+    v |= v >> 8; 
+    v |= v >> 16; 
+    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27]; 
+    return r; 
+#   endif 
+} 
+ 
+ 
+ 
+/*-******************************************************** 
+* bitStream decoding 
+**********************************************************/ 
+/*!BITv05_initDStream 
+*  Initialize a BITv05_DStream_t. 
+*  @bitD : a pointer to an already allocated BITv05_DStream_t structure 
+*  @srcBuffer must point at the beginning of a bitStream 
+*  @srcSize must be the exact size of the bitStream 
+*  @result : size of stream (== srcSize) or an errorCode if a problem is detected 
+*/ 
+MEM_STATIC size_t BITv05_initDStream(BITv05_DStream_t* bitD, const void* srcBuffer, size_t srcSize) 
+{ 
+    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); } 
+ 
+    if (srcSize >=  sizeof(size_t)) {  /* normal case */ 
+        U32 contain32; 
+        bitD->start = (const char*)srcBuffer; 
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t); 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr); 
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1]; 
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */ 
+        bitD->bitsConsumed = 8 - BITv05_highbit32(contain32); 
+    } else { 
+        U32 contain32; 
+        bitD->start = (const char*)srcBuffer; 
+        bitD->ptr   = bitD->start; 
+        bitD->bitContainer = *(const BYTE*)(bitD->start); 
+        switch(srcSize) 
+        { 
+            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16); 
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24); 
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32); 
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; 
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; 
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8; 
+            default:; 
+        } 
+        contain32 = ((const BYTE*)srcBuffer)[srcSize-1]; 
+        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */ 
+        bitD->bitsConsumed = 8 - BITv05_highbit32(contain32); 
+        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8; 
+    } 
+ 
+    return srcSize; 
+} 
+ 
+/*!BITv05_lookBits 
+ * Provides next n bits from local register 
+ * local register is not modified (bits are still present for next read/look) 
+ * On 32-bits, maxNbBits==25 
+ * On 64-bits, maxNbBits==57 
+ * @return : value extracted 
+ */ 
+MEM_STATIC size_t BITv05_lookBits(BITv05_DStream_t* bitD, U32 nbBits) 
+{ 
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1; 
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask); 
+} 
+ 
+/*! BITv05_lookBitsFast : 
+*   unsafe version; only works only if nbBits >= 1 */ 
+MEM_STATIC size_t BITv05_lookBitsFast(BITv05_DStream_t* bitD, U32 nbBits) 
+{ 
+    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1; 
+    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask); 
+} 
+ 
+MEM_STATIC void BITv05_skipBits(BITv05_DStream_t* bitD, U32 nbBits) 
+{ 
+    bitD->bitsConsumed += nbBits; 
+} 
+ 
+/*!BITv05_readBits 
+ * Read next n bits from local register. 
+ * pay attention to not read more than nbBits contained into local register. 
+ * @return : extracted value. 
+ */ 
+MEM_STATIC size_t BITv05_readBits(BITv05_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t value = BITv05_lookBits(bitD, nbBits); 
+    BITv05_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+/*!BITv05_readBitsFast : 
+*  unsafe version; only works only if nbBits >= 1 */ 
+MEM_STATIC size_t BITv05_readBitsFast(BITv05_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t value = BITv05_lookBitsFast(bitD, nbBits); 
+    BITv05_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+MEM_STATIC BITv05_DStream_status BITv05_reloadDStream(BITv05_DStream_t* bitD) 
+{ 
+	if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */ 
+		return BITv05_DStream_overflow; 
+ 
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) { 
+        bitD->ptr -= bitD->bitsConsumed >> 3; 
+        bitD->bitsConsumed &= 7; 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr); 
+        return BITv05_DStream_unfinished; 
+    } 
+    if (bitD->ptr == bitD->start) { 
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BITv05_DStream_endOfBuffer; 
+        return BITv05_DStream_completed; 
+    } 
+    { 
+        U32 nbBytes = bitD->bitsConsumed >> 3; 
+        BITv05_DStream_status result = BITv05_DStream_unfinished; 
+        if (bitD->ptr - nbBytes < bitD->start) { 
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */ 
+            result = BITv05_DStream_endOfBuffer; 
+        } 
+        bitD->ptr -= nbBytes; 
+        bitD->bitsConsumed -= nbBytes*8; 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */ 
+        return result; 
+    } 
+} 
+ 
+/*! BITv05_endOfDStream 
+*   @return Tells if DStream has reached its exact end 
+*/ 
+MEM_STATIC unsigned BITv05_endOfDStream(const BITv05_DStream_t* DStream) 
+{ 
+    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8)); 
+} 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* BITv05STREAM_H_MODULE */ 
+/* ****************************************************************** 
+   FSEv05 : Finite State Entropy coder 
+   header file for static linking (only) 
+   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 : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+   - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+#ifndef FSEv05_STATIC_H 
+#define FSEv05_STATIC_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+ 
+/* ***************************************** 
+*  Static allocation 
+*******************************************/ 
+/* It is possible to statically allocate FSEv05 CTable/DTable as a table of unsigned using below macros */ 
+#define FSEv05_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog)) 
+ 
+ 
+/* ***************************************** 
+*  FSEv05 advanced API 
+*******************************************/ 
+size_t FSEv05_buildDTable_raw (FSEv05_DTable* dt, unsigned nbBits); 
+/* build a fake FSEv05_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */ 
+ 
+size_t FSEv05_buildDTable_rle (FSEv05_DTable* dt, unsigned char symbolValue); 
+/* build a fake FSEv05_DTable, designed to always generate the same symbolValue */ 
+ 
+ 
+ 
+/* ***************************************** 
+*  FSEv05 symbol decompression API 
+*******************************************/ 
+typedef struct 
+{ 
+    size_t      state; 
+    const void* table;   /* precise table may vary, depending on U16 */ 
+} FSEv05_DState_t; 
+ 
+ 
+static void     FSEv05_initDState(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD, const FSEv05_DTable* dt); 
+ 
+static unsigned char FSEv05_decodeSymbol(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD); 
+ 
+static unsigned FSEv05_endOfDState(const FSEv05_DState_t* DStatePtr); 
+ 
+/*! 
+Let's now decompose FSEv05_decompress_usingDTable() into its unitary components. 
+You will decode FSEv05-encoded symbols from the bitStream, 
+and also any other bitFields you put in, **in reverse order**. 
+ 
+You will need a few variables to track your bitStream. They are : 
+ 
+BITv05_DStream_t DStream;    // Stream context 
+FSEv05_DState_t  DState;     // State context. Multiple ones are possible 
+FSEv05_DTable*   DTablePtr;  // Decoding table, provided by FSEv05_buildDTable() 
+ 
+The first thing to do is to init the bitStream. 
+    errorCode = BITv05_initDStream(&DStream, srcBuffer, srcSize); 
+ 
+You should then retrieve your initial state(s) 
+(in reverse flushing order if you have several ones) : 
+    errorCode = FSEv05_initDState(&DState, &DStream, DTablePtr); 
+ 
+You can then decode your data, symbol after symbol. 
+For information the maximum number of bits read by FSEv05_decodeSymbol() is 'tableLog'. 
+Keep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out). 
+    unsigned char symbol = FSEv05_decodeSymbol(&DState, &DStream); 
+ 
+You can retrieve any bitfield you eventually stored into the bitStream (in reverse order) 
+Note : maximum allowed nbBits is 25, for 32-bits compatibility 
+    size_t bitField = BITv05_readBits(&DStream, nbBits); 
+ 
+All above operations only read from local register (which size depends on size_t). 
+Refueling the register from memory is manually performed by the reload method. 
+    endSignal = FSEv05_reloadDStream(&DStream); 
+ 
+BITv05_reloadDStream() result tells if there is still some more data to read from DStream. 
+BITv05_DStream_unfinished : there is still some data left into the DStream. 
+BITv05_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled. 
+BITv05_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed. 
+BITv05_DStream_tooFar : Dstream went too far. Decompression result is corrupted. 
+ 
+When reaching end of buffer (BITv05_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop, 
+to properly detect the exact end of stream. 
+After each decoded symbol, check if DStream is fully consumed using this simple test : 
+    BITv05_reloadDStream(&DStream) >= BITv05_DStream_completed 
+ 
+When it's done, verify decompression is fully completed, by checking both DStream and the relevant states. 
+Checking if DStream has reached its end is performed by : 
+    BITv05_endOfDStream(&DStream); 
+Check also the states. There might be some symbols left there, if some high probability ones (>50%) are possible. 
+    FSEv05_endOfDState(&DState); 
+*/ 
+ 
+ 
+/* ***************************************** 
+*  FSEv05 unsafe API 
+*******************************************/ 
+static unsigned char FSEv05_decodeSymbolFast(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD); 
+/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */ 
+ 
+ 
+/* ***************************************** 
+*  Implementation of inlined functions 
+*******************************************/ 
+/* decompression */ 
+ 
+typedef struct { 
+    U16 tableLog; 
+    U16 fastMode; 
+} FSEv05_DTableHeader;   /* sizeof U32 */ 
+ 
+typedef struct 
+{ 
+    unsigned short newState; 
+    unsigned char  symbol; 
+    unsigned char  nbBits; 
+} FSEv05_decode_t;   /* size == U32 */ 
+ 
+MEM_STATIC void FSEv05_initDState(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD, const FSEv05_DTable* dt) 
+{ 
+    const void* ptr = dt; 
+    const FSEv05_DTableHeader* const DTableH = (const FSEv05_DTableHeader*)ptr; 
+    DStatePtr->state = BITv05_readBits(bitD, DTableH->tableLog); 
+    BITv05_reloadDStream(bitD); 
+    DStatePtr->table = dt + 1; 
+} 
+ 
+MEM_STATIC size_t FSEv05_getStateValue(FSEv05_DState_t* DStatePtr) 
+{ 
+    return DStatePtr->state; 
+} 
+ 
+MEM_STATIC BYTE FSEv05_peakSymbol(FSEv05_DState_t* DStatePtr) 
+{ 
+    const FSEv05_decode_t DInfo = ((const FSEv05_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    return DInfo.symbol; 
+} 
+ 
+MEM_STATIC BYTE FSEv05_decodeSymbol(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD) 
+{ 
+    const FSEv05_decode_t DInfo = ((const FSEv05_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    const U32  nbBits = DInfo.nbBits; 
+    BYTE symbol = DInfo.symbol; 
+    size_t lowBits = BITv05_readBits(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+MEM_STATIC BYTE FSEv05_decodeSymbolFast(FSEv05_DState_t* DStatePtr, BITv05_DStream_t* bitD) 
+{ 
+    const FSEv05_decode_t DInfo = ((const FSEv05_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    const U32 nbBits = DInfo.nbBits; 
+    BYTE symbol = DInfo.symbol; 
+    size_t lowBits = BITv05_readBitsFast(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+MEM_STATIC unsigned FSEv05_endOfDState(const FSEv05_DState_t* DStatePtr) 
+{ 
+    return DStatePtr->state == 0; 
+} 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* FSEv05_STATIC_H */ 
+/* ****************************************************************** 
+   FSEv05 : Finite State Entropy coder 
+   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 : 
+    - FSEv05 source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+ 
+#ifndef FSEv05_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 FSEv05_MAX_MEMORY_USAGE 14 
+#define FSEv05_DEFAULT_MEMORY_USAGE 13 
+ 
+/*!FSEv05_MAX_SYMBOL_VALUE : 
+*  Maximum symbol value authorized. 
+*  Required for proper stack allocation */ 
+#define FSEv05_MAX_SYMBOL_VALUE 255 
+ 
+ 
+/* ************************************************************** 
+*  template functions type & suffix 
+****************************************************************/ 
+#define FSEv05_FUNCTION_TYPE BYTE 
+#define FSEv05_FUNCTION_EXTENSION 
+#define FSEv05_DECODE_TYPE FSEv05_decode_t 
+ 
+ 
+#endif   /* !FSEv05_COMMONDEFS_ONLY */ 
+ 
+/* ************************************************************** 
+*  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) */ 
+ 
+ 
+ 
+/* *************************************************************** 
+*  Constants 
+*****************************************************************/ 
+#define FSEv05_MAX_TABLELOG  (FSEv05_MAX_MEMORY_USAGE-2) 
+#define FSEv05_MAX_TABLESIZE (1U<<FSEv05_MAX_TABLELOG) 
+#define FSEv05_MAXTABLESIZE_MASK (FSEv05_MAX_TABLESIZE-1) 
+#define FSEv05_DEFAULT_TABLELOG (FSEv05_DEFAULT_MEMORY_USAGE-2) 
+#define FSEv05_MIN_TABLELOG 5 
+ 
+#define FSEv05_TABLELOG_ABSOLUTE_MAX 15 
+#if FSEv05_MAX_TABLELOG > FSEv05_TABLELOG_ABSOLUTE_MAX 
+#error "FSEv05_MAX_TABLELOG > FSEv05_TABLELOG_ABSOLUTE_MAX is not supported" 
+#endif 
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#define FSEv05_STATIC_ASSERT(c) { enum { FSEv05_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */ 
+ 
+ 
+/* ************************************************************** 
+*  Complex types 
+****************************************************************/ 
+typedef U32 DTable_max_t[FSEv05_DTABLE_SIZE_U32(FSEv05_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 FSEv05_FUNCTION_EXTENSION 
+#  error "FSEv05_FUNCTION_EXTENSION must be defined" 
+#endif 
+#ifndef FSEv05_FUNCTION_TYPE 
+#  error "FSEv05_FUNCTION_TYPE must be defined" 
+#endif 
+ 
+/* Function names */ 
+#define FSEv05_CAT(X,Y) X##Y 
+#define FSEv05_FUNCTION_NAME(X,Y) FSEv05_CAT(X,Y) 
+#define FSEv05_TYPE_NAME(X,Y) FSEv05_CAT(X,Y) 
+ 
+ 
+/* Function templates */ 
+static U32 FSEv05_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; } 
+ 
+ 
+ 
+FSEv05_DTable* FSEv05_createDTable (unsigned tableLog) 
+{ 
+    if (tableLog > FSEv05_TABLELOG_ABSOLUTE_MAX) tableLog = FSEv05_TABLELOG_ABSOLUTE_MAX; 
+    return (FSEv05_DTable*)malloc( FSEv05_DTABLE_SIZE_U32(tableLog) * sizeof (U32) ); 
+} 
+ 
+void FSEv05_freeDTable (FSEv05_DTable* dt) 
+{ 
+    free(dt); 
+} 
+ 
+size_t FSEv05_buildDTable(FSEv05_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) 
+{ 
+    FSEv05_DTableHeader DTableH; 
+    void* const tdPtr = dt+1;   /* because dt is unsigned, 32-bits aligned on 32-bits */ 
+    FSEv05_DECODE_TYPE* const tableDecode = (FSEv05_DECODE_TYPE*) (tdPtr); 
+    const U32 tableSize = 1 << tableLog; 
+    const U32 tableMask = tableSize-1; 
+    const U32 step = FSEv05_tableStep(tableSize); 
+    U16 symbolNext[FSEv05_MAX_SYMBOL_VALUE+1]; 
+    U32 position = 0; 
+    U32 highThreshold = tableSize-1; 
+    const S16 largeLimit= (S16)(1 << (tableLog-1)); 
+    U32 noLarge = 1; 
+    U32 s; 
+ 
+    /* Sanity Checks */ 
+    if (maxSymbolValue > FSEv05_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge); 
+    if (tableLog > FSEv05_MAX_TABLELOG) return ERROR(tableLog_tooLarge); 
+ 
+    /* Init, lay down lowprob symbols */ 
+    DTableH.tableLog = (U16)tableLog; 
+    for (s=0; s<=maxSymbolValue; s++) { 
+        if (normalizedCounter[s]==-1) { 
+            tableDecode[highThreshold--].symbol = (FSEv05_FUNCTION_TYPE)s; 
+            symbolNext[s] = 1; 
+        } else { 
+            if (normalizedCounter[s] >= largeLimit) noLarge=0; 
+            symbolNext[s] = normalizedCounter[s]; 
+    }   } 
+ 
+    /* Spread symbols */ 
+    for (s=0; s<=maxSymbolValue; s++) { 
+        int i; 
+        for (i=0; i<normalizedCounter[s]; i++) { 
+            tableDecode[position].symbol = (FSEv05_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 i; 
+        for (i=0; i<tableSize; i++) { 
+            FSEv05_FUNCTION_TYPE symbol = (FSEv05_FUNCTION_TYPE)(tableDecode[i].symbol); 
+            U16 nextState = symbolNext[symbol]++; 
+            tableDecode[i].nbBits = (BYTE) (tableLog - BITv05_highbit32 ((U32)nextState) ); 
+            tableDecode[i].newState = (U16) ( (nextState << tableDecode[i].nbBits) - tableSize); 
+    }   } 
+ 
+    DTableH.fastMode = (U16)noLarge; 
+    memcpy(dt, &DTableH, sizeof(DTableH)); 
+    return 0; 
+} 
+ 
+ 
+#ifndef FSEv05_COMMONDEFS_ONLY 
+/*-**************************************** 
+*  FSEv05 helper functions 
+******************************************/ 
+unsigned FSEv05_isError(size_t code) { return ERR_isError(code); } 
+ 
+const char* FSEv05_getErrorName(size_t code) { return ERR_getErrorName(code); } 
+ 
+ 
+/*-************************************************************** 
+*  FSEv05 NCount encoding-decoding 
+****************************************************************/ 
+static short FSEv05_abs(short a) { return a<0 ? -a : a; } 
+ 
+ 
+size_t FSEv05_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) + FSEv05_MIN_TABLELOG;   /* extract tableLog */ 
+    if (nbBits > FSEv05_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; 
+        } 
+        { 
+            const short 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 -= FSEv05_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); 
+    }   } 
+    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; 
+} 
+ 
+ 
+ 
+/*-******************************************************* 
+*  Decompression (Byte symbols) 
+*********************************************************/ 
+size_t FSEv05_buildDTable_rle (FSEv05_DTable* dt, BYTE symbolValue) 
+{ 
+    void* ptr = dt; 
+    FSEv05_DTableHeader* const DTableH = (FSEv05_DTableHeader*)ptr; 
+    void* dPtr = dt + 1; 
+    FSEv05_decode_t* const cell = (FSEv05_decode_t*)dPtr; 
+ 
+    DTableH->tableLog = 0; 
+    DTableH->fastMode = 0; 
+ 
+    cell->newState = 0; 
+    cell->symbol = symbolValue; 
+    cell->nbBits = 0; 
+ 
+    return 0; 
+} 
+ 
+ 
+size_t FSEv05_buildDTable_raw (FSEv05_DTable* dt, unsigned nbBits) 
+{ 
+    void* ptr = dt; 
+    FSEv05_DTableHeader* const DTableH = (FSEv05_DTableHeader*)ptr; 
+    void* dPtr = dt + 1; 
+    FSEv05_decode_t* const dinfo = (FSEv05_decode_t*)dPtr; 
+    const unsigned tableSize = 1 << nbBits; 
+    const unsigned tableMask = tableSize - 1; 
+    const unsigned maxSymbolValue = tableMask; 
+    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<=maxSymbolValue; s++) { 
+        dinfo[s].newState = 0; 
+        dinfo[s].symbol = (BYTE)s; 
+        dinfo[s].nbBits = (BYTE)nbBits; 
+    } 
+ 
+    return 0; 
+} 
+ 
+FORCE_INLINE size_t FSEv05_decompress_usingDTable_generic( 
+          void* dst, size_t maxDstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const FSEv05_DTable* dt, const unsigned fast) 
+{ 
+    BYTE* const ostart = (BYTE*) dst; 
+    BYTE* op = ostart; 
+    BYTE* const omax = op + maxDstSize; 
+    BYTE* const olimit = omax-3; 
+ 
+    BITv05_DStream_t bitD; 
+    FSEv05_DState_t state1; 
+    FSEv05_DState_t state2; 
+    size_t errorCode; 
+ 
+    /* Init */ 
+    errorCode = BITv05_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */ 
+    if (FSEv05_isError(errorCode)) return errorCode; 
+ 
+    FSEv05_initDState(&state1, &bitD, dt); 
+    FSEv05_initDState(&state2, &bitD, dt); 
+ 
+#define FSEv05_GETSYMBOL(statePtr) fast ? FSEv05_decodeSymbolFast(statePtr, &bitD) : FSEv05_decodeSymbol(statePtr, &bitD) 
+ 
+    /* 4 symbols per loop */ 
+    for ( ; (BITv05_reloadDStream(&bitD)==BITv05_DStream_unfinished) && (op<olimit) ; op+=4) { 
+        op[0] = FSEv05_GETSYMBOL(&state1); 
+ 
+        if (FSEv05_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            BITv05_reloadDStream(&bitD); 
+ 
+        op[1] = FSEv05_GETSYMBOL(&state2); 
+ 
+        if (FSEv05_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            { if (BITv05_reloadDStream(&bitD) > BITv05_DStream_unfinished) { op+=2; break; } } 
+ 
+        op[2] = FSEv05_GETSYMBOL(&state1); 
+ 
+        if (FSEv05_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            BITv05_reloadDStream(&bitD); 
+ 
+        op[3] = FSEv05_GETSYMBOL(&state2); 
+    } 
+ 
+    /* tail */ 
+    /* note : BITv05_reloadDStream(&bitD) >= FSEv05_DStream_partiallyFilled; Ends at exactly BITv05_DStream_completed */ 
+    while (1) { 
+        if ( (BITv05_reloadDStream(&bitD)>BITv05_DStream_completed) || (op==omax) || (BITv05_endOfDStream(&bitD) && (fast || FSEv05_endOfDState(&state1))) ) 
+            break; 
+ 
+        *op++ = FSEv05_GETSYMBOL(&state1); 
+ 
+        if ( (BITv05_reloadDStream(&bitD)>BITv05_DStream_completed) || (op==omax) || (BITv05_endOfDStream(&bitD) && (fast || FSEv05_endOfDState(&state2))) ) 
+            break; 
+ 
+        *op++ = FSEv05_GETSYMBOL(&state2); 
+    } 
+ 
+    /* end ? */ 
+    if (BITv05_endOfDStream(&bitD) && FSEv05_endOfDState(&state1) && FSEv05_endOfDState(&state2)) 
+        return op-ostart; 
+ 
+    if (op==omax) return ERROR(dstSize_tooSmall);   /* dst buffer is full, but cSrc unfinished */ 
+ 
+    return ERROR(corruption_detected); 
+} 
+ 
+ 
+size_t FSEv05_decompress_usingDTable(void* dst, size_t originalSize, 
+                            const void* cSrc, size_t cSrcSize, 
+                            const FSEv05_DTable* dt) 
+{ 
+    const void* ptr = dt; 
+    const FSEv05_DTableHeader* DTableH = (const FSEv05_DTableHeader*)ptr; 
+    const U32 fastMode = DTableH->fastMode; 
+ 
+    /* select fast mode (static) */ 
+    if (fastMode) return FSEv05_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1); 
+    return FSEv05_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0); 
+} 
+ 
+ 
+size_t FSEv05_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[FSEv05_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 = FSEv05_MAX_SYMBOL_VALUE; 
+    size_t errorCode; 
+ 
+    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */ 
+ 
+    /* normal FSEv05 decoding mode */ 
+    errorCode = FSEv05_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize); 
+    if (FSEv05_isError(errorCode)) return errorCode; 
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */ 
+    ip += errorCode; 
+    cSrcSize -= errorCode; 
+ 
+    errorCode = FSEv05_buildDTable (dt, counting, maxSymbolValue, tableLog); 
+    if (FSEv05_isError(errorCode)) return errorCode; 
+ 
+    /* always return, even if it is an error code */ 
+    return FSEv05_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt); 
+} 
+ 
+ 
+ 
+#endif   /* FSEv05_COMMONDEFS_ONLY */ 
+/* ****************************************************************** 
+   Huff0 : 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 HUFF0_H 
+#define HUFF0_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+ 
+/* **************************************** 
+*  Huff0 simple functions 
+******************************************/ 
+size_t HUFv05_decompress(void* dst,  size_t dstSize, 
+                const void* cSrc, size_t cSrcSize); 
+/*! 
+HUFv05_decompress(): 
+    Decompress Huff0 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 FSEv05, HUFv05_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 HUFv05_isError() 
+*/ 
+ 
+ 
+/* **************************************** 
+*  Tool functions 
+******************************************/ 
+/* Error Management */ 
+unsigned    HUFv05_isError(size_t code);        /* tells if a return value is an error code */ 
+const char* HUFv05_getErrorName(size_t code);   /* provides error code string (useful for debugging) */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif   /* HUF0_H */ 
+/* ****************************************************************** 
+   Huff0 : 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 HUF0_STATIC_H 
+#define HUF0_STATIC_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+ 
+/* **************************************** 
+*  Static allocation 
+******************************************/ 
+/* static allocation of Huff0's DTable */ 
+#define HUFv05_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog)) 
+#define HUFv05_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \ 
+        unsigned short DTable[HUFv05_DTABLE_SIZE(maxTableLog)] = { maxTableLog } 
+#define HUFv05_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \ 
+        unsigned int DTable[HUFv05_DTABLE_SIZE(maxTableLog)] = { maxTableLog } 
+#define HUFv05_CREATE_STATIC_DTABLEX6(DTable, maxTableLog) \ 
+        unsigned int DTable[HUFv05_DTABLE_SIZE(maxTableLog) * 3 / 2] = { maxTableLog } 
+ 
+ 
+/* **************************************** 
+*  Advanced decompression functions 
+******************************************/ 
+size_t HUFv05_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */ 
+size_t HUFv05_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */ 
+ 
+ 
+/* **************************************** 
+*  Huff0 detailed API 
+******************************************/ 
+/*! 
+HUFv05_decompress() does the following: 
+1. select the decompression algorithm (X2, X4, X6) based on pre-computed heuristics 
+2. build Huffman table from save, using HUFv05_readDTableXn() 
+3. decode 1 or 4 segments in parallel using HUFv05_decompressSXn_usingDTable 
+*/ 
+size_t HUFv05_readDTableX2 (unsigned short* DTable, const void* src, size_t srcSize); 
+size_t HUFv05_readDTableX4 (unsigned* DTable, const void* src, size_t srcSize); 
+ 
+size_t HUFv05_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable); 
+size_t HUFv05_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable); 
+ 
+ 
+/* single stream variants */ 
+ 
+size_t HUFv05_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */ 
+size_t HUFv05_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */ 
+ 
+size_t HUFv05_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable); 
+size_t HUFv05_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable); 
+ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* HUF0_STATIC_H */ 
+/* ****************************************************************** 
+   Huff0 : Huffman coder, part of New Generation Entropy library 
+   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 : 
+    - FSEv05+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+ 
+/* ************************************************************** 
+*  Compiler specifics 
+****************************************************************/ 
+#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) 
+/* inline is defined */ 
+#elif defined(_MSC_VER) 
+#  define inline __inline 
+#else 
+#  define inline /* disable inline */ 
+#endif 
+ 
+ 
+#ifdef _MSC_VER    /* Visual Studio */ 
+#  define FORCE_INLINE static __forceinline 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#else 
+#  ifdef __GNUC__ 
+#    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) */ 
+ 
+ 
+/* ************************************************************** 
+*  Constants 
+****************************************************************/ 
+#define HUFv05_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUFv05_MAX_TABLELOG. Beyond that value, code does not work */ 
+#define HUFv05_MAX_TABLELOG  12           /* max configured tableLog (for static allocation); can be modified up to HUFv05_ABSOLUTEMAX_TABLELOG */ 
+#define HUFv05_DEFAULT_TABLELOG  HUFv05_MAX_TABLELOG   /* tableLog by default, when not specified */ 
+#define HUFv05_MAX_SYMBOL_VALUE 255 
+#if (HUFv05_MAX_TABLELOG > HUFv05_ABSOLUTEMAX_TABLELOG) 
+#  error "HUFv05_MAX_TABLELOG is too large !" 
+#endif 
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
+unsigned HUFv05_isError(size_t code) { return ERR_isError(code); } 
+const char* HUFv05_getErrorName(size_t code) { return ERR_getErrorName(code); } 
+#define HUFv05_STATIC_ASSERT(c) { enum { HUFv05_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */ 
+ 
+ 
+/* ******************************************************* 
+*  Huff0 : Huffman block decompression 
+*********************************************************/ 
+typedef struct { BYTE byte; BYTE nbBits; } HUFv05_DEltX2;   /* single-symbol decoding */ 
+ 
+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUFv05_DEltX4;  /* double-symbols decoding */ 
+ 
+typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t; 
+ 
+/*! HUFv05_readStats 
+    Read compact Huffman tree, saved by HUFv05_writeCTable 
+    @huffWeight : destination buffer 
+    @return : size read from `src` 
+*/ 
+static size_t HUFv05_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats, 
+                            U32* nbSymbolsPtr, U32* tableLogPtr, 
+                            const void* src, size_t srcSize) 
+{ 
+    U32 weightTotal; 
+    U32 tableLog; 
+    const BYTE* ip = (const BYTE*) src; 
+    size_t iSize = ip[0]; 
+    size_t oSize; 
+    U32 n; 
+ 
+    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    if (iSize >= 128)  { /* special header */ 
+        if (iSize >= (242)) {  /* RLE */ 
+            static int 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; 
+            for (n=0; n<oSize; n+=2) { 
+                huffWeight[n]   = ip[n/2] >> 4; 
+                huffWeight[n+1] = ip[n/2] & 15; 
+    }   }   } 
+    else  {   /* header compressed with FSEv05 (normal case) */ 
+        if (iSize+1 > srcSize) return ERROR(srcSize_wrong); 
+        oSize = FSEv05_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */ 
+        if (FSEv05_isError(oSize)) return oSize; 
+    } 
+ 
+    /* collect weight stats */ 
+    memset(rankStats, 0, (HUFv05_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32)); 
+    weightTotal = 0; 
+    for (n=0; n<oSize; n++) { 
+        if (huffWeight[n] >= HUFv05_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) */ 
+    tableLog = BITv05_highbit32(weightTotal) + 1; 
+    if (tableLog > HUFv05_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected); 
+    {   /* determine last weight */ 
+        U32 total = 1 << tableLog; 
+        U32 rest = total - weightTotal; 
+        U32 verif = 1 << BITv05_highbit32(rest); 
+        U32 lastWeight = BITv05_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); 
+    *tableLogPtr = tableLog; 
+    return iSize+1; 
+} 
+ 
+ 
+/*-***************************/ 
+/*  single-symbol decoding   */ 
+/*-***************************/ 
+ 
+size_t HUFv05_readDTableX2 (U16* DTable, const void* src, size_t srcSize) 
+{ 
+    BYTE huffWeight[HUFv05_MAX_SYMBOL_VALUE + 1]; 
+    U32 rankVal[HUFv05_ABSOLUTEMAX_TABLELOG + 1];   /* large enough for values from 0 to 16 */ 
+    U32 tableLog = 0; 
+    size_t iSize; 
+    U32 nbSymbols = 0; 
+    U32 n; 
+    U32 nextRankStart; 
+    void* const dtPtr = DTable + 1; 
+    HUFv05_DEltX2* const dt = (HUFv05_DEltX2*)dtPtr; 
+ 
+    HUFv05_STATIC_ASSERT(sizeof(HUFv05_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */ 
+    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    iSize = HUFv05_readStats(huffWeight, HUFv05_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize); 
+    if (HUFv05_isError(iSize)) return iSize; 
+ 
+    /* check result */ 
+    if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge);   /* DTable is too small */ 
+    DTable[0] = (U16)tableLog;   /* maybe should separate sizeof allocated DTable, from used size of DTable, in case of re-use */ 
+ 
+    /* Prepare ranks */ 
+    nextRankStart = 0; 
+    for (n=1; n<=tableLog; n++) { 
+        U32 current = nextRankStart; 
+        nextRankStart += (rankVal[n] << (n-1)); 
+        rankVal[n] = current; 
+    } 
+ 
+    /* fill DTable */ 
+    for (n=0; n<nbSymbols; n++) { 
+        const U32 w = huffWeight[n]; 
+        const U32 length = (1 << w) >> 1; 
+        U32 i; 
+        HUFv05_DEltX2 D; 
+        D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w); 
+        for (i = rankVal[w]; i < rankVal[w] + length; i++) 
+            dt[i] = D; 
+        rankVal[w] += length; 
+    } 
+ 
+    return iSize; 
+} 
+ 
+static BYTE HUFv05_decodeSymbolX2(BITv05_DStream_t* Dstream, const HUFv05_DEltX2* dt, const U32 dtLog) 
+{ 
+        const size_t val = BITv05_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */ 
+        const BYTE c = dt[val].byte; 
+        BITv05_skipBits(Dstream, dt[val].nbBits); 
+        return c; 
+} 
+ 
+#define HUFv05_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \ 
+    *ptr++ = HUFv05_decodeSymbolX2(DStreamPtr, dt, dtLog) 
+ 
+#define HUFv05_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \ 
+    if (MEM_64bits() || (HUFv05_MAX_TABLELOG<=12)) \ 
+        HUFv05_DECODE_SYMBOLX2_0(ptr, DStreamPtr) 
+ 
+#define HUFv05_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \ 
+    if (MEM_64bits()) \ 
+        HUFv05_DECODE_SYMBOLX2_0(ptr, DStreamPtr) 
+ 
+static inline size_t HUFv05_decodeStreamX2(BYTE* p, BITv05_DStream_t* const bitDPtr, BYTE* const pEnd, const HUFv05_DEltX2* const dt, const U32 dtLog) 
+{ 
+    BYTE* const pStart = p; 
+ 
+    /* up to 4 symbols at a time */ 
+    while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p <= pEnd-4)) { 
+        HUFv05_DECODE_SYMBOLX2_2(p, bitDPtr); 
+        HUFv05_DECODE_SYMBOLX2_1(p, bitDPtr); 
+        HUFv05_DECODE_SYMBOLX2_2(p, bitDPtr); 
+        HUFv05_DECODE_SYMBOLX2_0(p, bitDPtr); 
+    } 
+ 
+    /* closer to the end */ 
+    while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p < pEnd)) 
+        HUFv05_DECODE_SYMBOLX2_0(p, bitDPtr); 
+ 
+    /* no more data to retrieve from bitstream, hence no need to reload */ 
+    while (p < pEnd) 
+        HUFv05_DECODE_SYMBOLX2_0(p, bitDPtr); 
+ 
+    return pEnd-pStart; 
+} 
+ 
+size_t HUFv05_decompress1X2_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const U16* DTable) 
+{ 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + dstSize; 
+    size_t errorCode; 
+    const U32 dtLog = DTable[0]; 
+    const void* dtPtr = DTable; 
+    const HUFv05_DEltX2* const dt = ((const HUFv05_DEltX2*)dtPtr)+1; 
+    BITv05_DStream_t bitD; 
+    errorCode = BITv05_initDStream(&bitD, cSrc, cSrcSize); 
+    if (HUFv05_isError(errorCode)) return errorCode; 
+ 
+    HUFv05_decodeStreamX2(op, &bitD, oend, dt, dtLog); 
+ 
+    /* check */ 
+    if (!BITv05_endOfDStream(&bitD)) return ERROR(corruption_detected); 
+ 
+    return dstSize; 
+} 
+ 
+size_t HUFv05_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUFv05_CREATE_STATIC_DTABLEX2(DTable, HUFv05_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+    size_t errorCode; 
+ 
+    errorCode = HUFv05_readDTableX2 (DTable, cSrc, cSrcSize); 
+    if (HUFv05_isError(errorCode)) return errorCode; 
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += errorCode; 
+    cSrcSize -= errorCode; 
+ 
+    return HUFv05_decompress1X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable); 
+} 
+ 
+ 
+size_t HUFv05_decompress4X2_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const U16* DTable) 
+{ 
+    const BYTE* const istart = (const BYTE*) cSrc; 
+    BYTE* const ostart = (BYTE*) dst; 
+    BYTE* const oend = ostart + dstSize; 
+    const void* const dtPtr = DTable; 
+    const HUFv05_DEltX2* const dt = ((const HUFv05_DEltX2*)dtPtr) +1; 
+    const U32 dtLog = DTable[0]; 
+    size_t errorCode; 
+ 
+    /* Init */ 
+    BITv05_DStream_t bitD1; 
+    BITv05_DStream_t bitD2; 
+    BITv05_DStream_t bitD3; 
+    BITv05_DStream_t bitD4; 
+    const size_t length1 = MEM_readLE16(istart); 
+    const size_t length2 = MEM_readLE16(istart+2); 
+    const size_t length3 = MEM_readLE16(istart+4); 
+    size_t length4; 
+    const BYTE* const istart1 = istart + 6;  /* jumpTable */ 
+    const BYTE* const istart2 = istart1 + length1; 
+    const BYTE* const istart3 = istart2 + length2; 
+    const BYTE* const istart4 = istart3 + length3; 
+    const size_t segmentSize = (dstSize+3) / 4; 
+    BYTE* const opStart2 = ostart + segmentSize; 
+    BYTE* const opStart3 = opStart2 + segmentSize; 
+    BYTE* const opStart4 = opStart3 + segmentSize; 
+    BYTE* op1 = ostart; 
+    BYTE* op2 = opStart2; 
+    BYTE* op3 = opStart3; 
+    BYTE* op4 = opStart4; 
+    U32 endSignal; 
+ 
     /* Check */
     if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
 
-    length4 = cSrcSize - (length1 + length2 + length3 + 6);
-    if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
-    errorCode = BITv05_initDStream(&bitD1, istart1, length1);
-    if (HUFv05_isError(errorCode)) return errorCode;
-    errorCode = BITv05_initDStream(&bitD2, istart2, length2);
-    if (HUFv05_isError(errorCode)) return errorCode;
-    errorCode = BITv05_initDStream(&bitD3, istart3, length3);
-    if (HUFv05_isError(errorCode)) return errorCode;
-    errorCode = BITv05_initDStream(&bitD4, istart4, length4);
-    if (HUFv05_isError(errorCode)) return errorCode;
-
-    /* 16-32 symbols per loop (4-8 symbols per stream) */
-    endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4);
-    for ( ; (endSignal==BITv05_DStream_unfinished) && (op4<(oend-7)) ; ) {
-        HUFv05_DECODE_SYMBOLX2_2(op1, &bitD1);
-        HUFv05_DECODE_SYMBOLX2_2(op2, &bitD2);
-        HUFv05_DECODE_SYMBOLX2_2(op3, &bitD3);
-        HUFv05_DECODE_SYMBOLX2_2(op4, &bitD4);
-        HUFv05_DECODE_SYMBOLX2_1(op1, &bitD1);
-        HUFv05_DECODE_SYMBOLX2_1(op2, &bitD2);
-        HUFv05_DECODE_SYMBOLX2_1(op3, &bitD3);
-        HUFv05_DECODE_SYMBOLX2_1(op4, &bitD4);
-        HUFv05_DECODE_SYMBOLX2_2(op1, &bitD1);
-        HUFv05_DECODE_SYMBOLX2_2(op2, &bitD2);
-        HUFv05_DECODE_SYMBOLX2_2(op3, &bitD3);
-        HUFv05_DECODE_SYMBOLX2_2(op4, &bitD4);
-        HUFv05_DECODE_SYMBOLX2_0(op1, &bitD1);
-        HUFv05_DECODE_SYMBOLX2_0(op2, &bitD2);
-        HUFv05_DECODE_SYMBOLX2_0(op3, &bitD3);
-        HUFv05_DECODE_SYMBOLX2_0(op4, &bitD4);
-        endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4);
-    }
-
-    /* check corruption */
-    if (op1 > opStart2) return ERROR(corruption_detected);
-    if (op2 > opStart3) return ERROR(corruption_detected);
-    if (op3 > opStart4) return ERROR(corruption_detected);
-    /* note : op4 supposed already verified within main loop */
-
-    /* finish bitStreams one by one */
-    HUFv05_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
-    HUFv05_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
-    HUFv05_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
-    HUFv05_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
-
-    /* check */
-    endSignal = BITv05_endOfDStream(&bitD1) & BITv05_endOfDStream(&bitD2) & BITv05_endOfDStream(&bitD3) & BITv05_endOfDStream(&bitD4);
-    if (!endSignal) return ERROR(corruption_detected);
-
-    /* decoded size */
-    return dstSize;
-}
-
-
-size_t HUFv05_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUFv05_CREATE_STATIC_DTABLEX2(DTable, HUFv05_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-    size_t errorCode;
-
-    errorCode = HUFv05_readDTableX2 (DTable, cSrc, cSrcSize);
-    if (HUFv05_isError(errorCode)) return errorCode;
-    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += errorCode;
-    cSrcSize -= errorCode;
-
-    return HUFv05_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
-}
-
-
-/* *************************/
-/* double-symbols decoding */
-/* *************************/
-
-static void HUFv05_fillDTableX4Level2(HUFv05_DEltX4* DTable, U32 sizeLog, const U32 consumed,
-                           const U32* rankValOrigin, const int minWeight,
-                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
-                           U32 nbBitsBaseline, U16 baseSeq)
-{
-    HUFv05_DEltX4 DElt;
-    U32 rankVal[HUFv05_ABSOLUTEMAX_TABLELOG + 1];
-    U32 s;
-
-    /* get pre-calculated rankVal */
-    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
-
-    /* fill skipped values */
-    if (minWeight>1) {
-        U32 i, skipSize = rankVal[minWeight];
-        MEM_writeLE16(&(DElt.sequence), baseSeq);
-        DElt.nbBits   = (BYTE)(consumed);
-        DElt.length   = 1;
-        for (i = 0; i < skipSize; i++)
-            DTable[i] = DElt;
-    }
-
-    /* fill DTable */
-    for (s=0; s<sortedListSize; s++) {   /* note : sortedSymbols already skipped */
-        const U32 symbol = sortedSymbols[s].symbol;
-        const U32 weight = sortedSymbols[s].weight;
-        const U32 nbBits = nbBitsBaseline - weight;
-        const U32 length = 1 << (sizeLog-nbBits);
-        const U32 start = rankVal[weight];
-        U32 i = start;
-        const U32 end = start + length;
-
-        MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8)));
-        DElt.nbBits = (BYTE)(nbBits + consumed);
-        DElt.length = 2;
-        do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */
-
-        rankVal[weight] += length;
-    }
-}
-
-typedef U32 rankVal_t[HUFv05_ABSOLUTEMAX_TABLELOG][HUFv05_ABSOLUTEMAX_TABLELOG + 1];
-
-static void HUFv05_fillDTableX4(HUFv05_DEltX4* DTable, const U32 targetLog,
-                           const sortedSymbol_t* sortedList, const U32 sortedListSize,
-                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
-                           const U32 nbBitsBaseline)
-{
-    U32 rankVal[HUFv05_ABSOLUTEMAX_TABLELOG + 1];
-    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */
-    const U32 minBits  = nbBitsBaseline - maxWeight;
-    U32 s;
-
-    memcpy(rankVal, rankValOrigin, sizeof(rankVal));
-
-    /* fill DTable */
-    for (s=0; s<sortedListSize; s++) {
-        const U16 symbol = sortedList[s].symbol;
-        const U32 weight = sortedList[s].weight;
-        const U32 nbBits = nbBitsBaseline - weight;
-        const U32 start = rankVal[weight];
-        const U32 length = 1 << (targetLog-nbBits);
-
-        if (targetLog-nbBits >= minBits) {   /* enough room for a second symbol */
-            U32 sortedRank;
-            int minWeight = nbBits + scaleLog;
-            if (minWeight < 1) minWeight = 1;
-            sortedRank = rankStart[minWeight];
-            HUFv05_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,
-                           rankValOrigin[nbBits], minWeight,
-                           sortedList+sortedRank, sortedListSize-sortedRank,
-                           nbBitsBaseline, symbol);
-        } else {
-            U32 i;
-            const U32 end = start + length;
-            HUFv05_DEltX4 DElt;
-
-            MEM_writeLE16(&(DElt.sequence), symbol);
-            DElt.nbBits   = (BYTE)(nbBits);
-            DElt.length   = 1;
-            for (i = start; i < end; i++)
-                DTable[i] = DElt;
-        }
-        rankVal[weight] += length;
-    }
-}
-
-size_t HUFv05_readDTableX4 (U32* DTable, const void* src, size_t srcSize)
-{
-    BYTE weightList[HUFv05_MAX_SYMBOL_VALUE + 1];
-    sortedSymbol_t sortedSymbol[HUFv05_MAX_SYMBOL_VALUE + 1];
-    U32 rankStats[HUFv05_ABSOLUTEMAX_TABLELOG + 1] = { 0 };
-    U32 rankStart0[HUFv05_ABSOLUTEMAX_TABLELOG + 2] = { 0 };
-    U32* const rankStart = rankStart0+1;
-    rankVal_t rankVal;
-    U32 tableLog, maxW, sizeOfSort, nbSymbols;
-    const U32 memLog = DTable[0];
-    size_t iSize;
-    void* dtPtr = DTable;
-    HUFv05_DEltX4* const dt = ((HUFv05_DEltX4*)dtPtr) + 1;
-
-    HUFv05_STATIC_ASSERT(sizeof(HUFv05_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */
-    if (memLog > HUFv05_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);
-    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUFv05_readStats(weightList, HUFv05_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
-    if (HUFv05_isError(iSize)) return iSize;
-
-    /* check result */
-    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
-
-    /* find maxWeight */
-    for (maxW = tableLog; rankStats[maxW]==0; maxW--) {}  /* necessarily finds a solution before 0 */
-
-    /* Get start index of each weight */
-    {
-        U32 w, nextRankStart = 0;
-        for (w=1; w<=maxW; w++) {
-            U32 current = nextRankStart;
-            nextRankStart += rankStats[w];
-            rankStart[w] = current;
-        }
-        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
-        sizeOfSort = nextRankStart;
-    }
-
-    /* sort symbols by weight */
-    {
-        U32 s;
-        for (s=0; s<nbSymbols; s++) {
-            U32 w = weightList[s];
-            U32 r = rankStart[w]++;
-            sortedSymbol[r].symbol = (BYTE)s;
-            sortedSymbol[r].weight = (BYTE)w;
-        }
-        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
-    }
-
-    /* Build rankVal */
-    {
-        const U32 minBits = tableLog+1 - maxW;
-        U32 nextRankVal = 0;
-        U32 w, consumed;
-        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */
-        U32* rankVal0 = rankVal[0];
-        for (w=1; w<=maxW; w++) {
-            U32 current = nextRankVal;
-            nextRankVal += rankStats[w] << (w+rescale);
-            rankVal0[w] = current;
-        }
-        for (consumed = minBits; consumed <= memLog - minBits; consumed++) {
-            U32* rankValPtr = rankVal[consumed];
-            for (w = 1; w <= maxW; w++) {
-                rankValPtr[w] = rankVal0[w] >> consumed;
-    }   }   }
-
-    HUFv05_fillDTableX4(dt, memLog,
-                   sortedSymbol, sizeOfSort,
-                   rankStart0, rankVal, maxW,
-                   tableLog+1);
-
-    return iSize;
-}
-
-
-static U32 HUFv05_decodeSymbolX4(void* op, BITv05_DStream_t* DStream, const HUFv05_DEltX4* dt, const U32 dtLog)
-{
-    const size_t val = BITv05_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    memcpy(op, dt+val, 2);
-    BITv05_skipBits(DStream, dt[val].nbBits);
-    return dt[val].length;
-}
-
-static U32 HUFv05_decodeLastSymbolX4(void* op, BITv05_DStream_t* DStream, const HUFv05_DEltX4* dt, const U32 dtLog)
-{
-    const size_t val = BITv05_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    memcpy(op, dt+val, 1);
-    if (dt[val].length==1) BITv05_skipBits(DStream, dt[val].nbBits);
-    else {
-        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {
-            BITv05_skipBits(DStream, dt[val].nbBits);
-            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
-                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */
-    }   }
-    return 1;
-}
-
-
-#define HUFv05_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \
-    ptr += HUFv05_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-#define HUFv05_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \
-    if (MEM_64bits() || (HUFv05_MAX_TABLELOG<=12)) \
-        ptr += HUFv05_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-#define HUFv05_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \
-    if (MEM_64bits()) \
-        ptr += HUFv05_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-static inline size_t HUFv05_decodeStreamX4(BYTE* p, BITv05_DStream_t* bitDPtr, BYTE* const pEnd, const HUFv05_DEltX4* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 8 symbols at a time */
-    while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p < pEnd-7)) {
-        HUFv05_DECODE_SYMBOLX4_2(p, bitDPtr);
-        HUFv05_DECODE_SYMBOLX4_1(p, bitDPtr);
-        HUFv05_DECODE_SYMBOLX4_2(p, bitDPtr);
-        HUFv05_DECODE_SYMBOLX4_0(p, bitDPtr);
-    }
-
-    /* closer to the end */
-    while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p <= pEnd-2))
-        HUFv05_DECODE_SYMBOLX4_0(p, bitDPtr);
-
-    while (p <= pEnd-2)
-        HUFv05_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
-
-    if (p < pEnd)
-        p += HUFv05_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);
-
-    return p-pStart;
-}
-
-
-size_t HUFv05_decompress1X4_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const U32* DTable)
-{
-    const BYTE* const istart = (const BYTE*) cSrc;
-    BYTE* const ostart = (BYTE*) dst;
-    BYTE* const oend = ostart + dstSize;
-
-    const U32 dtLog = DTable[0];
-    const void* const dtPtr = DTable;
-    const HUFv05_DEltX4* const dt = ((const HUFv05_DEltX4*)dtPtr) +1;
-    size_t errorCode;
-
-    /* Init */
-    BITv05_DStream_t bitD;
-    errorCode = BITv05_initDStream(&bitD, istart, cSrcSize);
-    if (HUFv05_isError(errorCode)) return errorCode;
-
-    /* finish bitStreams one by one */
-    HUFv05_decodeStreamX4(ostart, &bitD, oend,     dt, dtLog);
-
-    /* check */
-    if (!BITv05_endOfDStream(&bitD)) return ERROR(corruption_detected);
-
-    /* decoded size */
-    return dstSize;
-}
-
-size_t HUFv05_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUFv05_CREATE_STATIC_DTABLEX4(DTable, HUFv05_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t hSize = HUFv05_readDTableX4 (DTable, cSrc, cSrcSize);
-    if (HUFv05_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize;
-    cSrcSize -= hSize;
-
-    return HUFv05_decompress1X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
-}
-
-size_t HUFv05_decompress4X4_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const U32* DTable)
-{
-    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
-
-    {
-        const BYTE* const istart = (const BYTE*) cSrc;
-        BYTE* const ostart = (BYTE*) dst;
-        BYTE* const oend = ostart + dstSize;
-        const void* const dtPtr = DTable;
-        const HUFv05_DEltX4* const dt = ((const HUFv05_DEltX4*)dtPtr) +1;
-        const U32 dtLog = DTable[0];
-        size_t errorCode;
-
-        /* Init */
-        BITv05_DStream_t bitD1;
-        BITv05_DStream_t bitD2;
-        BITv05_DStream_t bitD3;
-        BITv05_DStream_t bitD4;
-        const size_t length1 = MEM_readLE16(istart);
-        const size_t length2 = MEM_readLE16(istart+2);
-        const size_t length3 = MEM_readLE16(istart+4);
-        size_t length4;
-        const BYTE* const istart1 = istart + 6;  /* jumpTable */
-        const BYTE* const istart2 = istart1 + length1;
-        const BYTE* const istart3 = istart2 + length2;
-        const BYTE* const istart4 = istart3 + length3;
-        const size_t segmentSize = (dstSize+3) / 4;
-        BYTE* const opStart2 = ostart + segmentSize;
-        BYTE* const opStart3 = opStart2 + segmentSize;
-        BYTE* const opStart4 = opStart3 + segmentSize;
-        BYTE* op1 = ostart;
-        BYTE* op2 = opStart2;
-        BYTE* op3 = opStart3;
-        BYTE* op4 = opStart4;
-        U32 endSignal;
-
-        length4 = cSrcSize - (length1 + length2 + length3 + 6);
-        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
-        errorCode = BITv05_initDStream(&bitD1, istart1, length1);
-        if (HUFv05_isError(errorCode)) return errorCode;
-        errorCode = BITv05_initDStream(&bitD2, istart2, length2);
-        if (HUFv05_isError(errorCode)) return errorCode;
-        errorCode = BITv05_initDStream(&bitD3, istart3, length3);
-        if (HUFv05_isError(errorCode)) return errorCode;
-        errorCode = BITv05_initDStream(&bitD4, istart4, length4);
-        if (HUFv05_isError(errorCode)) return errorCode;
-
-        /* 16-32 symbols per loop (4-8 symbols per stream) */
-        endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4);
-        for ( ; (endSignal==BITv05_DStream_unfinished) && (op4<(oend-7)) ; ) {
-            HUFv05_DECODE_SYMBOLX4_2(op1, &bitD1);
-            HUFv05_DECODE_SYMBOLX4_2(op2, &bitD2);
-            HUFv05_DECODE_SYMBOLX4_2(op3, &bitD3);
-            HUFv05_DECODE_SYMBOLX4_2(op4, &bitD4);
-            HUFv05_DECODE_SYMBOLX4_1(op1, &bitD1);
-            HUFv05_DECODE_SYMBOLX4_1(op2, &bitD2);
-            HUFv05_DECODE_SYMBOLX4_1(op3, &bitD3);
-            HUFv05_DECODE_SYMBOLX4_1(op4, &bitD4);
-            HUFv05_DECODE_SYMBOLX4_2(op1, &bitD1);
-            HUFv05_DECODE_SYMBOLX4_2(op2, &bitD2);
-            HUFv05_DECODE_SYMBOLX4_2(op3, &bitD3);
-            HUFv05_DECODE_SYMBOLX4_2(op4, &bitD4);
-            HUFv05_DECODE_SYMBOLX4_0(op1, &bitD1);
-            HUFv05_DECODE_SYMBOLX4_0(op2, &bitD2);
-            HUFv05_DECODE_SYMBOLX4_0(op3, &bitD3);
-            HUFv05_DECODE_SYMBOLX4_0(op4, &bitD4);
-
-            endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4);
-        }
-
-        /* check corruption */
-        if (op1 > opStart2) return ERROR(corruption_detected);
-        if (op2 > opStart3) return ERROR(corruption_detected);
-        if (op3 > opStart4) return ERROR(corruption_detected);
-        /* note : op4 supposed already verified within main loop */
-
-        /* finish bitStreams one by one */
-        HUFv05_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);
-        HUFv05_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);
-        HUFv05_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);
-        HUFv05_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog);
-
-        /* check */
-        endSignal = BITv05_endOfDStream(&bitD1) & BITv05_endOfDStream(&bitD2) & BITv05_endOfDStream(&bitD3) & BITv05_endOfDStream(&bitD4);
-        if (!endSignal) return ERROR(corruption_detected);
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
-
-size_t HUFv05_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUFv05_CREATE_STATIC_DTABLEX4(DTable, HUFv05_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t hSize = HUFv05_readDTableX4 (DTable, cSrc, cSrcSize);
-    if (HUFv05_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize;
-    cSrcSize -= hSize;
-
-    return HUFv05_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
-}
-
-
-/* ********************************/
-/* Generic decompression selector */
-/* ********************************/
-
-typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
-static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] =
-{
-    /* single, double, quad */
-    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */
-    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */
-    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */
-    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */
-    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */
-    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */
-    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */
-    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */
-    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */
-    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */
-    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */
-    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */
-    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */
-    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */
-    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */
-    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */
-};
-
-typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
-
-size_t HUFv05_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
+    length4 = cSrcSize - (length1 + length2 + length3 + 6); 
+    if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */ 
+    errorCode = BITv05_initDStream(&bitD1, istart1, length1); 
+    if (HUFv05_isError(errorCode)) return errorCode; 
+    errorCode = BITv05_initDStream(&bitD2, istart2, length2); 
+    if (HUFv05_isError(errorCode)) return errorCode; 
+    errorCode = BITv05_initDStream(&bitD3, istart3, length3); 
+    if (HUFv05_isError(errorCode)) return errorCode; 
+    errorCode = BITv05_initDStream(&bitD4, istart4, length4); 
+    if (HUFv05_isError(errorCode)) return errorCode; 
+ 
+    /* 16-32 symbols per loop (4-8 symbols per stream) */ 
+    endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4); 
+    for ( ; (endSignal==BITv05_DStream_unfinished) && (op4<(oend-7)) ; ) { 
+        HUFv05_DECODE_SYMBOLX2_2(op1, &bitD1); 
+        HUFv05_DECODE_SYMBOLX2_2(op2, &bitD2); 
+        HUFv05_DECODE_SYMBOLX2_2(op3, &bitD3); 
+        HUFv05_DECODE_SYMBOLX2_2(op4, &bitD4); 
+        HUFv05_DECODE_SYMBOLX2_1(op1, &bitD1); 
+        HUFv05_DECODE_SYMBOLX2_1(op2, &bitD2); 
+        HUFv05_DECODE_SYMBOLX2_1(op3, &bitD3); 
+        HUFv05_DECODE_SYMBOLX2_1(op4, &bitD4); 
+        HUFv05_DECODE_SYMBOLX2_2(op1, &bitD1); 
+        HUFv05_DECODE_SYMBOLX2_2(op2, &bitD2); 
+        HUFv05_DECODE_SYMBOLX2_2(op3, &bitD3); 
+        HUFv05_DECODE_SYMBOLX2_2(op4, &bitD4); 
+        HUFv05_DECODE_SYMBOLX2_0(op1, &bitD1); 
+        HUFv05_DECODE_SYMBOLX2_0(op2, &bitD2); 
+        HUFv05_DECODE_SYMBOLX2_0(op3, &bitD3); 
+        HUFv05_DECODE_SYMBOLX2_0(op4, &bitD4); 
+        endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4); 
+    } 
+ 
+    /* check corruption */ 
+    if (op1 > opStart2) return ERROR(corruption_detected); 
+    if (op2 > opStart3) return ERROR(corruption_detected); 
+    if (op3 > opStart4) return ERROR(corruption_detected); 
+    /* note : op4 supposed already verified within main loop */ 
+ 
+    /* finish bitStreams one by one */ 
+    HUFv05_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog); 
+    HUFv05_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog); 
+    HUFv05_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog); 
+    HUFv05_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog); 
+ 
+    /* check */ 
+    endSignal = BITv05_endOfDStream(&bitD1) & BITv05_endOfDStream(&bitD2) & BITv05_endOfDStream(&bitD3) & BITv05_endOfDStream(&bitD4); 
+    if (!endSignal) return ERROR(corruption_detected); 
+ 
+    /* decoded size */ 
+    return dstSize; 
+} 
+ 
+ 
+size_t HUFv05_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUFv05_CREATE_STATIC_DTABLEX2(DTable, HUFv05_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+    size_t errorCode; 
+ 
+    errorCode = HUFv05_readDTableX2 (DTable, cSrc, cSrcSize); 
+    if (HUFv05_isError(errorCode)) return errorCode; 
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += errorCode; 
+    cSrcSize -= errorCode; 
+ 
+    return HUFv05_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable); 
+} 
+ 
+ 
+/* *************************/ 
+/* double-symbols decoding */ 
+/* *************************/ 
+ 
+static void HUFv05_fillDTableX4Level2(HUFv05_DEltX4* DTable, U32 sizeLog, const U32 consumed, 
+                           const U32* rankValOrigin, const int minWeight, 
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize, 
+                           U32 nbBitsBaseline, U16 baseSeq) 
+{ 
+    HUFv05_DEltX4 DElt; 
+    U32 rankVal[HUFv05_ABSOLUTEMAX_TABLELOG + 1]; 
+    U32 s; 
+ 
+    /* get pre-calculated rankVal */ 
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal)); 
+ 
+    /* fill skipped values */ 
+    if (minWeight>1) { 
+        U32 i, skipSize = rankVal[minWeight]; 
+        MEM_writeLE16(&(DElt.sequence), baseSeq); 
+        DElt.nbBits   = (BYTE)(consumed); 
+        DElt.length   = 1; 
+        for (i = 0; i < skipSize; i++) 
+            DTable[i] = DElt; 
+    } 
+ 
+    /* fill DTable */ 
+    for (s=0; s<sortedListSize; s++) {   /* note : sortedSymbols already skipped */ 
+        const U32 symbol = sortedSymbols[s].symbol; 
+        const U32 weight = sortedSymbols[s].weight; 
+        const U32 nbBits = nbBitsBaseline - weight; 
+        const U32 length = 1 << (sizeLog-nbBits); 
+        const U32 start = rankVal[weight]; 
+        U32 i = start; 
+        const U32 end = start + length; 
+ 
+        MEM_writeLE16(&(DElt.sequence), (U16)(baseSeq + (symbol << 8))); 
+        DElt.nbBits = (BYTE)(nbBits + consumed); 
+        DElt.length = 2; 
+        do { DTable[i++] = DElt; } while (i<end);   /* since length >= 1 */ 
+ 
+        rankVal[weight] += length; 
+    } 
+} 
+ 
+typedef U32 rankVal_t[HUFv05_ABSOLUTEMAX_TABLELOG][HUFv05_ABSOLUTEMAX_TABLELOG + 1]; 
+ 
+static void HUFv05_fillDTableX4(HUFv05_DEltX4* DTable, const U32 targetLog, 
+                           const sortedSymbol_t* sortedList, const U32 sortedListSize, 
+                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight, 
+                           const U32 nbBitsBaseline) 
+{ 
+    U32 rankVal[HUFv05_ABSOLUTEMAX_TABLELOG + 1]; 
+    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */ 
+    const U32 minBits  = nbBitsBaseline - maxWeight; 
+    U32 s; 
+ 
+    memcpy(rankVal, rankValOrigin, sizeof(rankVal)); 
+ 
+    /* fill DTable */ 
+    for (s=0; s<sortedListSize; s++) { 
+        const U16 symbol = sortedList[s].symbol; 
+        const U32 weight = sortedList[s].weight; 
+        const U32 nbBits = nbBitsBaseline - weight; 
+        const U32 start = rankVal[weight]; 
+        const U32 length = 1 << (targetLog-nbBits); 
+ 
+        if (targetLog-nbBits >= minBits) {   /* enough room for a second symbol */ 
+            U32 sortedRank; 
+            int minWeight = nbBits + scaleLog; 
+            if (minWeight < 1) minWeight = 1; 
+            sortedRank = rankStart[minWeight]; 
+            HUFv05_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits, 
+                           rankValOrigin[nbBits], minWeight, 
+                           sortedList+sortedRank, sortedListSize-sortedRank, 
+                           nbBitsBaseline, symbol); 
+        } else { 
+            U32 i; 
+            const U32 end = start + length; 
+            HUFv05_DEltX4 DElt; 
+ 
+            MEM_writeLE16(&(DElt.sequence), symbol); 
+            DElt.nbBits   = (BYTE)(nbBits); 
+            DElt.length   = 1; 
+            for (i = start; i < end; i++) 
+                DTable[i] = DElt; 
+        } 
+        rankVal[weight] += length; 
+    } 
+} 
+ 
+size_t HUFv05_readDTableX4 (U32* DTable, const void* src, size_t srcSize) 
+{ 
+    BYTE weightList[HUFv05_MAX_SYMBOL_VALUE + 1]; 
+    sortedSymbol_t sortedSymbol[HUFv05_MAX_SYMBOL_VALUE + 1]; 
+    U32 rankStats[HUFv05_ABSOLUTEMAX_TABLELOG + 1] = { 0 }; 
+    U32 rankStart0[HUFv05_ABSOLUTEMAX_TABLELOG + 2] = { 0 }; 
+    U32* const rankStart = rankStart0+1; 
+    rankVal_t rankVal; 
+    U32 tableLog, maxW, sizeOfSort, nbSymbols; 
+    const U32 memLog = DTable[0]; 
+    size_t iSize; 
+    void* dtPtr = DTable; 
+    HUFv05_DEltX4* const dt = ((HUFv05_DEltX4*)dtPtr) + 1; 
+ 
+    HUFv05_STATIC_ASSERT(sizeof(HUFv05_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */ 
+    if (memLog > HUFv05_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge); 
+    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    iSize = HUFv05_readStats(weightList, HUFv05_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize); 
+    if (HUFv05_isError(iSize)) return iSize; 
+ 
+    /* check result */ 
+    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */ 
+ 
+    /* find maxWeight */ 
+    for (maxW = tableLog; rankStats[maxW]==0; maxW--) {}  /* necessarily finds a solution before 0 */ 
+ 
+    /* Get start index of each weight */ 
+    { 
+        U32 w, nextRankStart = 0; 
+        for (w=1; w<=maxW; w++) { 
+            U32 current = nextRankStart; 
+            nextRankStart += rankStats[w]; 
+            rankStart[w] = current; 
+        } 
+        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/ 
+        sizeOfSort = nextRankStart; 
+    } 
+ 
+    /* sort symbols by weight */ 
+    { 
+        U32 s; 
+        for (s=0; s<nbSymbols; s++) { 
+            U32 w = weightList[s]; 
+            U32 r = rankStart[w]++; 
+            sortedSymbol[r].symbol = (BYTE)s; 
+            sortedSymbol[r].weight = (BYTE)w; 
+        } 
+        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */ 
+    } 
+ 
+    /* Build rankVal */ 
+    { 
+        const U32 minBits = tableLog+1 - maxW; 
+        U32 nextRankVal = 0; 
+        U32 w, consumed; 
+        const int rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */ 
+        U32* rankVal0 = rankVal[0]; 
+        for (w=1; w<=maxW; w++) { 
+            U32 current = nextRankVal; 
+            nextRankVal += rankStats[w] << (w+rescale); 
+            rankVal0[w] = current; 
+        } 
+        for (consumed = minBits; consumed <= memLog - minBits; consumed++) { 
+            U32* rankValPtr = rankVal[consumed]; 
+            for (w = 1; w <= maxW; w++) { 
+                rankValPtr[w] = rankVal0[w] >> consumed; 
+    }   }   } 
+ 
+    HUFv05_fillDTableX4(dt, memLog, 
+                   sortedSymbol, sizeOfSort, 
+                   rankStart0, rankVal, maxW, 
+                   tableLog+1); 
+ 
+    return iSize; 
+} 
+ 
+ 
+static U32 HUFv05_decodeSymbolX4(void* op, BITv05_DStream_t* DStream, const HUFv05_DEltX4* dt, const U32 dtLog) 
+{ 
+    const size_t val = BITv05_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    memcpy(op, dt+val, 2); 
+    BITv05_skipBits(DStream, dt[val].nbBits); 
+    return dt[val].length; 
+} 
+ 
+static U32 HUFv05_decodeLastSymbolX4(void* op, BITv05_DStream_t* DStream, const HUFv05_DEltX4* dt, const U32 dtLog) 
+{ 
+    const size_t val = BITv05_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    memcpy(op, dt+val, 1); 
+    if (dt[val].length==1) BITv05_skipBits(DStream, dt[val].nbBits); 
+    else { 
+        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) { 
+            BITv05_skipBits(DStream, dt[val].nbBits); 
+            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8)) 
+                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */ 
+    }   } 
+    return 1; 
+} 
+ 
+ 
+#define HUFv05_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \ 
+    ptr += HUFv05_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+#define HUFv05_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \ 
+    if (MEM_64bits() || (HUFv05_MAX_TABLELOG<=12)) \ 
+        ptr += HUFv05_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+#define HUFv05_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \ 
+    if (MEM_64bits()) \ 
+        ptr += HUFv05_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+static inline size_t HUFv05_decodeStreamX4(BYTE* p, BITv05_DStream_t* bitDPtr, BYTE* const pEnd, const HUFv05_DEltX4* const dt, const U32 dtLog) 
+{ 
+    BYTE* const pStart = p; 
+ 
+    /* up to 8 symbols at a time */ 
+    while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p < pEnd-7)) { 
+        HUFv05_DECODE_SYMBOLX4_2(p, bitDPtr); 
+        HUFv05_DECODE_SYMBOLX4_1(p, bitDPtr); 
+        HUFv05_DECODE_SYMBOLX4_2(p, bitDPtr); 
+        HUFv05_DECODE_SYMBOLX4_0(p, bitDPtr); 
+    } 
+ 
+    /* closer to the end */ 
+    while ((BITv05_reloadDStream(bitDPtr) == BITv05_DStream_unfinished) && (p <= pEnd-2)) 
+        HUFv05_DECODE_SYMBOLX4_0(p, bitDPtr); 
+ 
+    while (p <= pEnd-2) 
+        HUFv05_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */ 
+ 
+    if (p < pEnd) 
+        p += HUFv05_decodeLastSymbolX4(p, bitDPtr, dt, dtLog); 
+ 
+    return p-pStart; 
+} 
+ 
+ 
+size_t HUFv05_decompress1X4_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const U32* DTable) 
+{ 
+    const BYTE* const istart = (const BYTE*) cSrc; 
+    BYTE* const ostart = (BYTE*) dst; 
+    BYTE* const oend = ostart + dstSize; 
+ 
+    const U32 dtLog = DTable[0]; 
+    const void* const dtPtr = DTable; 
+    const HUFv05_DEltX4* const dt = ((const HUFv05_DEltX4*)dtPtr) +1; 
+    size_t errorCode; 
+ 
+    /* Init */ 
+    BITv05_DStream_t bitD; 
+    errorCode = BITv05_initDStream(&bitD, istart, cSrcSize); 
+    if (HUFv05_isError(errorCode)) return errorCode; 
+ 
+    /* finish bitStreams one by one */ 
+    HUFv05_decodeStreamX4(ostart, &bitD, oend,     dt, dtLog); 
+ 
+    /* check */ 
+    if (!BITv05_endOfDStream(&bitD)) return ERROR(corruption_detected); 
+ 
+    /* decoded size */ 
+    return dstSize; 
+} 
+ 
+size_t HUFv05_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUFv05_CREATE_STATIC_DTABLEX4(DTable, HUFv05_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
+    size_t hSize = HUFv05_readDTableX4 (DTable, cSrc, cSrcSize); 
+    if (HUFv05_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; 
+    cSrcSize -= hSize; 
+ 
+    return HUFv05_decompress1X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable); 
+} 
+ 
+size_t HUFv05_decompress4X4_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const U32* DTable) 
+{ 
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */ 
+ 
+    { 
+        const BYTE* const istart = (const BYTE*) cSrc; 
+        BYTE* const ostart = (BYTE*) dst; 
+        BYTE* const oend = ostart + dstSize; 
+        const void* const dtPtr = DTable; 
+        const HUFv05_DEltX4* const dt = ((const HUFv05_DEltX4*)dtPtr) +1; 
+        const U32 dtLog = DTable[0]; 
+        size_t errorCode; 
+ 
+        /* Init */ 
+        BITv05_DStream_t bitD1; 
+        BITv05_DStream_t bitD2; 
+        BITv05_DStream_t bitD3; 
+        BITv05_DStream_t bitD4; 
+        const size_t length1 = MEM_readLE16(istart); 
+        const size_t length2 = MEM_readLE16(istart+2); 
+        const size_t length3 = MEM_readLE16(istart+4); 
+        size_t length4; 
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */ 
+        const BYTE* const istart2 = istart1 + length1; 
+        const BYTE* const istart3 = istart2 + length2; 
+        const BYTE* const istart4 = istart3 + length3; 
+        const size_t segmentSize = (dstSize+3) / 4; 
+        BYTE* const opStart2 = ostart + segmentSize; 
+        BYTE* const opStart3 = opStart2 + segmentSize; 
+        BYTE* const opStart4 = opStart3 + segmentSize; 
+        BYTE* op1 = ostart; 
+        BYTE* op2 = opStart2; 
+        BYTE* op3 = opStart3; 
+        BYTE* op4 = opStart4; 
+        U32 endSignal; 
+ 
+        length4 = cSrcSize - (length1 + length2 + length3 + 6); 
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */ 
+        errorCode = BITv05_initDStream(&bitD1, istart1, length1); 
+        if (HUFv05_isError(errorCode)) return errorCode; 
+        errorCode = BITv05_initDStream(&bitD2, istart2, length2); 
+        if (HUFv05_isError(errorCode)) return errorCode; 
+        errorCode = BITv05_initDStream(&bitD3, istart3, length3); 
+        if (HUFv05_isError(errorCode)) return errorCode; 
+        errorCode = BITv05_initDStream(&bitD4, istart4, length4); 
+        if (HUFv05_isError(errorCode)) return errorCode; 
+ 
+        /* 16-32 symbols per loop (4-8 symbols per stream) */ 
+        endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4); 
+        for ( ; (endSignal==BITv05_DStream_unfinished) && (op4<(oend-7)) ; ) { 
+            HUFv05_DECODE_SYMBOLX4_2(op1, &bitD1); 
+            HUFv05_DECODE_SYMBOLX4_2(op2, &bitD2); 
+            HUFv05_DECODE_SYMBOLX4_2(op3, &bitD3); 
+            HUFv05_DECODE_SYMBOLX4_2(op4, &bitD4); 
+            HUFv05_DECODE_SYMBOLX4_1(op1, &bitD1); 
+            HUFv05_DECODE_SYMBOLX4_1(op2, &bitD2); 
+            HUFv05_DECODE_SYMBOLX4_1(op3, &bitD3); 
+            HUFv05_DECODE_SYMBOLX4_1(op4, &bitD4); 
+            HUFv05_DECODE_SYMBOLX4_2(op1, &bitD1); 
+            HUFv05_DECODE_SYMBOLX4_2(op2, &bitD2); 
+            HUFv05_DECODE_SYMBOLX4_2(op3, &bitD3); 
+            HUFv05_DECODE_SYMBOLX4_2(op4, &bitD4); 
+            HUFv05_DECODE_SYMBOLX4_0(op1, &bitD1); 
+            HUFv05_DECODE_SYMBOLX4_0(op2, &bitD2); 
+            HUFv05_DECODE_SYMBOLX4_0(op3, &bitD3); 
+            HUFv05_DECODE_SYMBOLX4_0(op4, &bitD4); 
+ 
+            endSignal = BITv05_reloadDStream(&bitD1) | BITv05_reloadDStream(&bitD2) | BITv05_reloadDStream(&bitD3) | BITv05_reloadDStream(&bitD4); 
+        } 
+ 
+        /* check corruption */ 
+        if (op1 > opStart2) return ERROR(corruption_detected); 
+        if (op2 > opStart3) return ERROR(corruption_detected); 
+        if (op3 > opStart4) return ERROR(corruption_detected); 
+        /* note : op4 supposed already verified within main loop */ 
+ 
+        /* finish bitStreams one by one */ 
+        HUFv05_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog); 
+        HUFv05_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog); 
+        HUFv05_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog); 
+        HUFv05_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog); 
+ 
+        /* check */ 
+        endSignal = BITv05_endOfDStream(&bitD1) & BITv05_endOfDStream(&bitD2) & BITv05_endOfDStream(&bitD3) & BITv05_endOfDStream(&bitD4); 
+        if (!endSignal) return ERROR(corruption_detected); 
+ 
+        /* decoded size */ 
+        return dstSize; 
+    } 
+} 
+ 
+ 
+size_t HUFv05_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUFv05_CREATE_STATIC_DTABLEX4(DTable, HUFv05_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
+    size_t hSize = HUFv05_readDTableX4 (DTable, cSrc, cSrcSize); 
+    if (HUFv05_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; 
+    cSrcSize -= hSize; 
+ 
+    return HUFv05_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable); 
+} 
+ 
+ 
+/* ********************************/ 
+/* Generic decompression selector */ 
+/* ********************************/ 
+ 
+typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t; 
+static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, quad */] = 
+{ 
+    /* single, double, quad */ 
+    {{0,0}, {1,1}, {2,2}},  /* Q==0 : impossible */ 
+    {{0,0}, {1,1}, {2,2}},  /* Q==1 : impossible */ 
+    {{  38,130}, {1313, 74}, {2151, 38}},   /* Q == 2 : 12-18% */ 
+    {{ 448,128}, {1353, 74}, {2238, 41}},   /* Q == 3 : 18-25% */ 
+    {{ 556,128}, {1353, 74}, {2238, 47}},   /* Q == 4 : 25-32% */ 
+    {{ 714,128}, {1418, 74}, {2436, 53}},   /* Q == 5 : 32-38% */ 
+    {{ 883,128}, {1437, 74}, {2464, 61}},   /* Q == 6 : 38-44% */ 
+    {{ 897,128}, {1515, 75}, {2622, 68}},   /* Q == 7 : 44-50% */ 
+    {{ 926,128}, {1613, 75}, {2730, 75}},   /* Q == 8 : 50-56% */ 
+    {{ 947,128}, {1729, 77}, {3359, 77}},   /* Q == 9 : 56-62% */ 
+    {{1107,128}, {2083, 81}, {4006, 84}},   /* Q ==10 : 62-69% */ 
+    {{1177,128}, {2379, 87}, {4785, 88}},   /* Q ==11 : 69-75% */ 
+    {{1242,128}, {2415, 93}, {5155, 84}},   /* Q ==12 : 75-81% */ 
+    {{1349,128}, {2644,106}, {5260,106}},   /* Q ==13 : 81-87% */ 
+    {{1455,128}, {2422,124}, {4174,124}},   /* Q ==14 : 87-93% */ 
+    {{ 722,128}, {1891,145}, {1936,146}},   /* Q ==15 : 93-99% */ 
+}; 
+ 
+typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); 
+ 
+size_t HUFv05_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
     static const decompressionAlgo decompress[3] = { HUFv05_decompress4X2, HUFv05_decompress4X4, NULL };
-    /* estimate decompression time */
-    U32 Q;
-    const U32 D256 = (U32)(dstSize >> 8);
-    U32 Dtime[3];
-    U32 algoNb = 0;
-    int n;
-
-    /* validation checks */
-    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    /* estimate decompression time */ 
+    U32 Q; 
+    const U32 D256 = (U32)(dstSize >> 8); 
+    U32 Dtime[3]; 
+    U32 algoNb = 0; 
+    int n; 
+ 
+    /* validation checks */ 
+    if (dstSize == 0) return ERROR(dstSize_tooSmall); 
     if (cSrcSize >= dstSize) return ERROR(corruption_detected);   /* invalid, or not compressed, but not compressed already dealt with */
-    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
-
-    /* decoder timing evaluation */
-    Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */
-    for (n=0; n<3; n++)
-        Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256);
-
-    Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */
-
-    if (Dtime[1] < Dtime[0]) algoNb = 1;
-
-    return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
-
-    //return HUFv05_decompress4X2(dst, dstSize, cSrc, cSrcSize);   /* multi-streams single-symbol decoding */
-    //return HUFv05_decompress4X4(dst, dstSize, cSrc, cSrcSize);   /* multi-streams double-symbols decoding */
-    //return HUFv05_decompress4X6(dst, dstSize, cSrc, cSrcSize);   /* multi-streams quad-symbols decoding */
-}
-/*
-    zstd - standard compression library
-    Copyright (C) 2014-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 source repository : https://github.com/Cyan4973/zstd
-*/
-
-/* ***************************************************************
-*  Tuning parameters
-*****************************************************************/
-/*!
- * HEAPMODE :
- * Select how default decompression function ZSTDv05_decompress() will allocate memory,
- * in memory stack (0), or in memory heap (1, requires malloc())
- */
-#ifndef ZSTDv05_HEAPMODE
-#  define ZSTDv05_HEAPMODE 1
-#endif
-
-
-/*-*******************************************************
-*  Dependencies
-*********************************************************/
-#include <stdlib.h>      /* calloc */
-#include <string.h>      /* memcpy, memmove */
-#include <stdio.h>       /* debug only : printf */
-
-
-/*-*******************************************************
-*  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 : 4324)        /* disable: C4324: padded structure */
-#else
-#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#  ifdef __GNUC__
-#    define FORCE_INLINE static inline __attribute__((always_inline))
-#  else
-#    define FORCE_INLINE static inline
-#  endif
-#endif
-
-
-/*-*************************************
-*  Local types
-***************************************/
-typedef struct
-{
-    blockType_t blockType;
-    U32 origSize;
-} blockProperties_t;
-
-
-/* *******************************************************
-*  Memory operations
-**********************************************************/
-static void ZSTDv05_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
-
-
-/* *************************************
-*  Error Management
-***************************************/
-/*! ZSTDv05_isError() :
-*   tells if a return value is an error code */
-unsigned ZSTDv05_isError(size_t code) { return ERR_isError(code); }
-
-/*! ZSTDv05_getError() :
-*   convert a `size_t` function result into a proper ZSTDv05_errorCode enum */
-ZSTDv05_ErrorCode ZSTDv05_getError(size_t code) { return ERR_getError(code); }
-
-/*! ZSTDv05_getErrorName() :
-*   provides error code string (useful for debugging) */
-const char* ZSTDv05_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-
-/* *************************************************************
-*   Context management
-***************************************************************/
-typedef enum { ZSTDv05ds_getFrameHeaderSize, ZSTDv05ds_decodeFrameHeader,
-               ZSTDv05ds_decodeBlockHeader, ZSTDv05ds_decompressBlock } ZSTDv05_dStage;
-
-struct ZSTDv05_DCtx_s
-{
-    FSEv05_DTable LLTable[FSEv05_DTABLE_SIZE_U32(LLFSEv05Log)];
-    FSEv05_DTable OffTable[FSEv05_DTABLE_SIZE_U32(OffFSEv05Log)];
-    FSEv05_DTable MLTable[FSEv05_DTABLE_SIZE_U32(MLFSEv05Log)];
-    unsigned   hufTableX4[HUFv05_DTABLE_SIZE(HufLog)];
-    const void* previousDstEnd;
-    const void* base;
-    const void* vBase;
-    const void* dictEnd;
-    size_t expected;
-    size_t headerSize;
-    ZSTDv05_parameters params;
-    blockType_t bType;   /* used in ZSTDv05_decompressContinue(), to transfer blockType between header decoding and block decoding stages */
-    ZSTDv05_dStage stage;
-    U32 flagStaticTables;
-    const BYTE* litPtr;
-    size_t litBufSize;
-    size_t litSize;
-    BYTE litBuffer[BLOCKSIZE + WILDCOPY_OVERLENGTH];
-    BYTE headerBuffer[ZSTDv05_frameHeaderSize_max];
-};  /* typedef'd to ZSTDv05_DCtx within "zstd_static.h" */
-
-size_t ZSTDv05_sizeofDCtx (void) { return sizeof(ZSTDv05_DCtx); }
-
-size_t ZSTDv05_decompressBegin(ZSTDv05_DCtx* dctx)
-{
-    dctx->expected = ZSTDv05_frameHeaderSize_min;
-    dctx->stage = ZSTDv05ds_getFrameHeaderSize;
-    dctx->previousDstEnd = NULL;
-    dctx->base = NULL;
-    dctx->vBase = NULL;
-    dctx->dictEnd = NULL;
-    dctx->hufTableX4[0] = HufLog;
-    dctx->flagStaticTables = 0;
-    return 0;
-}
-
-ZSTDv05_DCtx* ZSTDv05_createDCtx(void)
-{
-    ZSTDv05_DCtx* dctx = (ZSTDv05_DCtx*)malloc(sizeof(ZSTDv05_DCtx));
-    if (dctx==NULL) return NULL;
-    ZSTDv05_decompressBegin(dctx);
-    return dctx;
-}
-
-size_t ZSTDv05_freeDCtx(ZSTDv05_DCtx* dctx)
-{
-    free(dctx);
-    return 0;   /* reserved as a potential error code in the future */
-}
-
-void ZSTDv05_copyDCtx(ZSTDv05_DCtx* dstDCtx, const ZSTDv05_DCtx* srcDCtx)
-{
-    memcpy(dstDCtx, srcDCtx,
-           sizeof(ZSTDv05_DCtx) - (BLOCKSIZE+WILDCOPY_OVERLENGTH + ZSTDv05_frameHeaderSize_max));  /* no need to copy workspace */
-}
-
-
-/* *************************************************************
-*   Decompression section
-***************************************************************/
-
-/* Frame format description
-   Frame Header -  [ Block Header - Block ] - Frame End
-   1) Frame Header
-      - 4 bytes - Magic Number : ZSTDv05_MAGICNUMBER (defined within zstd_internal.h)
-      - 1 byte  - Window Descriptor
-   2) Block Header
-      - 3 bytes, starting with a 2-bits descriptor
-                 Uncompressed, Compressed, Frame End, unused
-   3) Block
-      See Block Format Description
-   4) Frame End
-      - 3 bytes, compatible with Block Header
-*/
-
-/* Block format description
-
-   Block = Literal Section - Sequences Section
-   Prerequisite : size of (compressed) block, maximum size of regenerated data
-
-   1) Literal Section
-
-   1.1) Header : 1-5 bytes
-        flags: 2 bits
-            00 compressed by Huff0
-            01 unused
-            10 is Raw (uncompressed)
-            11 is Rle
-            Note : using 01 => Huff0 with precomputed table ?
-            Note : delta map ? => compressed ?
-
-   1.1.1) Huff0-compressed literal block : 3-5 bytes
-            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream
-            srcSize < 1 KB => 3 bytes (2-2-10-10)
-            srcSize < 16KB => 4 bytes (2-2-14-14)
-            else           => 5 bytes (2-2-18-18)
-            big endian convention
-
-   1.1.2) Raw (uncompressed) literal block header : 1-3 bytes
-        size :  5 bits: (IS_RAW<<6) + (0<<4) + size
-               12 bits: (IS_RAW<<6) + (2<<4) + (size>>8)
-                        size&255
-               20 bits: (IS_RAW<<6) + (3<<4) + (size>>16)
-                        size>>8&255
-                        size&255
-
-   1.1.3) Rle (repeated single byte) literal block header : 1-3 bytes
-        size :  5 bits: (IS_RLE<<6) + (0<<4) + size
-               12 bits: (IS_RLE<<6) + (2<<4) + (size>>8)
-                        size&255
-               20 bits: (IS_RLE<<6) + (3<<4) + (size>>16)
-                        size>>8&255
-                        size&255
-
-   1.1.4) Huff0-compressed literal block, using precomputed CTables : 3-5 bytes
-            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream
-            srcSize < 1 KB => 3 bytes (2-2-10-10)
-            srcSize < 16KB => 4 bytes (2-2-14-14)
-            else           => 5 bytes (2-2-18-18)
-            big endian convention
-
-        1- CTable available (stored into workspace ?)
-        2- Small input (fast heuristic ? Full comparison ? depend on clevel ?)
-
-
-   1.2) Literal block content
-
-   1.2.1) Huff0 block, using sizes from header
-        See Huff0 format
-
-   1.2.2) Huff0 block, using prepared table
-
-   1.2.3) Raw content
-
-   1.2.4) single byte
-
-
-   2) Sequences section
-      TO DO
-*/
-
-
-/** ZSTDv05_decodeFrameHeader_Part1() :
-*   decode the 1st part of the Frame Header, which tells Frame Header size.
-*   srcSize must be == ZSTDv05_frameHeaderSize_min.
-*   @return : the full size of the Frame Header */
-static size_t ZSTDv05_decodeFrameHeader_Part1(ZSTDv05_DCtx* zc, const void* src, size_t srcSize)
-{
-    U32 magicNumber;
-    if (srcSize != ZSTDv05_frameHeaderSize_min)
-        return ERROR(srcSize_wrong);
-    magicNumber = MEM_readLE32(src);
-    if (magicNumber != ZSTDv05_MAGICNUMBER) return ERROR(prefix_unknown);
-    zc->headerSize = ZSTDv05_frameHeaderSize_min;
-    return zc->headerSize;
-}
-
-
-size_t ZSTDv05_getFrameParams(ZSTDv05_parameters* params, const void* src, size_t srcSize)
-{
-    U32 magicNumber;
-    if (srcSize < ZSTDv05_frameHeaderSize_min) return ZSTDv05_frameHeaderSize_max;
-    magicNumber = MEM_readLE32(src);
-    if (magicNumber != ZSTDv05_MAGICNUMBER) return ERROR(prefix_unknown);
-    memset(params, 0, sizeof(*params));
-    params->windowLog = (((const BYTE*)src)[4] & 15) + ZSTDv05_WINDOWLOG_ABSOLUTEMIN;
-    if ((((const BYTE*)src)[4] >> 4) != 0) return ERROR(frameParameter_unsupported);   /* reserved bits */
-    return 0;
-}
-
-/** ZSTDv05_decodeFrameHeader_Part2() :
-*   decode the full Frame Header.
-*   srcSize must be the size provided by ZSTDv05_decodeFrameHeader_Part1().
-*   @return : 0, or an error code, which can be tested using ZSTDv05_isError() */
-static size_t ZSTDv05_decodeFrameHeader_Part2(ZSTDv05_DCtx* zc, const void* src, size_t srcSize)
-{
-    size_t result;
-    if (srcSize != zc->headerSize)
-        return ERROR(srcSize_wrong);
-    result = ZSTDv05_getFrameParams(&(zc->params), src, srcSize);
-    if ((MEM_32bits()) && (zc->params.windowLog > 25)) return ERROR(frameParameter_unsupportedBy32bits);
-    return result;
-}
-
-
-size_t ZSTDv05_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
-{
-    const BYTE* const in = (const BYTE* const)src;
-    BYTE headerFlags;
-    U32 cSize;
-
-    if (srcSize < 3)
-        return ERROR(srcSize_wrong);
-
-    headerFlags = *in;
-    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);
-
-    bpPtr->blockType = (blockType_t)(headerFlags >> 6);
-    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;
-
-    if (bpPtr->blockType == bt_end) return 0;
-    if (bpPtr->blockType == bt_rle) return 1;
-    return cSize;
-}
-
-
-static size_t ZSTDv05_copyRawBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall);
-    memcpy(dst, src, srcSize);
-    return srcSize;
-}
-
-
-/*! ZSTDv05_decodeLiteralsBlock() :
-    @return : nb of bytes read from src (< srcSize ) */
-size_t ZSTDv05_decodeLiteralsBlock(ZSTDv05_DCtx* dctx,
-                          const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */
-{
-    const BYTE* const istart = (const BYTE*) src;
-
-    /* any compressed block with literals segment must be at least this size */
-    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
-
-    switch(istart[0]>> 6)
-    {
-    case IS_HUFv05:
-        {
-            size_t litSize, litCSize, singleStream=0;
-            U32 lhSize = ((istart[0]) >> 4) & 3;
-            switch(lhSize)
-            {
-            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
-                /* 2 - 2 - 10 - 10 */
-                lhSize=3;
-                singleStream = istart[0] & 16;
-                litSize  = ((istart[0] & 15) << 6) + (istart[1] >> 2);
-                litCSize = ((istart[1] &  3) << 8) + istart[2];
-                break;
-            case 2:
-                /* 2 - 2 - 14 - 14 */
-                lhSize=4;
-                litSize  = ((istart[0] & 15) << 10) + (istart[1] << 2) + (istart[2] >> 6);
-                litCSize = ((istart[2] & 63) <<  8) + istart[3];
-                break;
-            case 3:
-                /* 2 - 2 - 18 - 18 */
-                lhSize=5;
-                litSize  = ((istart[0] & 15) << 14) + (istart[1] << 6) + (istart[2] >> 2);
-                litCSize = ((istart[2] &  3) << 16) + (istart[3] << 8) + istart[4];
-                break;
-            }
-            if (litSize > BLOCKSIZE) return ERROR(corruption_detected);
-
-            if (HUFv05_isError(singleStream ?
-                            HUFv05_decompress1X2(dctx->litBuffer, litSize, istart+lhSize, litCSize) :
-                            HUFv05_decompress   (dctx->litBuffer, litSize, istart+lhSize, litCSize) ))
-                return ERROR(corruption_detected);
-
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litBufSize = BLOCKSIZE+8;
-            dctx->litSize = litSize;
-            return litCSize + lhSize;
-        }
-    case IS_PCH:
-        {
-            size_t errorCode;
-            size_t litSize, litCSize;
-            U32 lhSize = ((istart[0]) >> 4) & 3;
-            if (lhSize != 1)  /* only case supported for now : small litSize, single stream */
-                return ERROR(corruption_detected);
-            if (!dctx->flagStaticTables)
-                return ERROR(dictionary_corrupted);
-
-            /* 2 - 2 - 10 - 10 */
-            lhSize=3;
-            litSize  = ((istart[0] & 15) << 6) + (istart[1] >> 2);
-            litCSize = ((istart[1] &  3) << 8) + istart[2];
-
-            errorCode = HUFv05_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTableX4);
-            if (HUFv05_isError(errorCode)) return ERROR(corruption_detected);
-
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litBufSize = BLOCKSIZE+WILDCOPY_OVERLENGTH;
-            dctx->litSize = litSize;
-            return litCSize + lhSize;
-        }
-    case IS_RAW:
-        {
-            size_t litSize;
-            U32 lhSize = ((istart[0]) >> 4) & 3;
-            switch(lhSize)
-            {
-            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
-                lhSize=1;
-                litSize = istart[0] & 31;
-                break;
-            case 2:
-                litSize = ((istart[0] & 15) << 8) + istart[1];
-                break;
-            case 3:
-                litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];
-                break;
-            }
-
-            if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) {  /* risk reading beyond src buffer with wildcopy */
-                if (litSize+lhSize > srcSize) return ERROR(corruption_detected);
-                memcpy(dctx->litBuffer, istart+lhSize, litSize);
-                dctx->litPtr = dctx->litBuffer;
-                dctx->litBufSize = BLOCKSIZE+8;
-                dctx->litSize = litSize;
-                return lhSize+litSize;
-            }
-            /* direct reference into compressed stream */
-            dctx->litPtr = istart+lhSize;
-            dctx->litBufSize = srcSize-lhSize;
-            dctx->litSize = litSize;
-            return lhSize+litSize;
-        }
-    case IS_RLE:
-        {
-            size_t litSize;
-            U32 lhSize = ((istart[0]) >> 4) & 3;
-            switch(lhSize)
-            {
-            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */
-                lhSize = 1;
-                litSize = istart[0] & 31;
-                break;
-            case 2:
-                litSize = ((istart[0] & 15) << 8) + istart[1];
-                break;
-            case 3:
-                litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2];
-                break;
-            }
-            if (litSize > BLOCKSIZE) return ERROR(corruption_detected);
-            memset(dctx->litBuffer, istart[lhSize], litSize);
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litBufSize = BLOCKSIZE+WILDCOPY_OVERLENGTH;
-            dctx->litSize = litSize;
-            return lhSize+1;
-        }
-    default:
-        return ERROR(corruption_detected);   /* impossible */
-    }
-}
-
-
-size_t ZSTDv05_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,
-                         FSEv05_DTable* DTableLL, FSEv05_DTable* DTableML, FSEv05_DTable* DTableOffb,
-                         const void* src, size_t srcSize)
-{
-    const BYTE* const istart = (const BYTE* const)src;
-    const BYTE* ip = istart;
-    const BYTE* const iend = istart + srcSize;
-    U32 LLtype, Offtype, MLtype;
-    U32 LLlog, Offlog, MLlog;
-    size_t dumpsLength;
-
-    /* check */
-    if (srcSize < MIN_SEQUENCES_SIZE)
-        return ERROR(srcSize_wrong);
-
-    /* SeqHead */
-    *nbSeq = *ip++;
-    if (*nbSeq==0) return 1;
-    if (*nbSeq >= 128)
-        *nbSeq = ((nbSeq[0]-128)<<8) + *ip++;
-
-    LLtype  = *ip >> 6;
-    Offtype = (*ip >> 4) & 3;
-    MLtype  = (*ip >> 2) & 3;
-    if (*ip & 2) {
-        dumpsLength  = ip[2];
-        dumpsLength += ip[1] << 8;
-        ip += 3;
-    } else {
-        dumpsLength  = ip[1];
-        dumpsLength += (ip[0] & 1) << 8;
-        ip += 2;
-    }
-    *dumpsPtr = ip;
-    ip += dumpsLength;
-    *dumpsLengthPtr = dumpsLength;
-
-    /* check */
-    if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */
-
-    /* sequences */
-    {
-        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL >= MaxOff */
-        size_t headerSize;
-
-        /* Build DTables */
-        switch(LLtype)
-        {
-        U32 max;
-        case FSEv05_ENCODING_RLE :
-            LLlog = 0;
-            FSEv05_buildDTable_rle(DTableLL, *ip++);
-            break;
-        case FSEv05_ENCODING_RAW :
-            LLlog = LLbits;
-            FSEv05_buildDTable_raw(DTableLL, LLbits);
-            break;
-        case FSEv05_ENCODING_STATIC:
-            break;
-        case FSEv05_ENCODING_DYNAMIC :
-        default :   /* impossible */
-            max = MaxLL;
-            headerSize = FSEv05_readNCount(norm, &max, &LLlog, ip, iend-ip);
-            if (FSEv05_isError(headerSize)) return ERROR(GENERIC);
-            if (LLlog > LLFSEv05Log) return ERROR(corruption_detected);
-            ip += headerSize;
-            FSEv05_buildDTable(DTableLL, norm, max, LLlog);
-        }
-
-        switch(Offtype)
-        {
-        U32 max;
-        case FSEv05_ENCODING_RLE :
-            Offlog = 0;
-            if (ip > iend-2) return ERROR(srcSize_wrong);   /* min : "raw", hence no header, but at least xxLog bits */
-            FSEv05_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */
-            break;
-        case FSEv05_ENCODING_RAW :
-            Offlog = Offbits;
-            FSEv05_buildDTable_raw(DTableOffb, Offbits);
-            break;
-        case FSEv05_ENCODING_STATIC:
-            break;
-        case FSEv05_ENCODING_DYNAMIC :
-        default :   /* impossible */
-            max = MaxOff;
-            headerSize = FSEv05_readNCount(norm, &max, &Offlog, ip, iend-ip);
-            if (FSEv05_isError(headerSize)) return ERROR(GENERIC);
-            if (Offlog > OffFSEv05Log) return ERROR(corruption_detected);
-            ip += headerSize;
-            FSEv05_buildDTable(DTableOffb, norm, max, Offlog);
-        }
-
-        switch(MLtype)
-        {
-        U32 max;
-        case FSEv05_ENCODING_RLE :
-            MLlog = 0;
-            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */
-            FSEv05_buildDTable_rle(DTableML, *ip++);
-            break;
-        case FSEv05_ENCODING_RAW :
-            MLlog = MLbits;
-            FSEv05_buildDTable_raw(DTableML, MLbits);
-            break;
-        case FSEv05_ENCODING_STATIC:
-            break;
-        case FSEv05_ENCODING_DYNAMIC :
-        default :   /* impossible */
-            max = MaxML;
-            headerSize = FSEv05_readNCount(norm, &max, &MLlog, ip, iend-ip);
-            if (FSEv05_isError(headerSize)) return ERROR(GENERIC);
-            if (MLlog > MLFSEv05Log) return ERROR(corruption_detected);
-            ip += headerSize;
-            FSEv05_buildDTable(DTableML, norm, max, MLlog);
-    }   }
-
-    return ip-istart;
-}
-
-
-typedef struct {
-    size_t litLength;
-    size_t matchLength;
-    size_t offset;
-} seq_t;
-
-typedef struct {
-    BITv05_DStream_t DStream;
-    FSEv05_DState_t stateLL;
-    FSEv05_DState_t stateOffb;
-    FSEv05_DState_t stateML;
-    size_t prevOffset;
-    const BYTE* dumps;
-    const BYTE* dumpsEnd;
-} seqState_t;
-
-
-
-static void ZSTDv05_decodeSequence(seq_t* seq, seqState_t* seqState)
-{
-    size_t litLength;
-    size_t prevOffset;
-    size_t offset;
-    size_t matchLength;
-    const BYTE* dumps = seqState->dumps;
-    const BYTE* const de = seqState->dumpsEnd;
-
-    /* Literal length */
-    litLength = FSEv05_peakSymbol(&(seqState->stateLL));
-    prevOffset = litLength ? seq->offset : seqState->prevOffset;
-    if (litLength == MaxLL) {
-        U32 add = *dumps++;
-        if (add < 255) litLength += add;
-        else {
-            litLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no risk : dumps is always followed by seq tables > 1 byte */
-            if (litLength&1) litLength>>=1, dumps += 3;
-            else litLength = (U16)(litLength)>>1, dumps += 2;
-        }
-        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */
-    }
-
-    /* Offset */
-    {
-        static const U32 offsetPrefix[MaxOff+1] = {
-                1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256,
-                512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
-                524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 };
-        U32 offsetCode = FSEv05_peakSymbol(&(seqState->stateOffb));   /* <= maxOff, by table construction */
-        U32 nbBits = offsetCode - 1;
-        if (offsetCode==0) nbBits = 0;   /* cmove */
-        offset = offsetPrefix[offsetCode] + BITv05_readBits(&(seqState->DStream), nbBits);
-        if (MEM_32bits()) BITv05_reloadDStream(&(seqState->DStream));
-        if (offsetCode==0) offset = prevOffset;   /* repcode, cmove */
-        if (offsetCode | !litLength) seqState->prevOffset = seq->offset;   /* cmove */
-        FSEv05_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream));    /* update */
-    }
-
-    /* Literal length update */
-    FSEv05_decodeSymbol(&(seqState->stateLL), &(seqState->DStream));   /* update */
-    if (MEM_32bits()) BITv05_reloadDStream(&(seqState->DStream));
-
-    /* MatchLength */
-    matchLength = FSEv05_decodeSymbol(&(seqState->stateML), &(seqState->DStream));
-    if (matchLength == MaxML) {
-        U32 add = *dumps++;
-        if (add < 255) matchLength += add;
-        else {
-            matchLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */
-            if (matchLength&1) matchLength>>=1, dumps += 3;
-            else matchLength = (U16)(matchLength)>>1, dumps += 2;
-        }
-        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */
-    }
-    matchLength += MINMATCH;
-
-    /* save result */
-    seq->litLength = litLength;
-    seq->offset = offset;
-    seq->matchLength = matchLength;
-    seqState->dumps = dumps;
-
-#if 0   /* debug */
-    {
-        static U64 totalDecoded = 0;
-        printf("pos %6u : %3u literals & match %3u bytes at distance %6u \n",
-           (U32)(totalDecoded), (U32)litLength, (U32)matchLength, (U32)offset);
-        totalDecoded += litLength + matchLength;
-    }
-#endif
-}
-
-
-static size_t ZSTDv05_execSequence(BYTE* op,
-                                BYTE* const oend, seq_t sequence,
-                                const BYTE** litPtr, const BYTE* const litLimit_8,
-                                const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd)
-{
-    static const int dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */
-    static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 };   /* substracted */
-    BYTE* const oLitEnd = op + sequence.litLength;
-    const size_t sequenceLength = sequence.litLength + sequence.matchLength;
-    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */
-    BYTE* const oend_8 = oend-8;
-    const BYTE* const litEnd = *litPtr + sequence.litLength;
-    const BYTE* match = oLitEnd - sequence.offset;
-
-    /* check */
-    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */
-    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */
-    if (litEnd > litLimit_8) return ERROR(corruption_detected);   /* risk read beyond lit buffer */
-
-    /* copy Literals */
-    ZSTDv05_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */
-    op = oLitEnd;
-    *litPtr = litEnd;   /* update for next sequence */
-
-    /* copy Match */
-    if (sequence.offset > (size_t)(oLitEnd - base)) {
-        /* offset beyond prefix */
-        if (sequence.offset > (size_t)(oLitEnd - vBase))
-            return ERROR(corruption_detected);
-        match = dictEnd - (base-match);
-        if (match + sequence.matchLength <= dictEnd) {
-            memmove(oLitEnd, match, sequence.matchLength);
-            return sequenceLength;
-        }
-        /* span extDict & currentPrefixSegment */
-        {
-            size_t length1 = dictEnd - match;
-            memmove(oLitEnd, match, length1);
-            op = oLitEnd + length1;
-            sequence.matchLength -= length1;
-            match = base;
-    }   }
-
-    /* match within prefix */
-    if (sequence.offset < 8) {
-        /* close range match, overlap */
-        const int sub2 = dec64table[sequence.offset];
-        op[0] = match[0];
-        op[1] = match[1];
-        op[2] = match[2];
-        op[3] = match[3];
-        match += dec32table[sequence.offset];
-        ZSTDv05_copy4(op+4, match);
-        match -= sub2;
-    } else {
-        ZSTDv05_copy8(op, match);
-    }
-    op += 8; match += 8;
-
-    if (oMatchEnd > oend-12) {
-        if (op < oend_8) {
-            ZSTDv05_wildcopy(op, match, oend_8 - op);
-            match += oend_8 - op;
-            op = oend_8;
-        }
-        while (op < oMatchEnd)
-            *op++ = *match++;
-    } else {
-        ZSTDv05_wildcopy(op, match, sequence.matchLength-8);   /* works even if matchLength < 8 */
-    }
-    return sequenceLength;
-}
-
-
-static size_t ZSTDv05_decompressSequences(
-                               ZSTDv05_DCtx* dctx,
-                               void* dst, size_t maxDstSize,
-                         const void* seqStart, size_t seqSize)
-{
-    const BYTE* ip = (const BYTE*)seqStart;
-    const BYTE* const iend = ip + seqSize;
-    BYTE* const ostart = (BYTE* const)dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + maxDstSize;
-    size_t errorCode, dumpsLength;
-    const BYTE* litPtr = dctx->litPtr;
-    const BYTE* const litLimit_8 = litPtr + dctx->litBufSize - 8;
-    const BYTE* const litEnd = litPtr + dctx->litSize;
-    int nbSeq;
-    const BYTE* dumps;
-    U32* DTableLL = dctx->LLTable;
-    U32* DTableML = dctx->MLTable;
-    U32* DTableOffb = dctx->OffTable;
-    const BYTE* const base = (const BYTE*) (dctx->base);
-    const BYTE* const vBase = (const BYTE*) (dctx->vBase);
-    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);
-
-    /* Build Decoding Tables */
-    errorCode = ZSTDv05_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,
-                                      DTableLL, DTableML, DTableOffb,
-                                      ip, seqSize);
-    if (ZSTDv05_isError(errorCode)) return errorCode;
-    ip += errorCode;
-
-    /* Regen sequences */
-    if (nbSeq) {
-        seq_t sequence;
-        seqState_t seqState;
-
-        memset(&sequence, 0, sizeof(sequence));
-        sequence.offset = REPCODE_STARTVALUE;
-        seqState.dumps = dumps;
-        seqState.dumpsEnd = dumps + dumpsLength;
-        seqState.prevOffset = REPCODE_STARTVALUE;
-        errorCode = BITv05_initDStream(&(seqState.DStream), ip, iend-ip);
-        if (ERR_isError(errorCode)) return ERROR(corruption_detected);
-        FSEv05_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
-        FSEv05_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
-        FSEv05_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
-
-        for ( ; (BITv05_reloadDStream(&(seqState.DStream)) <= BITv05_DStream_completed) && nbSeq ; ) {
-            size_t oneSeqSize;
-            nbSeq--;
-            ZSTDv05_decodeSequence(&sequence, &seqState);
-            oneSeqSize = ZSTDv05_execSequence(op, oend, sequence, &litPtr, litLimit_8, base, vBase, dictEnd);
-            if (ZSTDv05_isError(oneSeqSize)) return oneSeqSize;
-            op += oneSeqSize;
-        }
-
-        /* check if reached exact end */
-        if (nbSeq) return ERROR(corruption_detected);
-    }
-
-    /* last literal segment */
-    {
-        size_t lastLLSize = litEnd - litPtr;
-        if (litPtr > litEnd) return ERROR(corruption_detected);   /* too many literals already used */
-        if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);
-        memcpy(op, litPtr, lastLLSize);
-        op += lastLLSize;
-    }
-
-    return op-ostart;
-}
-
-
-static void ZSTDv05_checkContinuity(ZSTDv05_DCtx* dctx, const void* dst)
-{
-    if (dst != dctx->previousDstEnd) {   /* not contiguous */
-        dctx->dictEnd = dctx->previousDstEnd;
-        dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));
-        dctx->base = dst;
-        dctx->previousDstEnd = dst;
-    }
-}
-
-
-static size_t ZSTDv05_decompressBlock_internal(ZSTDv05_DCtx* dctx,
-                            void* dst, size_t dstCapacity,
-                      const void* src, size_t srcSize)
-{   /* blockType == blockCompressed */
-    const BYTE* ip = (const BYTE*)src;
-    size_t litCSize;
-
-    if (srcSize >= BLOCKSIZE) return ERROR(srcSize_wrong);
-
-    /* Decode literals sub-block */
-    litCSize = ZSTDv05_decodeLiteralsBlock(dctx, src, srcSize);
-    if (ZSTDv05_isError(litCSize)) return litCSize;
-    ip += litCSize;
-    srcSize -= litCSize;
-
-    return ZSTDv05_decompressSequences(dctx, dst, dstCapacity, ip, srcSize);
-}
-
-
-size_t ZSTDv05_decompressBlock(ZSTDv05_DCtx* dctx,
-                            void* dst, size_t dstCapacity,
-                      const void* src, size_t srcSize)
-{
-    ZSTDv05_checkContinuity(dctx, dst);
-    return ZSTDv05_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
-}
-
-
-/*! ZSTDv05_decompress_continueDCtx
-*   dctx must have been properly initialized */
-static size_t ZSTDv05_decompress_continueDCtx(ZSTDv05_DCtx* dctx,
-                                 void* dst, size_t maxDstSize,
-                                 const void* src, size_t srcSize)
-{
-    const BYTE* ip = (const BYTE*)src;
-    const BYTE* iend = ip + srcSize;
-    BYTE* const ostart = (BYTE* const)dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + maxDstSize;
-    size_t remainingSize = srcSize;
-    blockProperties_t blockProperties;
-
-    /* Frame Header */
-    {
-        size_t frameHeaderSize;
-        if (srcSize < ZSTDv05_frameHeaderSize_min+ZSTDv05_blockHeaderSize) return ERROR(srcSize_wrong);
-        frameHeaderSize = ZSTDv05_decodeFrameHeader_Part1(dctx, src, ZSTDv05_frameHeaderSize_min);
-        if (ZSTDv05_isError(frameHeaderSize)) return frameHeaderSize;
-        if (srcSize < frameHeaderSize+ZSTDv05_blockHeaderSize) return ERROR(srcSize_wrong);
-        ip += frameHeaderSize; remainingSize -= frameHeaderSize;
-        frameHeaderSize = ZSTDv05_decodeFrameHeader_Part2(dctx, src, frameHeaderSize);
-        if (ZSTDv05_isError(frameHeaderSize)) return frameHeaderSize;
-    }
-
-    /* Loop on each block */
-    while (1)
-    {
-        size_t decodedSize=0;
-        size_t cBlockSize = ZSTDv05_getcBlockSize(ip, iend-ip, &blockProperties);
-        if (ZSTDv05_isError(cBlockSize)) return cBlockSize;
-
-        ip += ZSTDv05_blockHeaderSize;
-        remainingSize -= ZSTDv05_blockHeaderSize;
-        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);
-
-        switch(blockProperties.blockType)
-        {
-        case bt_compressed:
-            decodedSize = ZSTDv05_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize);
-            break;
-        case bt_raw :
-            decodedSize = ZSTDv05_copyRawBlock(op, oend-op, ip, cBlockSize);
-            break;
-        case bt_rle :
-            return ERROR(GENERIC);   /* not yet supported */
-            break;
-        case bt_end :
-            /* end of frame */
-            if (remainingSize) return ERROR(srcSize_wrong);
-            break;
-        default:
-            return ERROR(GENERIC);   /* impossible */
-        }
-        if (cBlockSize == 0) break;   /* bt_end */
-
-        if (ZSTDv05_isError(decodedSize)) return decodedSize;
-        op += decodedSize;
-        ip += cBlockSize;
-        remainingSize -= cBlockSize;
-    }
-
-    return op-ostart;
-}
-
-
-size_t ZSTDv05_decompress_usingPreparedDCtx(ZSTDv05_DCtx* dctx, const ZSTDv05_DCtx* refDCtx,
-                                         void* dst, size_t maxDstSize,
-                                   const void* src, size_t srcSize)
-{
-    ZSTDv05_copyDCtx(dctx, refDCtx);
-    ZSTDv05_checkContinuity(dctx, dst);
-    return ZSTDv05_decompress_continueDCtx(dctx, dst, maxDstSize, src, srcSize);
-}
-
-
-size_t ZSTDv05_decompress_usingDict(ZSTDv05_DCtx* dctx,
-                                 void* dst, size_t maxDstSize,
-                                 const void* src, size_t srcSize,
-                                 const void* dict, size_t dictSize)
-{
-    ZSTDv05_decompressBegin_usingDict(dctx, dict, dictSize);
-    ZSTDv05_checkContinuity(dctx, dst);
-    return ZSTDv05_decompress_continueDCtx(dctx, dst, maxDstSize, src, srcSize);
-}
-
-
-size_t ZSTDv05_decompressDCtx(ZSTDv05_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    return ZSTDv05_decompress_usingDict(dctx, dst, maxDstSize, src, srcSize, NULL, 0);
-}
-
-size_t ZSTDv05_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-#if defined(ZSTDv05_HEAPMODE) && (ZSTDv05_HEAPMODE==1)
-    size_t regenSize;
-    ZSTDv05_DCtx* dctx = ZSTDv05_createDCtx();
-    if (dctx==NULL) return ERROR(memory_allocation);
-    regenSize = ZSTDv05_decompressDCtx(dctx, dst, maxDstSize, src, srcSize);
-    ZSTDv05_freeDCtx(dctx);
-    return regenSize;
-#else
-    ZSTDv05_DCtx dctx;
-    return ZSTDv05_decompressDCtx(&dctx, dst, maxDstSize, src, srcSize);
-#endif
-}
-
-
-/* ******************************
-*  Streaming Decompression API
-********************************/
-size_t ZSTDv05_nextSrcSizeToDecompress(ZSTDv05_DCtx* dctx)
-{
-    return dctx->expected;
-}
-
-size_t ZSTDv05_decompressContinue(ZSTDv05_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    /* Sanity check */
-    if (srcSize != dctx->expected) return ERROR(srcSize_wrong);
-    ZSTDv05_checkContinuity(dctx, dst);
-
-    /* Decompress : frame header; part 1 */
-    switch (dctx->stage)
-    {
-    case ZSTDv05ds_getFrameHeaderSize :
+    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */ 
+ 
+    /* decoder timing evaluation */ 
+    Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */ 
+    for (n=0; n<3; n++) 
+        Dtime[n] = algoTime[Q][n].tableTime + (algoTime[Q][n].decode256Time * D256); 
+ 
+    Dtime[1] += Dtime[1] >> 4; Dtime[2] += Dtime[2] >> 3; /* advantage to algorithms using less memory, for cache eviction */ 
+ 
+    if (Dtime[1] < Dtime[0]) algoNb = 1; 
+ 
+    return decompress[algoNb](dst, dstSize, cSrc, cSrcSize); 
+ 
+    //return HUFv05_decompress4X2(dst, dstSize, cSrc, cSrcSize);   /* multi-streams single-symbol decoding */ 
+    //return HUFv05_decompress4X4(dst, dstSize, cSrc, cSrcSize);   /* multi-streams double-symbols decoding */ 
+    //return HUFv05_decompress4X6(dst, dstSize, cSrc, cSrcSize);   /* multi-streams quad-symbols decoding */ 
+} 
+/* 
+    zstd - standard compression library 
+    Copyright (C) 2014-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 source repository : https://github.com/Cyan4973/zstd 
+*/ 
+ 
+/* *************************************************************** 
+*  Tuning parameters 
+*****************************************************************/ 
+/*! 
+ * HEAPMODE : 
+ * Select how default decompression function ZSTDv05_decompress() will allocate memory, 
+ * in memory stack (0), or in memory heap (1, requires malloc()) 
+ */ 
+#ifndef ZSTDv05_HEAPMODE 
+#  define ZSTDv05_HEAPMODE 1 
+#endif 
+ 
+ 
+/*-******************************************************* 
+*  Dependencies 
+*********************************************************/ 
+#include <stdlib.h>      /* calloc */ 
+#include <string.h>      /* memcpy, memmove */ 
+#include <stdio.h>       /* debug only : printf */ 
+ 
+ 
+/*-******************************************************* 
+*  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 : 4324)        /* disable: C4324: padded structure */ 
+#else 
+#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) 
+#  ifdef __GNUC__ 
+#    define FORCE_INLINE static inline __attribute__((always_inline)) 
+#  else 
+#    define FORCE_INLINE static inline 
+#  endif 
+#endif 
+ 
+ 
+/*-************************************* 
+*  Local types 
+***************************************/ 
+typedef struct 
+{ 
+    blockType_t blockType; 
+    U32 origSize; 
+} blockProperties_t; 
+ 
+ 
+/* ******************************************************* 
+*  Memory operations 
+**********************************************************/ 
+static void ZSTDv05_copy4(void* dst, const void* src) { memcpy(dst, src, 4); } 
+ 
+ 
+/* ************************************* 
+*  Error Management 
+***************************************/ 
+/*! ZSTDv05_isError() : 
+*   tells if a return value is an error code */ 
+unsigned ZSTDv05_isError(size_t code) { return ERR_isError(code); } 
+ 
+/*! ZSTDv05_getError() : 
+*   convert a `size_t` function result into a proper ZSTDv05_errorCode enum */ 
+ZSTDv05_ErrorCode ZSTDv05_getError(size_t code) { return ERR_getError(code); } 
+ 
+/*! ZSTDv05_getErrorName() : 
+*   provides error code string (useful for debugging) */ 
+const char* ZSTDv05_getErrorName(size_t code) { return ERR_getErrorName(code); } 
+ 
+ 
+/* ************************************************************* 
+*   Context management 
+***************************************************************/ 
+typedef enum { ZSTDv05ds_getFrameHeaderSize, ZSTDv05ds_decodeFrameHeader, 
+               ZSTDv05ds_decodeBlockHeader, ZSTDv05ds_decompressBlock } ZSTDv05_dStage; 
+ 
+struct ZSTDv05_DCtx_s 
+{ 
+    FSEv05_DTable LLTable[FSEv05_DTABLE_SIZE_U32(LLFSEv05Log)]; 
+    FSEv05_DTable OffTable[FSEv05_DTABLE_SIZE_U32(OffFSEv05Log)]; 
+    FSEv05_DTable MLTable[FSEv05_DTABLE_SIZE_U32(MLFSEv05Log)]; 
+    unsigned   hufTableX4[HUFv05_DTABLE_SIZE(HufLog)]; 
+    const void* previousDstEnd; 
+    const void* base; 
+    const void* vBase; 
+    const void* dictEnd; 
+    size_t expected; 
+    size_t headerSize; 
+    ZSTDv05_parameters params; 
+    blockType_t bType;   /* used in ZSTDv05_decompressContinue(), to transfer blockType between header decoding and block decoding stages */ 
+    ZSTDv05_dStage stage; 
+    U32 flagStaticTables; 
+    const BYTE* litPtr; 
+    size_t litBufSize; 
+    size_t litSize; 
+    BYTE litBuffer[BLOCKSIZE + WILDCOPY_OVERLENGTH]; 
+    BYTE headerBuffer[ZSTDv05_frameHeaderSize_max]; 
+};  /* typedef'd to ZSTDv05_DCtx within "zstd_static.h" */ 
+ 
+size_t ZSTDv05_sizeofDCtx (void) { return sizeof(ZSTDv05_DCtx); } 
+ 
+size_t ZSTDv05_decompressBegin(ZSTDv05_DCtx* dctx) 
+{ 
+    dctx->expected = ZSTDv05_frameHeaderSize_min; 
+    dctx->stage = ZSTDv05ds_getFrameHeaderSize; 
+    dctx->previousDstEnd = NULL; 
+    dctx->base = NULL; 
+    dctx->vBase = NULL; 
+    dctx->dictEnd = NULL; 
+    dctx->hufTableX4[0] = HufLog; 
+    dctx->flagStaticTables = 0; 
+    return 0; 
+} 
+ 
+ZSTDv05_DCtx* ZSTDv05_createDCtx(void) 
+{ 
+    ZSTDv05_DCtx* dctx = (ZSTDv05_DCtx*)malloc(sizeof(ZSTDv05_DCtx)); 
+    if (dctx==NULL) return NULL; 
+    ZSTDv05_decompressBegin(dctx); 
+    return dctx; 
+} 
+ 
+size_t ZSTDv05_freeDCtx(ZSTDv05_DCtx* dctx) 
+{ 
+    free(dctx); 
+    return 0;   /* reserved as a potential error code in the future */ 
+} 
+ 
+void ZSTDv05_copyDCtx(ZSTDv05_DCtx* dstDCtx, const ZSTDv05_DCtx* srcDCtx) 
+{ 
+    memcpy(dstDCtx, srcDCtx, 
+           sizeof(ZSTDv05_DCtx) - (BLOCKSIZE+WILDCOPY_OVERLENGTH + ZSTDv05_frameHeaderSize_max));  /* no need to copy workspace */ 
+} 
+ 
+ 
+/* ************************************************************* 
+*   Decompression section 
+***************************************************************/ 
+ 
+/* Frame format description 
+   Frame Header -  [ Block Header - Block ] - Frame End 
+   1) Frame Header 
+      - 4 bytes - Magic Number : ZSTDv05_MAGICNUMBER (defined within zstd_internal.h) 
+      - 1 byte  - Window Descriptor 
+   2) Block Header 
+      - 3 bytes, starting with a 2-bits descriptor 
+                 Uncompressed, Compressed, Frame End, unused 
+   3) Block 
+      See Block Format Description 
+   4) Frame End 
+      - 3 bytes, compatible with Block Header 
+*/ 
+ 
+/* Block format description 
+ 
+   Block = Literal Section - Sequences Section 
+   Prerequisite : size of (compressed) block, maximum size of regenerated data 
+ 
+   1) Literal Section 
+ 
+   1.1) Header : 1-5 bytes 
+        flags: 2 bits 
+            00 compressed by Huff0 
+            01 unused 
+            10 is Raw (uncompressed) 
+            11 is Rle 
+            Note : using 01 => Huff0 with precomputed table ? 
+            Note : delta map ? => compressed ? 
+ 
+   1.1.1) Huff0-compressed literal block : 3-5 bytes 
+            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream 
+            srcSize < 1 KB => 3 bytes (2-2-10-10) 
+            srcSize < 16KB => 4 bytes (2-2-14-14) 
+            else           => 5 bytes (2-2-18-18) 
+            big endian convention 
+ 
+   1.1.2) Raw (uncompressed) literal block header : 1-3 bytes 
+        size :  5 bits: (IS_RAW<<6) + (0<<4) + size 
+               12 bits: (IS_RAW<<6) + (2<<4) + (size>>8) 
+                        size&255 
+               20 bits: (IS_RAW<<6) + (3<<4) + (size>>16) 
+                        size>>8&255 
+                        size&255 
+ 
+   1.1.3) Rle (repeated single byte) literal block header : 1-3 bytes 
+        size :  5 bits: (IS_RLE<<6) + (0<<4) + size 
+               12 bits: (IS_RLE<<6) + (2<<4) + (size>>8) 
+                        size&255 
+               20 bits: (IS_RLE<<6) + (3<<4) + (size>>16) 
+                        size>>8&255 
+                        size&255 
+ 
+   1.1.4) Huff0-compressed literal block, using precomputed CTables : 3-5 bytes 
+            srcSize < 1 KB => 3 bytes (2-2-10-10) => single stream 
+            srcSize < 1 KB => 3 bytes (2-2-10-10) 
+            srcSize < 16KB => 4 bytes (2-2-14-14) 
+            else           => 5 bytes (2-2-18-18) 
+            big endian convention 
+ 
+        1- CTable available (stored into workspace ?) 
+        2- Small input (fast heuristic ? Full comparison ? depend on clevel ?) 
+ 
+ 
+   1.2) Literal block content 
+ 
+   1.2.1) Huff0 block, using sizes from header 
+        See Huff0 format 
+ 
+   1.2.2) Huff0 block, using prepared table 
+ 
+   1.2.3) Raw content 
+ 
+   1.2.4) single byte 
+ 
+ 
+   2) Sequences section 
+      TO DO 
+*/ 
+ 
+ 
+/** ZSTDv05_decodeFrameHeader_Part1() : 
+*   decode the 1st part of the Frame Header, which tells Frame Header size. 
+*   srcSize must be == ZSTDv05_frameHeaderSize_min. 
+*   @return : the full size of the Frame Header */ 
+static size_t ZSTDv05_decodeFrameHeader_Part1(ZSTDv05_DCtx* zc, const void* src, size_t srcSize) 
+{ 
+    U32 magicNumber; 
+    if (srcSize != ZSTDv05_frameHeaderSize_min) 
+        return ERROR(srcSize_wrong); 
+    magicNumber = MEM_readLE32(src); 
+    if (magicNumber != ZSTDv05_MAGICNUMBER) return ERROR(prefix_unknown); 
+    zc->headerSize = ZSTDv05_frameHeaderSize_min; 
+    return zc->headerSize; 
+} 
+ 
+ 
+size_t ZSTDv05_getFrameParams(ZSTDv05_parameters* params, const void* src, size_t srcSize) 
+{ 
+    U32 magicNumber; 
+    if (srcSize < ZSTDv05_frameHeaderSize_min) return ZSTDv05_frameHeaderSize_max; 
+    magicNumber = MEM_readLE32(src); 
+    if (magicNumber != ZSTDv05_MAGICNUMBER) return ERROR(prefix_unknown); 
+    memset(params, 0, sizeof(*params)); 
+    params->windowLog = (((const BYTE*)src)[4] & 15) + ZSTDv05_WINDOWLOG_ABSOLUTEMIN; 
+    if ((((const BYTE*)src)[4] >> 4) != 0) return ERROR(frameParameter_unsupported);   /* reserved bits */ 
+    return 0; 
+} 
+ 
+/** ZSTDv05_decodeFrameHeader_Part2() : 
+*   decode the full Frame Header. 
+*   srcSize must be the size provided by ZSTDv05_decodeFrameHeader_Part1(). 
+*   @return : 0, or an error code, which can be tested using ZSTDv05_isError() */ 
+static size_t ZSTDv05_decodeFrameHeader_Part2(ZSTDv05_DCtx* zc, const void* src, size_t srcSize) 
+{ 
+    size_t result; 
+    if (srcSize != zc->headerSize) 
+        return ERROR(srcSize_wrong); 
+    result = ZSTDv05_getFrameParams(&(zc->params), src, srcSize); 
+    if ((MEM_32bits()) && (zc->params.windowLog > 25)) return ERROR(frameParameter_unsupportedBy32bits); 
+    return result; 
+} 
+ 
+ 
+size_t ZSTDv05_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr) 
+{ 
+    const BYTE* const in = (const BYTE* const)src; 
+    BYTE headerFlags; 
+    U32 cSize; 
+ 
+    if (srcSize < 3) 
+        return ERROR(srcSize_wrong); 
+ 
+    headerFlags = *in; 
+    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16); 
+ 
+    bpPtr->blockType = (blockType_t)(headerFlags >> 6); 
+    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0; 
+ 
+    if (bpPtr->blockType == bt_end) return 0; 
+    if (bpPtr->blockType == bt_rle) return 1; 
+    return cSize; 
+} 
+ 
+ 
+static size_t ZSTDv05_copyRawBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall); 
+    memcpy(dst, src, srcSize); 
+    return srcSize; 
+} 
+ 
+ 
+/*! ZSTDv05_decodeLiteralsBlock() : 
+    @return : nb of bytes read from src (< srcSize ) */ 
+size_t ZSTDv05_decodeLiteralsBlock(ZSTDv05_DCtx* dctx, 
+                          const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */ 
+{ 
+    const BYTE* const istart = (const BYTE*) src; 
+ 
+    /* any compressed block with literals segment must be at least this size */ 
+    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected); 
+ 
+    switch(istart[0]>> 6) 
+    { 
+    case IS_HUFv05: 
+        { 
+            size_t litSize, litCSize, singleStream=0; 
+            U32 lhSize = ((istart[0]) >> 4) & 3; 
+            switch(lhSize) 
+            { 
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */ 
+                /* 2 - 2 - 10 - 10 */ 
+                lhSize=3; 
+                singleStream = istart[0] & 16; 
+                litSize  = ((istart[0] & 15) << 6) + (istart[1] >> 2); 
+                litCSize = ((istart[1] &  3) << 8) + istart[2]; 
+                break; 
+            case 2: 
+                /* 2 - 2 - 14 - 14 */ 
+                lhSize=4; 
+                litSize  = ((istart[0] & 15) << 10) + (istart[1] << 2) + (istart[2] >> 6); 
+                litCSize = ((istart[2] & 63) <<  8) + istart[3]; 
+                break; 
+            case 3: 
+                /* 2 - 2 - 18 - 18 */ 
+                lhSize=5; 
+                litSize  = ((istart[0] & 15) << 14) + (istart[1] << 6) + (istart[2] >> 2); 
+                litCSize = ((istart[2] &  3) << 16) + (istart[3] << 8) + istart[4]; 
+                break; 
+            } 
+            if (litSize > BLOCKSIZE) return ERROR(corruption_detected); 
+ 
+            if (HUFv05_isError(singleStream ? 
+                            HUFv05_decompress1X2(dctx->litBuffer, litSize, istart+lhSize, litCSize) : 
+                            HUFv05_decompress   (dctx->litBuffer, litSize, istart+lhSize, litCSize) )) 
+                return ERROR(corruption_detected); 
+ 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litBufSize = BLOCKSIZE+8; 
+            dctx->litSize = litSize; 
+            return litCSize + lhSize; 
+        } 
+    case IS_PCH: 
+        { 
+            size_t errorCode; 
+            size_t litSize, litCSize; 
+            U32 lhSize = ((istart[0]) >> 4) & 3; 
+            if (lhSize != 1)  /* only case supported for now : small litSize, single stream */ 
+                return ERROR(corruption_detected); 
+            if (!dctx->flagStaticTables) 
+                return ERROR(dictionary_corrupted); 
+ 
+            /* 2 - 2 - 10 - 10 */ 
+            lhSize=3; 
+            litSize  = ((istart[0] & 15) << 6) + (istart[1] >> 2); 
+            litCSize = ((istart[1] &  3) << 8) + istart[2]; 
+ 
+            errorCode = HUFv05_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTableX4); 
+            if (HUFv05_isError(errorCode)) return ERROR(corruption_detected); 
+ 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litBufSize = BLOCKSIZE+WILDCOPY_OVERLENGTH; 
+            dctx->litSize = litSize; 
+            return litCSize + lhSize; 
+        } 
+    case IS_RAW: 
+        { 
+            size_t litSize; 
+            U32 lhSize = ((istart[0]) >> 4) & 3; 
+            switch(lhSize) 
+            { 
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */ 
+                lhSize=1; 
+                litSize = istart[0] & 31; 
+                break; 
+            case 2: 
+                litSize = ((istart[0] & 15) << 8) + istart[1]; 
+                break; 
+            case 3: 
+                litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2]; 
+                break; 
+            } 
+ 
+            if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) {  /* risk reading beyond src buffer with wildcopy */ 
+                if (litSize+lhSize > srcSize) return ERROR(corruption_detected); 
+                memcpy(dctx->litBuffer, istart+lhSize, litSize); 
+                dctx->litPtr = dctx->litBuffer; 
+                dctx->litBufSize = BLOCKSIZE+8; 
+                dctx->litSize = litSize; 
+                return lhSize+litSize; 
+            } 
+            /* direct reference into compressed stream */ 
+            dctx->litPtr = istart+lhSize; 
+            dctx->litBufSize = srcSize-lhSize; 
+            dctx->litSize = litSize; 
+            return lhSize+litSize; 
+        } 
+    case IS_RLE: 
+        { 
+            size_t litSize; 
+            U32 lhSize = ((istart[0]) >> 4) & 3; 
+            switch(lhSize) 
+            { 
+            case 0: case 1: default:   /* note : default is impossible, since lhSize into [0..3] */ 
+                lhSize = 1; 
+                litSize = istart[0] & 31; 
+                break; 
+            case 2: 
+                litSize = ((istart[0] & 15) << 8) + istart[1]; 
+                break; 
+            case 3: 
+                litSize = ((istart[0] & 15) << 16) + (istart[1] << 8) + istart[2]; 
+                break; 
+            } 
+            if (litSize > BLOCKSIZE) return ERROR(corruption_detected); 
+            memset(dctx->litBuffer, istart[lhSize], litSize); 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litBufSize = BLOCKSIZE+WILDCOPY_OVERLENGTH; 
+            dctx->litSize = litSize; 
+            return lhSize+1; 
+        } 
+    default: 
+        return ERROR(corruption_detected);   /* impossible */ 
+    } 
+} 
+ 
+ 
+size_t ZSTDv05_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr, 
+                         FSEv05_DTable* DTableLL, FSEv05_DTable* DTableML, FSEv05_DTable* DTableOffb, 
+                         const void* src, size_t srcSize) 
+{ 
+    const BYTE* const istart = (const BYTE* const)src; 
+    const BYTE* ip = istart; 
+    const BYTE* const iend = istart + srcSize; 
+    U32 LLtype, Offtype, MLtype; 
+    U32 LLlog, Offlog, MLlog; 
+    size_t dumpsLength; 
+ 
+    /* check */ 
+    if (srcSize < MIN_SEQUENCES_SIZE) 
+        return ERROR(srcSize_wrong); 
+ 
+    /* SeqHead */ 
+    *nbSeq = *ip++; 
+    if (*nbSeq==0) return 1; 
+    if (*nbSeq >= 128) 
+        *nbSeq = ((nbSeq[0]-128)<<8) + *ip++; 
+ 
+    LLtype  = *ip >> 6; 
+    Offtype = (*ip >> 4) & 3; 
+    MLtype  = (*ip >> 2) & 3; 
+    if (*ip & 2) { 
+        dumpsLength  = ip[2]; 
+        dumpsLength += ip[1] << 8; 
+        ip += 3; 
+    } else { 
+        dumpsLength  = ip[1]; 
+        dumpsLength += (ip[0] & 1) << 8; 
+        ip += 2; 
+    } 
+    *dumpsPtr = ip; 
+    ip += dumpsLength; 
+    *dumpsLengthPtr = dumpsLength; 
+ 
+    /* check */ 
+    if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are "raw", hence no header, but at least xxLog bits per type */ 
+ 
+    /* sequences */ 
+    { 
+        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL >= MaxOff */ 
+        size_t headerSize; 
+ 
+        /* Build DTables */ 
+        switch(LLtype) 
+        { 
+        U32 max; 
+        case FSEv05_ENCODING_RLE : 
+            LLlog = 0; 
+            FSEv05_buildDTable_rle(DTableLL, *ip++); 
+            break; 
+        case FSEv05_ENCODING_RAW : 
+            LLlog = LLbits; 
+            FSEv05_buildDTable_raw(DTableLL, LLbits); 
+            break; 
+        case FSEv05_ENCODING_STATIC: 
+            break; 
+        case FSEv05_ENCODING_DYNAMIC : 
+        default :   /* impossible */ 
+            max = MaxLL; 
+            headerSize = FSEv05_readNCount(norm, &max, &LLlog, ip, iend-ip); 
+            if (FSEv05_isError(headerSize)) return ERROR(GENERIC); 
+            if (LLlog > LLFSEv05Log) return ERROR(corruption_detected); 
+            ip += headerSize; 
+            FSEv05_buildDTable(DTableLL, norm, max, LLlog); 
+        } 
+ 
+        switch(Offtype) 
+        { 
+        U32 max; 
+        case FSEv05_ENCODING_RLE : 
+            Offlog = 0; 
+            if (ip > iend-2) return ERROR(srcSize_wrong);   /* min : "raw", hence no header, but at least xxLog bits */ 
+            FSEv05_buildDTable_rle(DTableOffb, *ip++ & MaxOff); /* if *ip > MaxOff, data is corrupted */ 
+            break; 
+        case FSEv05_ENCODING_RAW : 
+            Offlog = Offbits; 
+            FSEv05_buildDTable_raw(DTableOffb, Offbits); 
+            break; 
+        case FSEv05_ENCODING_STATIC: 
+            break; 
+        case FSEv05_ENCODING_DYNAMIC : 
+        default :   /* impossible */ 
+            max = MaxOff; 
+            headerSize = FSEv05_readNCount(norm, &max, &Offlog, ip, iend-ip); 
+            if (FSEv05_isError(headerSize)) return ERROR(GENERIC); 
+            if (Offlog > OffFSEv05Log) return ERROR(corruption_detected); 
+            ip += headerSize; 
+            FSEv05_buildDTable(DTableOffb, norm, max, Offlog); 
+        } 
+ 
+        switch(MLtype) 
+        { 
+        U32 max; 
+        case FSEv05_ENCODING_RLE : 
+            MLlog = 0; 
+            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : "raw", hence no header, but at least xxLog bits */ 
+            FSEv05_buildDTable_rle(DTableML, *ip++); 
+            break; 
+        case FSEv05_ENCODING_RAW : 
+            MLlog = MLbits; 
+            FSEv05_buildDTable_raw(DTableML, MLbits); 
+            break; 
+        case FSEv05_ENCODING_STATIC: 
+            break; 
+        case FSEv05_ENCODING_DYNAMIC : 
+        default :   /* impossible */ 
+            max = MaxML; 
+            headerSize = FSEv05_readNCount(norm, &max, &MLlog, ip, iend-ip); 
+            if (FSEv05_isError(headerSize)) return ERROR(GENERIC); 
+            if (MLlog > MLFSEv05Log) return ERROR(corruption_detected); 
+            ip += headerSize; 
+            FSEv05_buildDTable(DTableML, norm, max, MLlog); 
+    }   } 
+ 
+    return ip-istart; 
+} 
+ 
+ 
+typedef struct { 
+    size_t litLength; 
+    size_t matchLength; 
+    size_t offset; 
+} seq_t; 
+ 
+typedef struct { 
+    BITv05_DStream_t DStream; 
+    FSEv05_DState_t stateLL; 
+    FSEv05_DState_t stateOffb; 
+    FSEv05_DState_t stateML; 
+    size_t prevOffset; 
+    const BYTE* dumps; 
+    const BYTE* dumpsEnd; 
+} seqState_t; 
+ 
+ 
+ 
+static void ZSTDv05_decodeSequence(seq_t* seq, seqState_t* seqState) 
+{ 
+    size_t litLength; 
+    size_t prevOffset; 
+    size_t offset; 
+    size_t matchLength; 
+    const BYTE* dumps = seqState->dumps; 
+    const BYTE* const de = seqState->dumpsEnd; 
+ 
+    /* Literal length */ 
+    litLength = FSEv05_peakSymbol(&(seqState->stateLL)); 
+    prevOffset = litLength ? seq->offset : seqState->prevOffset; 
+    if (litLength == MaxLL) { 
+        U32 add = *dumps++; 
+        if (add < 255) litLength += add; 
+        else { 
+            litLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no risk : dumps is always followed by seq tables > 1 byte */ 
+            if (litLength&1) litLength>>=1, dumps += 3; 
+            else litLength = (U16)(litLength)>>1, dumps += 2; 
+        } 
+        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */ 
+    } 
+ 
+    /* Offset */ 
+    { 
+        static const U32 offsetPrefix[MaxOff+1] = { 
+                1 /*fake*/, 1, 2, 4, 8, 16, 32, 64, 128, 256, 
+                512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 
+                524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, /*fake*/ 1, 1, 1, 1, 1 }; 
+        U32 offsetCode = FSEv05_peakSymbol(&(seqState->stateOffb));   /* <= maxOff, by table construction */ 
+        U32 nbBits = offsetCode - 1; 
+        if (offsetCode==0) nbBits = 0;   /* cmove */ 
+        offset = offsetPrefix[offsetCode] + BITv05_readBits(&(seqState->DStream), nbBits); 
+        if (MEM_32bits()) BITv05_reloadDStream(&(seqState->DStream)); 
+        if (offsetCode==0) offset = prevOffset;   /* repcode, cmove */ 
+        if (offsetCode | !litLength) seqState->prevOffset = seq->offset;   /* cmove */ 
+        FSEv05_decodeSymbol(&(seqState->stateOffb), &(seqState->DStream));    /* update */ 
+    } 
+ 
+    /* Literal length update */ 
+    FSEv05_decodeSymbol(&(seqState->stateLL), &(seqState->DStream));   /* update */ 
+    if (MEM_32bits()) BITv05_reloadDStream(&(seqState->DStream)); 
+ 
+    /* MatchLength */ 
+    matchLength = FSEv05_decodeSymbol(&(seqState->stateML), &(seqState->DStream)); 
+    if (matchLength == MaxML) { 
+        U32 add = *dumps++; 
+        if (add < 255) matchLength += add; 
+        else { 
+            matchLength = MEM_readLE32(dumps) & 0xFFFFFF;  /* no pb : dumps is always followed by seq tables > 1 byte */ 
+            if (matchLength&1) matchLength>>=1, dumps += 3; 
+            else matchLength = (U16)(matchLength)>>1, dumps += 2; 
+        } 
+        if (dumps >= de) dumps = de-1;   /* late correction, to avoid read overflow (data is now corrupted anyway) */ 
+    } 
+    matchLength += MINMATCH; 
+ 
+    /* save result */ 
+    seq->litLength = litLength; 
+    seq->offset = offset; 
+    seq->matchLength = matchLength; 
+    seqState->dumps = dumps; 
+ 
+#if 0   /* debug */ 
+    { 
+        static U64 totalDecoded = 0; 
+        printf("pos %6u : %3u literals & match %3u bytes at distance %6u \n", 
+           (U32)(totalDecoded), (U32)litLength, (U32)matchLength, (U32)offset); 
+        totalDecoded += litLength + matchLength; 
+    } 
+#endif 
+} 
+ 
+ 
+static size_t ZSTDv05_execSequence(BYTE* op, 
+                                BYTE* const oend, seq_t sequence, 
+                                const BYTE** litPtr, const BYTE* const litLimit_8, 
+                                const BYTE* const base, const BYTE* const vBase, const BYTE* const dictEnd) 
+{ 
+    static const int dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */ 
+    static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 };   /* substracted */ 
+    BYTE* const oLitEnd = op + sequence.litLength; 
+    const size_t sequenceLength = sequence.litLength + sequence.matchLength; 
+    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */ 
+    BYTE* const oend_8 = oend-8; 
+    const BYTE* const litEnd = *litPtr + sequence.litLength; 
+    const BYTE* match = oLitEnd - sequence.offset; 
+ 
+    /* check */ 
+    if (oLitEnd > oend_8) return ERROR(dstSize_tooSmall);   /* last match must start at a minimum distance of 8 from oend */ 
+    if (oMatchEnd > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */ 
+    if (litEnd > litLimit_8) return ERROR(corruption_detected);   /* risk read beyond lit buffer */ 
+ 
+    /* copy Literals */ 
+    ZSTDv05_wildcopy(op, *litPtr, sequence.litLength);   /* note : oLitEnd <= oend-8 : no risk of overwrite beyond oend */ 
+    op = oLitEnd; 
+    *litPtr = litEnd;   /* update for next sequence */ 
+ 
+    /* copy Match */ 
+    if (sequence.offset > (size_t)(oLitEnd - base)) { 
+        /* offset beyond prefix */ 
+        if (sequence.offset > (size_t)(oLitEnd - vBase)) 
+            return ERROR(corruption_detected); 
+        match = dictEnd - (base-match); 
+        if (match + sequence.matchLength <= dictEnd) { 
+            memmove(oLitEnd, match, sequence.matchLength); 
+            return sequenceLength; 
+        } 
+        /* span extDict & currentPrefixSegment */ 
+        { 
+            size_t length1 = dictEnd - match; 
+            memmove(oLitEnd, match, length1); 
+            op = oLitEnd + length1; 
+            sequence.matchLength -= length1; 
+            match = base; 
+    }   } 
+ 
+    /* match within prefix */ 
+    if (sequence.offset < 8) { 
+        /* close range match, overlap */ 
+        const int sub2 = dec64table[sequence.offset]; 
+        op[0] = match[0]; 
+        op[1] = match[1]; 
+        op[2] = match[2]; 
+        op[3] = match[3]; 
+        match += dec32table[sequence.offset]; 
+        ZSTDv05_copy4(op+4, match); 
+        match -= sub2; 
+    } else { 
+        ZSTDv05_copy8(op, match); 
+    } 
+    op += 8; match += 8; 
+ 
+    if (oMatchEnd > oend-12) { 
+        if (op < oend_8) { 
+            ZSTDv05_wildcopy(op, match, oend_8 - op); 
+            match += oend_8 - op; 
+            op = oend_8; 
+        } 
+        while (op < oMatchEnd) 
+            *op++ = *match++; 
+    } else { 
+        ZSTDv05_wildcopy(op, match, sequence.matchLength-8);   /* works even if matchLength < 8 */ 
+    } 
+    return sequenceLength; 
+} 
+ 
+ 
+static size_t ZSTDv05_decompressSequences( 
+                               ZSTDv05_DCtx* dctx, 
+                               void* dst, size_t maxDstSize, 
+                         const void* seqStart, size_t seqSize) 
+{ 
+    const BYTE* ip = (const BYTE*)seqStart; 
+    const BYTE* const iend = ip + seqSize; 
+    BYTE* const ostart = (BYTE* const)dst; 
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + maxDstSize; 
+    size_t errorCode, dumpsLength; 
+    const BYTE* litPtr = dctx->litPtr; 
+    const BYTE* const litLimit_8 = litPtr + dctx->litBufSize - 8; 
+    const BYTE* const litEnd = litPtr + dctx->litSize; 
+    int nbSeq; 
+    const BYTE* dumps; 
+    U32* DTableLL = dctx->LLTable; 
+    U32* DTableML = dctx->MLTable; 
+    U32* DTableOffb = dctx->OffTable; 
+    const BYTE* const base = (const BYTE*) (dctx->base); 
+    const BYTE* const vBase = (const BYTE*) (dctx->vBase); 
+    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd); 
+ 
+    /* Build Decoding Tables */ 
+    errorCode = ZSTDv05_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength, 
+                                      DTableLL, DTableML, DTableOffb, 
+                                      ip, seqSize); 
+    if (ZSTDv05_isError(errorCode)) return errorCode; 
+    ip += errorCode; 
+ 
+    /* Regen sequences */ 
+    if (nbSeq) { 
+        seq_t sequence; 
+        seqState_t seqState; 
+ 
+        memset(&sequence, 0, sizeof(sequence)); 
+        sequence.offset = REPCODE_STARTVALUE; 
+        seqState.dumps = dumps; 
+        seqState.dumpsEnd = dumps + dumpsLength; 
+        seqState.prevOffset = REPCODE_STARTVALUE; 
+        errorCode = BITv05_initDStream(&(seqState.DStream), ip, iend-ip); 
+        if (ERR_isError(errorCode)) return ERROR(corruption_detected); 
+        FSEv05_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL); 
+        FSEv05_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb); 
+        FSEv05_initDState(&(seqState.stateML), &(seqState.DStream), DTableML); 
+ 
+        for ( ; (BITv05_reloadDStream(&(seqState.DStream)) <= BITv05_DStream_completed) && nbSeq ; ) { 
+            size_t oneSeqSize; 
+            nbSeq--; 
+            ZSTDv05_decodeSequence(&sequence, &seqState); 
+            oneSeqSize = ZSTDv05_execSequence(op, oend, sequence, &litPtr, litLimit_8, base, vBase, dictEnd); 
+            if (ZSTDv05_isError(oneSeqSize)) return oneSeqSize; 
+            op += oneSeqSize; 
+        } 
+ 
+        /* check if reached exact end */ 
+        if (nbSeq) return ERROR(corruption_detected); 
+    } 
+ 
+    /* last literal segment */ 
+    { 
+        size_t lastLLSize = litEnd - litPtr; 
+        if (litPtr > litEnd) return ERROR(corruption_detected);   /* too many literals already used */ 
+        if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall); 
+        memcpy(op, litPtr, lastLLSize); 
+        op += lastLLSize; 
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+static void ZSTDv05_checkContinuity(ZSTDv05_DCtx* dctx, const void* dst) 
+{ 
+    if (dst != dctx->previousDstEnd) {   /* not contiguous */ 
+        dctx->dictEnd = dctx->previousDstEnd; 
+        dctx->vBase = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base)); 
+        dctx->base = dst; 
+        dctx->previousDstEnd = dst; 
+    } 
+} 
+ 
+ 
+static size_t ZSTDv05_decompressBlock_internal(ZSTDv05_DCtx* dctx, 
+                            void* dst, size_t dstCapacity, 
+                      const void* src, size_t srcSize) 
+{   /* blockType == blockCompressed */ 
+    const BYTE* ip = (const BYTE*)src; 
+    size_t litCSize; 
+ 
+    if (srcSize >= BLOCKSIZE) return ERROR(srcSize_wrong); 
+ 
+    /* Decode literals sub-block */ 
+    litCSize = ZSTDv05_decodeLiteralsBlock(dctx, src, srcSize); 
+    if (ZSTDv05_isError(litCSize)) return litCSize; 
+    ip += litCSize; 
+    srcSize -= litCSize; 
+ 
+    return ZSTDv05_decompressSequences(dctx, dst, dstCapacity, ip, srcSize); 
+} 
+ 
+ 
+size_t ZSTDv05_decompressBlock(ZSTDv05_DCtx* dctx, 
+                            void* dst, size_t dstCapacity, 
+                      const void* src, size_t srcSize) 
+{ 
+    ZSTDv05_checkContinuity(dctx, dst); 
+    return ZSTDv05_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize); 
+} 
+ 
+ 
+/*! ZSTDv05_decompress_continueDCtx 
+*   dctx must have been properly initialized */ 
+static size_t ZSTDv05_decompress_continueDCtx(ZSTDv05_DCtx* dctx, 
+                                 void* dst, size_t maxDstSize, 
+                                 const void* src, size_t srcSize) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    const BYTE* iend = ip + srcSize; 
+    BYTE* const ostart = (BYTE* const)dst; 
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + maxDstSize; 
+    size_t remainingSize = srcSize; 
+    blockProperties_t blockProperties; 
+ 
+    /* Frame Header */ 
+    { 
+        size_t frameHeaderSize; 
+        if (srcSize < ZSTDv05_frameHeaderSize_min+ZSTDv05_blockHeaderSize) return ERROR(srcSize_wrong); 
+        frameHeaderSize = ZSTDv05_decodeFrameHeader_Part1(dctx, src, ZSTDv05_frameHeaderSize_min); 
+        if (ZSTDv05_isError(frameHeaderSize)) return frameHeaderSize; 
+        if (srcSize < frameHeaderSize+ZSTDv05_blockHeaderSize) return ERROR(srcSize_wrong); 
+        ip += frameHeaderSize; remainingSize -= frameHeaderSize; 
+        frameHeaderSize = ZSTDv05_decodeFrameHeader_Part2(dctx, src, frameHeaderSize); 
+        if (ZSTDv05_isError(frameHeaderSize)) return frameHeaderSize; 
+    } 
+ 
+    /* Loop on each block */ 
+    while (1) 
+    { 
+        size_t decodedSize=0; 
+        size_t cBlockSize = ZSTDv05_getcBlockSize(ip, iend-ip, &blockProperties); 
+        if (ZSTDv05_isError(cBlockSize)) return cBlockSize; 
+ 
+        ip += ZSTDv05_blockHeaderSize; 
+        remainingSize -= ZSTDv05_blockHeaderSize; 
+        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong); 
+ 
+        switch(blockProperties.blockType) 
+        { 
+        case bt_compressed: 
+            decodedSize = ZSTDv05_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize); 
+            break; 
+        case bt_raw : 
+            decodedSize = ZSTDv05_copyRawBlock(op, oend-op, ip, cBlockSize); 
+            break; 
+        case bt_rle : 
+            return ERROR(GENERIC);   /* not yet supported */ 
+            break; 
+        case bt_end : 
+            /* end of frame */ 
+            if (remainingSize) return ERROR(srcSize_wrong); 
+            break; 
+        default: 
+            return ERROR(GENERIC);   /* impossible */ 
+        } 
+        if (cBlockSize == 0) break;   /* bt_end */ 
+ 
+        if (ZSTDv05_isError(decodedSize)) return decodedSize; 
+        op += decodedSize; 
+        ip += cBlockSize; 
+        remainingSize -= cBlockSize; 
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+size_t ZSTDv05_decompress_usingPreparedDCtx(ZSTDv05_DCtx* dctx, const ZSTDv05_DCtx* refDCtx, 
+                                         void* dst, size_t maxDstSize, 
+                                   const void* src, size_t srcSize) 
+{ 
+    ZSTDv05_copyDCtx(dctx, refDCtx); 
+    ZSTDv05_checkContinuity(dctx, dst); 
+    return ZSTDv05_decompress_continueDCtx(dctx, dst, maxDstSize, src, srcSize); 
+} 
+ 
+ 
+size_t ZSTDv05_decompress_usingDict(ZSTDv05_DCtx* dctx, 
+                                 void* dst, size_t maxDstSize, 
+                                 const void* src, size_t srcSize, 
+                                 const void* dict, size_t dictSize) 
+{ 
+    ZSTDv05_decompressBegin_usingDict(dctx, dict, dictSize); 
+    ZSTDv05_checkContinuity(dctx, dst); 
+    return ZSTDv05_decompress_continueDCtx(dctx, dst, maxDstSize, src, srcSize); 
+} 
+ 
+ 
+size_t ZSTDv05_decompressDCtx(ZSTDv05_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    return ZSTDv05_decompress_usingDict(dctx, dst, maxDstSize, src, srcSize, NULL, 0); 
+} 
+ 
+size_t ZSTDv05_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+#if defined(ZSTDv05_HEAPMODE) && (ZSTDv05_HEAPMODE==1) 
+    size_t regenSize; 
+    ZSTDv05_DCtx* dctx = ZSTDv05_createDCtx(); 
+    if (dctx==NULL) return ERROR(memory_allocation); 
+    regenSize = ZSTDv05_decompressDCtx(dctx, dst, maxDstSize, src, srcSize); 
+    ZSTDv05_freeDCtx(dctx); 
+    return regenSize; 
+#else 
+    ZSTDv05_DCtx dctx; 
+    return ZSTDv05_decompressDCtx(&dctx, dst, maxDstSize, src, srcSize); 
+#endif 
+} 
+ 
+ 
+/* ****************************** 
+*  Streaming Decompression API 
+********************************/ 
+size_t ZSTDv05_nextSrcSizeToDecompress(ZSTDv05_DCtx* dctx) 
+{ 
+    return dctx->expected; 
+} 
+ 
+size_t ZSTDv05_decompressContinue(ZSTDv05_DCtx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    /* Sanity check */ 
+    if (srcSize != dctx->expected) return ERROR(srcSize_wrong); 
+    ZSTDv05_checkContinuity(dctx, dst); 
+ 
+    /* Decompress : frame header; part 1 */ 
+    switch (dctx->stage) 
+    { 
+    case ZSTDv05ds_getFrameHeaderSize : 
         /* get frame header size */
         if (srcSize != ZSTDv05_frameHeaderSize_min) return ERROR(srcSize_wrong);   /* impossible */
         dctx->headerSize = ZSTDv05_decodeFrameHeader_Part1(dctx, src, ZSTDv05_frameHeaderSize_min);
@@ -3880,446 +3880,446 @@ size_t ZSTDv05_decompressContinue(ZSTDv05_DCtx* dctx, void* dst, size_t maxDstSi
         if (dctx->headerSize > ZSTDv05_frameHeaderSize_min) return ERROR(GENERIC); /* should never happen */
         dctx->expected = 0;   /* not necessary to copy more */
         /* fallthrough */
-    case ZSTDv05ds_decodeFrameHeader:
+    case ZSTDv05ds_decodeFrameHeader: 
         /* get frame header */
         {   size_t const result = ZSTDv05_decodeFrameHeader_Part2(dctx, dctx->headerBuffer, dctx->headerSize);
-            if (ZSTDv05_isError(result)) return result;
-            dctx->expected = ZSTDv05_blockHeaderSize;
-            dctx->stage = ZSTDv05ds_decodeBlockHeader;
-            return 0;
-        }
-    case ZSTDv05ds_decodeBlockHeader:
-        {
-            /* Decode block header */
-            blockProperties_t bp;
-            size_t blockSize = ZSTDv05_getcBlockSize(src, ZSTDv05_blockHeaderSize, &bp);
-            if (ZSTDv05_isError(blockSize)) return blockSize;
-            if (bp.blockType == bt_end) {
-                dctx->expected = 0;
-                dctx->stage = ZSTDv05ds_getFrameHeaderSize;
-            }
-            else {
-                dctx->expected = blockSize;
-                dctx->bType = bp.blockType;
-                dctx->stage = ZSTDv05ds_decompressBlock;
-            }
-            return 0;
-        }
-    case ZSTDv05ds_decompressBlock:
-        {
-            /* Decompress : block content */
-            size_t rSize;
-            switch(dctx->bType)
-            {
-            case bt_compressed:
-                rSize = ZSTDv05_decompressBlock_internal(dctx, dst, maxDstSize, src, srcSize);
-                break;
-            case bt_raw :
-                rSize = ZSTDv05_copyRawBlock(dst, maxDstSize, src, srcSize);
-                break;
-            case bt_rle :
-                return ERROR(GENERIC);   /* not yet handled */
-                break;
-            case bt_end :   /* should never happen (filtered at phase 1) */
-                rSize = 0;
-                break;
-            default:
-                return ERROR(GENERIC);   /* impossible */
-            }
-            dctx->stage = ZSTDv05ds_decodeBlockHeader;
-            dctx->expected = ZSTDv05_blockHeaderSize;
-            dctx->previousDstEnd = (char*)dst + rSize;
-            return rSize;
-        }
-    default:
-        return ERROR(GENERIC);   /* impossible */
-    }
-}
-
-
-static void ZSTDv05_refDictContent(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    dctx->dictEnd = dctx->previousDstEnd;
-    dctx->vBase = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base));
-    dctx->base = dict;
-    dctx->previousDstEnd = (const char*)dict + dictSize;
-}
-
-static size_t ZSTDv05_loadEntropy(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    size_t hSize, offcodeHeaderSize, matchlengthHeaderSize, errorCode, litlengthHeaderSize;
-    short offcodeNCount[MaxOff+1];
-    U32 offcodeMaxValue=MaxOff, offcodeLog=OffFSEv05Log;
-    short matchlengthNCount[MaxML+1];
-    unsigned matchlengthMaxValue = MaxML, matchlengthLog = MLFSEv05Log;
-    short litlengthNCount[MaxLL+1];
-    unsigned litlengthMaxValue = MaxLL, litlengthLog = LLFSEv05Log;
-
-    hSize = HUFv05_readDTableX4(dctx->hufTableX4, dict, dictSize);
-    if (HUFv05_isError(hSize)) return ERROR(dictionary_corrupted);
-    dict = (const char*)dict + hSize;
-    dictSize -= hSize;
-
-    offcodeHeaderSize = FSEv05_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dict, dictSize);
-    if (FSEv05_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);
-    errorCode = FSEv05_buildDTable(dctx->OffTable, offcodeNCount, offcodeMaxValue, offcodeLog);
-    if (FSEv05_isError(errorCode)) return ERROR(dictionary_corrupted);
-    dict = (const char*)dict + offcodeHeaderSize;
-    dictSize -= offcodeHeaderSize;
-
-    matchlengthHeaderSize = FSEv05_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dict, dictSize);
-    if (FSEv05_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted);
-    errorCode = FSEv05_buildDTable(dctx->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog);
-    if (FSEv05_isError(errorCode)) return ERROR(dictionary_corrupted);
-    dict = (const char*)dict + matchlengthHeaderSize;
-    dictSize -= matchlengthHeaderSize;
-
-    litlengthHeaderSize = FSEv05_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dict, dictSize);
-    if (FSEv05_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted);
-    errorCode = FSEv05_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog);
-    if (FSEv05_isError(errorCode)) return ERROR(dictionary_corrupted);
-
-    dctx->flagStaticTables = 1;
-    return hSize + offcodeHeaderSize + matchlengthHeaderSize + litlengthHeaderSize;
-}
-
-static size_t ZSTDv05_decompress_insertDictionary(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    size_t eSize;
-    U32 magic = MEM_readLE32(dict);
-    if (magic != ZSTDv05_DICT_MAGIC) {
-        /* pure content mode */
-        ZSTDv05_refDictContent(dctx, dict, dictSize);
-        return 0;
-    }
-    /* load entropy tables */
-    dict = (const char*)dict + 4;
-    dictSize -= 4;
-    eSize = ZSTDv05_loadEntropy(dctx, dict, dictSize);
-    if (ZSTDv05_isError(eSize)) return ERROR(dictionary_corrupted);
-
-    /* reference dictionary content */
-    dict = (const char*)dict + eSize;
-    dictSize -= eSize;
-    ZSTDv05_refDictContent(dctx, dict, dictSize);
-
-    return 0;
-}
-
-
-size_t ZSTDv05_decompressBegin_usingDict(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    size_t errorCode;
-    errorCode = ZSTDv05_decompressBegin(dctx);
-    if (ZSTDv05_isError(errorCode)) return errorCode;
-
-    if (dict && dictSize) {
-        errorCode = ZSTDv05_decompress_insertDictionary(dctx, dict, dictSize);
-        if (ZSTDv05_isError(errorCode)) return ERROR(dictionary_corrupted);
-    }
-
-    return 0;
-}
-
-/*
-    Buffered version 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 source repository : https://github.com/Cyan4973/zstd
-    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-
-/* The objects defined into this file should be considered experimental.
- * They are not labelled stable, as their prototype may change in the future.
- * You can use them for tests, provide feedback, or if you can endure risk of future changes.
- */
-
-
-
-/* *************************************
-*  Constants
-***************************************/
-static size_t ZBUFFv05_blockHeaderSize = 3;
-
-
-
-/* *** Compression *** */
-
-static size_t ZBUFFv05_limitCopy(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    size_t length = MIN(maxDstSize, srcSize);
-    memcpy(dst, src, length);
-    return length;
-}
-
-
-
-
-/** ************************************************
-*  Streaming decompression
-*
-*  A ZBUFFv05_DCtx object is required to track streaming operation.
-*  Use ZBUFFv05_createDCtx() and ZBUFFv05_freeDCtx() to create/release resources.
-*  Use ZBUFFv05_decompressInit() to start a new decompression operation.
-*  ZBUFFv05_DCtx objects can be reused multiple times.
-*
-*  Use ZBUFFv05_decompressContinue() repetitively to consume your input.
-*  *srcSizePtr and *maxDstSizePtr can be any size.
-*  The function will report how many bytes were read or written by modifying *srcSizePtr and *maxDstSizePtr.
-*  Note that it may not consume the entire input, in which case it's up to the caller to call again the function with remaining input.
-*  The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst .
-*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency)
-*            or 0 when a frame is completely decoded
-*            or an error code, which can be tested using ZBUFFv05_isError().
-*
-*  Hint : recommended buffer sizes (not compulsory)
-*  output : 128 KB block size is the internal unit, it ensures it's always possible to write a full block when it's decoded.
-*  input : just follow indications from ZBUFFv05_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
-* **************************************************/
-
-typedef enum { ZBUFFv05ds_init, ZBUFFv05ds_readHeader, ZBUFFv05ds_loadHeader, ZBUFFv05ds_decodeHeader,
-               ZBUFFv05ds_read, ZBUFFv05ds_load, ZBUFFv05ds_flush } ZBUFFv05_dStage;
-
-/* *** Resource management *** */
-
-#define ZSTDv05_frameHeaderSize_max 5   /* too magical, should come from reference */
-struct ZBUFFv05_DCtx_s {
-    ZSTDv05_DCtx* zc;
-    ZSTDv05_parameters params;
-    char* inBuff;
-    size_t inBuffSize;
-    size_t inPos;
-    char* outBuff;
-    size_t outBuffSize;
-    size_t outStart;
-    size_t outEnd;
-    size_t hPos;
-    ZBUFFv05_dStage stage;
-    unsigned char headerBuffer[ZSTDv05_frameHeaderSize_max];
-};   /* typedef'd to ZBUFFv05_DCtx within "zstd_buffered.h" */
-
-
-ZBUFFv05_DCtx* ZBUFFv05_createDCtx(void)
-{
-    ZBUFFv05_DCtx* zbc = (ZBUFFv05_DCtx*)malloc(sizeof(ZBUFFv05_DCtx));
-    if (zbc==NULL) return NULL;
-    memset(zbc, 0, sizeof(*zbc));
-    zbc->zc = ZSTDv05_createDCtx();
-    zbc->stage = ZBUFFv05ds_init;
-    return zbc;
-}
-
-size_t ZBUFFv05_freeDCtx(ZBUFFv05_DCtx* zbc)
-{
-    if (zbc==NULL) return 0;   /* support free on null */
-    ZSTDv05_freeDCtx(zbc->zc);
-    free(zbc->inBuff);
-    free(zbc->outBuff);
-    free(zbc);
-    return 0;
-}
-
-
-/* *** Initialization *** */
-
-size_t ZBUFFv05_decompressInitDictionary(ZBUFFv05_DCtx* zbc, const void* dict, size_t dictSize)
-{
-    zbc->stage = ZBUFFv05ds_readHeader;
-    zbc->hPos = zbc->inPos = zbc->outStart = zbc->outEnd = 0;
-    return ZSTDv05_decompressBegin_usingDict(zbc->zc, dict, dictSize);
-}
-
-size_t ZBUFFv05_decompressInit(ZBUFFv05_DCtx* zbc)
-{
-    return ZBUFFv05_decompressInitDictionary(zbc, NULL, 0);
-}
-
-
-/* *** Decompression *** */
-
-size_t ZBUFFv05_decompressContinue(ZBUFFv05_DCtx* zbc, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr)
-{
-    const char* const istart = (const char*)src;
-    const char* ip = istart;
-    const char* const iend = istart + *srcSizePtr;
-    char* const ostart = (char*)dst;
-    char* op = ostart;
-    char* const oend = ostart + *maxDstSizePtr;
-    U32 notDone = 1;
-
-    while (notDone) {
-        switch(zbc->stage)
-        {
-        case ZBUFFv05ds_init :
-            return ERROR(init_missing);
-
-        case ZBUFFv05ds_readHeader :
-            /* read header from src */
-            {
-                size_t headerSize = ZSTDv05_getFrameParams(&(zbc->params), src, *srcSizePtr);
-                if (ZSTDv05_isError(headerSize)) return headerSize;
-                if (headerSize) {
-                    /* not enough input to decode header : tell how many bytes would be necessary */
-                    memcpy(zbc->headerBuffer+zbc->hPos, src, *srcSizePtr);
-                    zbc->hPos += *srcSizePtr;
-                    *maxDstSizePtr = 0;
-                    zbc->stage = ZBUFFv05ds_loadHeader;
-                    return headerSize - zbc->hPos;
-                }
-                zbc->stage = ZBUFFv05ds_decodeHeader;
-                break;
-            }
-
-        case ZBUFFv05ds_loadHeader:
-            /* complete header from src */
-            {
-                size_t headerSize = ZBUFFv05_limitCopy(
-                    zbc->headerBuffer + zbc->hPos, ZSTDv05_frameHeaderSize_max - zbc->hPos,
-                    src, *srcSizePtr);
-                zbc->hPos += headerSize;
-                ip += headerSize;
-                headerSize = ZSTDv05_getFrameParams(&(zbc->params), zbc->headerBuffer, zbc->hPos);
-                if (ZSTDv05_isError(headerSize)) return headerSize;
-                if (headerSize) {
-                    /* not enough input to decode header : tell how many bytes would be necessary */
-                    *maxDstSizePtr = 0;
-                    return headerSize - zbc->hPos;
-                }
-                // zbc->stage = ZBUFFv05ds_decodeHeader; break;   /* useless : stage follows */
-            }
-
-        case ZBUFFv05ds_decodeHeader:
-                /* apply header to create / resize buffers */
-                {
-                    size_t neededOutSize = (size_t)1 << zbc->params.windowLog;
-                    size_t neededInSize = BLOCKSIZE;   /* a block is never > BLOCKSIZE */
-                    if (zbc->inBuffSize < neededInSize) {
-                        free(zbc->inBuff);
-                        zbc->inBuffSize = neededInSize;
-                        zbc->inBuff = (char*)malloc(neededInSize);
-                        if (zbc->inBuff == NULL) return ERROR(memory_allocation);
-                    }
-                    if (zbc->outBuffSize < neededOutSize) {
-                        free(zbc->outBuff);
-                        zbc->outBuffSize = neededOutSize;
-                        zbc->outBuff = (char*)malloc(neededOutSize);
-                        if (zbc->outBuff == NULL) return ERROR(memory_allocation);
-                }   }
-                if (zbc->hPos) {
-                    /* some data already loaded into headerBuffer : transfer into inBuff */
-                    memcpy(zbc->inBuff, zbc->headerBuffer, zbc->hPos);
-                    zbc->inPos = zbc->hPos;
-                    zbc->hPos = 0;
-                    zbc->stage = ZBUFFv05ds_load;
-                    break;
-                }
-                zbc->stage = ZBUFFv05ds_read;
-
-        case ZBUFFv05ds_read:
-            {
-                size_t neededInSize = ZSTDv05_nextSrcSizeToDecompress(zbc->zc);
-                if (neededInSize==0) {  /* end of frame */
-                    zbc->stage = ZBUFFv05ds_init;
-                    notDone = 0;
-                    break;
-                }
-                if ((size_t)(iend-ip) >= neededInSize) {
-                    /* directly decode from src */
-                    size_t decodedSize = ZSTDv05_decompressContinue(zbc->zc,
-                        zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart,
-                        ip, neededInSize);
-                    if (ZSTDv05_isError(decodedSize)) return decodedSize;
-                    ip += neededInSize;
-                    if (!decodedSize) break;   /* this was just a header */
-                    zbc->outEnd = zbc->outStart +  decodedSize;
-                    zbc->stage = ZBUFFv05ds_flush;
-                    break;
-                }
-                if (ip==iend) { notDone = 0; break; }   /* no more input */
-                zbc->stage = ZBUFFv05ds_load;
-            }
-
-        case ZBUFFv05ds_load:
-            {
-                size_t neededInSize = ZSTDv05_nextSrcSizeToDecompress(zbc->zc);
-                size_t toLoad = neededInSize - zbc->inPos;   /* should always be <= remaining space within inBuff */
-                size_t loadedSize;
-                if (toLoad > zbc->inBuffSize - zbc->inPos) return ERROR(corruption_detected);   /* should never happen */
-                loadedSize = ZBUFFv05_limitCopy(zbc->inBuff + zbc->inPos, toLoad, ip, iend-ip);
-                ip += loadedSize;
-                zbc->inPos += loadedSize;
-                if (loadedSize < toLoad) { notDone = 0; break; }   /* not enough input, wait for more */
-                {
-                    size_t decodedSize = ZSTDv05_decompressContinue(zbc->zc,
-                        zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart,
-                        zbc->inBuff, neededInSize);
-                    if (ZSTDv05_isError(decodedSize)) return decodedSize;
-                    zbc->inPos = 0;   /* input is consumed */
-                    if (!decodedSize) { zbc->stage = ZBUFFv05ds_read; break; }   /* this was just a header */
-                    zbc->outEnd = zbc->outStart +  decodedSize;
-                    zbc->stage = ZBUFFv05ds_flush;
-                    // break; /* ZBUFFv05ds_flush follows */
-            }   }
-        case ZBUFFv05ds_flush:
-            {
-                size_t toFlushSize = zbc->outEnd - zbc->outStart;
-                size_t flushedSize = ZBUFFv05_limitCopy(op, oend-op, zbc->outBuff + zbc->outStart, toFlushSize);
-                op += flushedSize;
-                zbc->outStart += flushedSize;
-                if (flushedSize == toFlushSize) {
-                    zbc->stage = ZBUFFv05ds_read;
-                    if (zbc->outStart + BLOCKSIZE > zbc->outBuffSize)
-                        zbc->outStart = zbc->outEnd = 0;
-                    break;
-                }
-                /* cannot flush everything */
-                notDone = 0;
-                break;
-            }
-        default: return ERROR(GENERIC);   /* impossible */
-    }   }
-
-    *srcSizePtr = ip-istart;
-    *maxDstSizePtr = op-ostart;
-
+            if (ZSTDv05_isError(result)) return result; 
+            dctx->expected = ZSTDv05_blockHeaderSize; 
+            dctx->stage = ZSTDv05ds_decodeBlockHeader; 
+            return 0; 
+        } 
+    case ZSTDv05ds_decodeBlockHeader: 
+        { 
+            /* Decode block header */ 
+            blockProperties_t bp; 
+            size_t blockSize = ZSTDv05_getcBlockSize(src, ZSTDv05_blockHeaderSize, &bp); 
+            if (ZSTDv05_isError(blockSize)) return blockSize; 
+            if (bp.blockType == bt_end) { 
+                dctx->expected = 0; 
+                dctx->stage = ZSTDv05ds_getFrameHeaderSize; 
+            } 
+            else { 
+                dctx->expected = blockSize; 
+                dctx->bType = bp.blockType; 
+                dctx->stage = ZSTDv05ds_decompressBlock; 
+            } 
+            return 0; 
+        } 
+    case ZSTDv05ds_decompressBlock: 
+        { 
+            /* Decompress : block content */ 
+            size_t rSize; 
+            switch(dctx->bType) 
+            { 
+            case bt_compressed: 
+                rSize = ZSTDv05_decompressBlock_internal(dctx, dst, maxDstSize, src, srcSize); 
+                break; 
+            case bt_raw : 
+                rSize = ZSTDv05_copyRawBlock(dst, maxDstSize, src, srcSize); 
+                break; 
+            case bt_rle : 
+                return ERROR(GENERIC);   /* not yet handled */ 
+                break; 
+            case bt_end :   /* should never happen (filtered at phase 1) */ 
+                rSize = 0; 
+                break; 
+            default: 
+                return ERROR(GENERIC);   /* impossible */ 
+            } 
+            dctx->stage = ZSTDv05ds_decodeBlockHeader; 
+            dctx->expected = ZSTDv05_blockHeaderSize; 
+            dctx->previousDstEnd = (char*)dst + rSize; 
+            return rSize; 
+        } 
+    default: 
+        return ERROR(GENERIC);   /* impossible */ 
+    } 
+} 
+ 
+ 
+static void ZSTDv05_refDictContent(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
+    dctx->dictEnd = dctx->previousDstEnd; 
+    dctx->vBase = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->base)); 
+    dctx->base = dict; 
+    dctx->previousDstEnd = (const char*)dict + dictSize; 
+} 
+ 
+static size_t ZSTDv05_loadEntropy(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
+    size_t hSize, offcodeHeaderSize, matchlengthHeaderSize, errorCode, litlengthHeaderSize; 
+    short offcodeNCount[MaxOff+1]; 
+    U32 offcodeMaxValue=MaxOff, offcodeLog=OffFSEv05Log; 
+    short matchlengthNCount[MaxML+1]; 
+    unsigned matchlengthMaxValue = MaxML, matchlengthLog = MLFSEv05Log; 
+    short litlengthNCount[MaxLL+1]; 
+    unsigned litlengthMaxValue = MaxLL, litlengthLog = LLFSEv05Log; 
+ 
+    hSize = HUFv05_readDTableX4(dctx->hufTableX4, dict, dictSize); 
+    if (HUFv05_isError(hSize)) return ERROR(dictionary_corrupted); 
+    dict = (const char*)dict + hSize; 
+    dictSize -= hSize; 
+ 
+    offcodeHeaderSize = FSEv05_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dict, dictSize); 
+    if (FSEv05_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted); 
+    errorCode = FSEv05_buildDTable(dctx->OffTable, offcodeNCount, offcodeMaxValue, offcodeLog); 
+    if (FSEv05_isError(errorCode)) return ERROR(dictionary_corrupted); 
+    dict = (const char*)dict + offcodeHeaderSize; 
+    dictSize -= offcodeHeaderSize; 
+ 
+    matchlengthHeaderSize = FSEv05_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dict, dictSize); 
+    if (FSEv05_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted); 
+    errorCode = FSEv05_buildDTable(dctx->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog); 
+    if (FSEv05_isError(errorCode)) return ERROR(dictionary_corrupted); 
+    dict = (const char*)dict + matchlengthHeaderSize; 
+    dictSize -= matchlengthHeaderSize; 
+ 
+    litlengthHeaderSize = FSEv05_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dict, dictSize); 
+    if (FSEv05_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted); 
+    errorCode = FSEv05_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog); 
+    if (FSEv05_isError(errorCode)) return ERROR(dictionary_corrupted); 
+ 
+    dctx->flagStaticTables = 1; 
+    return hSize + offcodeHeaderSize + matchlengthHeaderSize + litlengthHeaderSize; 
+} 
+ 
+static size_t ZSTDv05_decompress_insertDictionary(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
+    size_t eSize; 
+    U32 magic = MEM_readLE32(dict); 
+    if (magic != ZSTDv05_DICT_MAGIC) { 
+        /* pure content mode */ 
+        ZSTDv05_refDictContent(dctx, dict, dictSize); 
+        return 0; 
+    } 
+    /* load entropy tables */ 
+    dict = (const char*)dict + 4; 
+    dictSize -= 4; 
+    eSize = ZSTDv05_loadEntropy(dctx, dict, dictSize); 
+    if (ZSTDv05_isError(eSize)) return ERROR(dictionary_corrupted); 
+ 
+    /* reference dictionary content */ 
+    dict = (const char*)dict + eSize; 
+    dictSize -= eSize; 
+    ZSTDv05_refDictContent(dctx, dict, dictSize); 
+ 
+    return 0; 
+} 
+ 
+ 
+size_t ZSTDv05_decompressBegin_usingDict(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
+    size_t errorCode; 
+    errorCode = ZSTDv05_decompressBegin(dctx); 
+    if (ZSTDv05_isError(errorCode)) return errorCode; 
+ 
+    if (dict && dictSize) { 
+        errorCode = ZSTDv05_decompress_insertDictionary(dctx, dict, dictSize); 
+        if (ZSTDv05_isError(errorCode)) return ERROR(dictionary_corrupted); 
+    } 
+ 
+    return 0; 
+} 
+ 
+/* 
+    Buffered version 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 source repository : https://github.com/Cyan4973/zstd 
+    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c 
+*/ 
+ 
+/* The objects defined into this file should be considered experimental. 
+ * They are not labelled stable, as their prototype may change in the future. 
+ * You can use them for tests, provide feedback, or if you can endure risk of future changes. 
+ */ 
+ 
+ 
+ 
+/* ************************************* 
+*  Constants 
+***************************************/ 
+static size_t ZBUFFv05_blockHeaderSize = 3; 
+ 
+ 
+ 
+/* *** Compression *** */ 
+ 
+static size_t ZBUFFv05_limitCopy(void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    size_t length = MIN(maxDstSize, srcSize); 
+    memcpy(dst, src, length); 
+    return length; 
+} 
+ 
+ 
+ 
+ 
+/** ************************************************ 
+*  Streaming decompression 
+* 
+*  A ZBUFFv05_DCtx object is required to track streaming operation. 
+*  Use ZBUFFv05_createDCtx() and ZBUFFv05_freeDCtx() to create/release resources. 
+*  Use ZBUFFv05_decompressInit() to start a new decompression operation. 
+*  ZBUFFv05_DCtx objects can be reused multiple times. 
+* 
+*  Use ZBUFFv05_decompressContinue() repetitively to consume your input. 
+*  *srcSizePtr and *maxDstSizePtr can be any size. 
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *maxDstSizePtr. 
+*  Note that it may not consume the entire input, in which case it's up to the caller to call again the function with remaining input. 
+*  The content of dst will be overwritten (up to *maxDstSizePtr) at each function call, so save its content if it matters or change dst . 
+*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency) 
+*            or 0 when a frame is completely decoded 
+*            or an error code, which can be tested using ZBUFFv05_isError(). 
+* 
+*  Hint : recommended buffer sizes (not compulsory) 
+*  output : 128 KB block size is the internal unit, it ensures it's always possible to write a full block when it's decoded. 
+*  input : just follow indications from ZBUFFv05_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 . 
+* **************************************************/ 
+ 
+typedef enum { ZBUFFv05ds_init, ZBUFFv05ds_readHeader, ZBUFFv05ds_loadHeader, ZBUFFv05ds_decodeHeader, 
+               ZBUFFv05ds_read, ZBUFFv05ds_load, ZBUFFv05ds_flush } ZBUFFv05_dStage; 
+ 
+/* *** Resource management *** */ 
+ 
+#define ZSTDv05_frameHeaderSize_max 5   /* too magical, should come from reference */ 
+struct ZBUFFv05_DCtx_s { 
+    ZSTDv05_DCtx* zc; 
+    ZSTDv05_parameters params; 
+    char* inBuff; 
+    size_t inBuffSize; 
+    size_t inPos; 
+    char* outBuff; 
+    size_t outBuffSize; 
+    size_t outStart; 
+    size_t outEnd; 
+    size_t hPos; 
+    ZBUFFv05_dStage stage; 
+    unsigned char headerBuffer[ZSTDv05_frameHeaderSize_max]; 
+};   /* typedef'd to ZBUFFv05_DCtx within "zstd_buffered.h" */ 
+ 
+ 
+ZBUFFv05_DCtx* ZBUFFv05_createDCtx(void) 
+{ 
+    ZBUFFv05_DCtx* zbc = (ZBUFFv05_DCtx*)malloc(sizeof(ZBUFFv05_DCtx)); 
+    if (zbc==NULL) return NULL; 
+    memset(zbc, 0, sizeof(*zbc)); 
+    zbc->zc = ZSTDv05_createDCtx(); 
+    zbc->stage = ZBUFFv05ds_init; 
+    return zbc; 
+} 
+ 
+size_t ZBUFFv05_freeDCtx(ZBUFFv05_DCtx* zbc) 
+{ 
+    if (zbc==NULL) return 0;   /* support free on null */ 
+    ZSTDv05_freeDCtx(zbc->zc); 
+    free(zbc->inBuff); 
+    free(zbc->outBuff); 
+    free(zbc); 
+    return 0; 
+} 
+ 
+ 
+/* *** Initialization *** */ 
+ 
+size_t ZBUFFv05_decompressInitDictionary(ZBUFFv05_DCtx* zbc, const void* dict, size_t dictSize) 
+{ 
+    zbc->stage = ZBUFFv05ds_readHeader; 
+    zbc->hPos = zbc->inPos = zbc->outStart = zbc->outEnd = 0; 
+    return ZSTDv05_decompressBegin_usingDict(zbc->zc, dict, dictSize); 
+} 
+ 
+size_t ZBUFFv05_decompressInit(ZBUFFv05_DCtx* zbc) 
+{ 
+    return ZBUFFv05_decompressInitDictionary(zbc, NULL, 0); 
+} 
+ 
+ 
+/* *** Decompression *** */ 
+ 
+size_t ZBUFFv05_decompressContinue(ZBUFFv05_DCtx* zbc, void* dst, size_t* maxDstSizePtr, const void* src, size_t* srcSizePtr) 
+{ 
+    const char* const istart = (const char*)src; 
+    const char* ip = istart; 
+    const char* const iend = istart + *srcSizePtr; 
+    char* const ostart = (char*)dst; 
+    char* op = ostart; 
+    char* const oend = ostart + *maxDstSizePtr; 
+    U32 notDone = 1; 
+ 
+    while (notDone) { 
+        switch(zbc->stage) 
+        { 
+        case ZBUFFv05ds_init : 
+            return ERROR(init_missing); 
+ 
+        case ZBUFFv05ds_readHeader : 
+            /* read header from src */ 
+            { 
+                size_t headerSize = ZSTDv05_getFrameParams(&(zbc->params), src, *srcSizePtr); 
+                if (ZSTDv05_isError(headerSize)) return headerSize; 
+                if (headerSize) { 
+                    /* not enough input to decode header : tell how many bytes would be necessary */ 
+                    memcpy(zbc->headerBuffer+zbc->hPos, src, *srcSizePtr); 
+                    zbc->hPos += *srcSizePtr; 
+                    *maxDstSizePtr = 0; 
+                    zbc->stage = ZBUFFv05ds_loadHeader; 
+                    return headerSize - zbc->hPos; 
+                } 
+                zbc->stage = ZBUFFv05ds_decodeHeader; 
+                break; 
+            } 
+ 
+        case ZBUFFv05ds_loadHeader: 
+            /* complete header from src */ 
+            { 
+                size_t headerSize = ZBUFFv05_limitCopy( 
+                    zbc->headerBuffer + zbc->hPos, ZSTDv05_frameHeaderSize_max - zbc->hPos, 
+                    src, *srcSizePtr); 
+                zbc->hPos += headerSize; 
+                ip += headerSize; 
+                headerSize = ZSTDv05_getFrameParams(&(zbc->params), zbc->headerBuffer, zbc->hPos); 
+                if (ZSTDv05_isError(headerSize)) return headerSize; 
+                if (headerSize) { 
+                    /* not enough input to decode header : tell how many bytes would be necessary */ 
+                    *maxDstSizePtr = 0; 
+                    return headerSize - zbc->hPos; 
+                } 
+                // zbc->stage = ZBUFFv05ds_decodeHeader; break;   /* useless : stage follows */ 
+            } 
+ 
+        case ZBUFFv05ds_decodeHeader: 
+                /* apply header to create / resize buffers */ 
+                { 
+                    size_t neededOutSize = (size_t)1 << zbc->params.windowLog; 
+                    size_t neededInSize = BLOCKSIZE;   /* a block is never > BLOCKSIZE */ 
+                    if (zbc->inBuffSize < neededInSize) { 
+                        free(zbc->inBuff); 
+                        zbc->inBuffSize = neededInSize; 
+                        zbc->inBuff = (char*)malloc(neededInSize); 
+                        if (zbc->inBuff == NULL) return ERROR(memory_allocation); 
+                    } 
+                    if (zbc->outBuffSize < neededOutSize) { 
+                        free(zbc->outBuff); 
+                        zbc->outBuffSize = neededOutSize; 
+                        zbc->outBuff = (char*)malloc(neededOutSize); 
+                        if (zbc->outBuff == NULL) return ERROR(memory_allocation); 
+                }   } 
+                if (zbc->hPos) { 
+                    /* some data already loaded into headerBuffer : transfer into inBuff */ 
+                    memcpy(zbc->inBuff, zbc->headerBuffer, zbc->hPos); 
+                    zbc->inPos = zbc->hPos; 
+                    zbc->hPos = 0; 
+                    zbc->stage = ZBUFFv05ds_load; 
+                    break; 
+                } 
+                zbc->stage = ZBUFFv05ds_read; 
+ 
+        case ZBUFFv05ds_read: 
+            { 
+                size_t neededInSize = ZSTDv05_nextSrcSizeToDecompress(zbc->zc); 
+                if (neededInSize==0) {  /* end of frame */ 
+                    zbc->stage = ZBUFFv05ds_init; 
+                    notDone = 0; 
+                    break; 
+                } 
+                if ((size_t)(iend-ip) >= neededInSize) { 
+                    /* directly decode from src */ 
+                    size_t decodedSize = ZSTDv05_decompressContinue(zbc->zc, 
+                        zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart, 
+                        ip, neededInSize); 
+                    if (ZSTDv05_isError(decodedSize)) return decodedSize; 
+                    ip += neededInSize; 
+                    if (!decodedSize) break;   /* this was just a header */ 
+                    zbc->outEnd = zbc->outStart +  decodedSize; 
+                    zbc->stage = ZBUFFv05ds_flush; 
+                    break; 
+                } 
+                if (ip==iend) { notDone = 0; break; }   /* no more input */ 
+                zbc->stage = ZBUFFv05ds_load; 
+            } 
+ 
+        case ZBUFFv05ds_load: 
+            { 
+                size_t neededInSize = ZSTDv05_nextSrcSizeToDecompress(zbc->zc); 
+                size_t toLoad = neededInSize - zbc->inPos;   /* should always be <= remaining space within inBuff */ 
+                size_t loadedSize; 
+                if (toLoad > zbc->inBuffSize - zbc->inPos) return ERROR(corruption_detected);   /* should never happen */ 
+                loadedSize = ZBUFFv05_limitCopy(zbc->inBuff + zbc->inPos, toLoad, ip, iend-ip); 
+                ip += loadedSize; 
+                zbc->inPos += loadedSize; 
+                if (loadedSize < toLoad) { notDone = 0; break; }   /* not enough input, wait for more */ 
+                { 
+                    size_t decodedSize = ZSTDv05_decompressContinue(zbc->zc, 
+                        zbc->outBuff + zbc->outStart, zbc->outBuffSize - zbc->outStart, 
+                        zbc->inBuff, neededInSize); 
+                    if (ZSTDv05_isError(decodedSize)) return decodedSize; 
+                    zbc->inPos = 0;   /* input is consumed */ 
+                    if (!decodedSize) { zbc->stage = ZBUFFv05ds_read; break; }   /* this was just a header */ 
+                    zbc->outEnd = zbc->outStart +  decodedSize; 
+                    zbc->stage = ZBUFFv05ds_flush; 
+                    // break; /* ZBUFFv05ds_flush follows */ 
+            }   } 
+        case ZBUFFv05ds_flush: 
+            { 
+                size_t toFlushSize = zbc->outEnd - zbc->outStart; 
+                size_t flushedSize = ZBUFFv05_limitCopy(op, oend-op, zbc->outBuff + zbc->outStart, toFlushSize); 
+                op += flushedSize; 
+                zbc->outStart += flushedSize; 
+                if (flushedSize == toFlushSize) { 
+                    zbc->stage = ZBUFFv05ds_read; 
+                    if (zbc->outStart + BLOCKSIZE > zbc->outBuffSize) 
+                        zbc->outStart = zbc->outEnd = 0; 
+                    break; 
+                } 
+                /* cannot flush everything */ 
+                notDone = 0; 
+                break; 
+            } 
+        default: return ERROR(GENERIC);   /* impossible */ 
+    }   } 
+ 
+    *srcSizePtr = ip-istart; 
+    *maxDstSizePtr = op-ostart; 
+ 
     {   size_t nextSrcSizeHint = ZSTDv05_nextSrcSizeToDecompress(zbc->zc);
-        if (nextSrcSizeHint > ZBUFFv05_blockHeaderSize) nextSrcSizeHint+= ZBUFFv05_blockHeaderSize;   /* get next block header too */
-        nextSrcSizeHint -= zbc->inPos;   /* already loaded*/
-        return nextSrcSizeHint;
-    }
-}
-
-
-
-/* *************************************
-*  Tool functions
-***************************************/
-unsigned ZBUFFv05_isError(size_t errorCode) { return ERR_isError(errorCode); }
-const char* ZBUFFv05_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
-
-size_t ZBUFFv05_recommendedDInSize(void)  { return BLOCKSIZE + ZBUFFv05_blockHeaderSize /* block header size*/ ; }
-size_t ZBUFFv05_recommendedDOutSize(void) { return BLOCKSIZE; }
+        if (nextSrcSizeHint > ZBUFFv05_blockHeaderSize) nextSrcSizeHint+= ZBUFFv05_blockHeaderSize;   /* get next block header too */ 
+        nextSrcSizeHint -= zbc->inPos;   /* already loaded*/ 
+        return nextSrcSizeHint; 
+    } 
+} 
+ 
+ 
+ 
+/* ************************************* 
+*  Tool functions 
+***************************************/ 
+unsigned ZBUFFv05_isError(size_t errorCode) { return ERR_isError(errorCode); } 
+const char* ZBUFFv05_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); } 
+ 
+size_t ZBUFFv05_recommendedDInSize(void)  { return BLOCKSIZE + ZBUFFv05_blockHeaderSize /* block header size*/ ; } 
+size_t ZBUFFv05_recommendedDOutSize(void) { return BLOCKSIZE; } 
diff --git a/contrib/libs/zstd06/legacy/zstd_v05.h b/contrib/libs/zstd06/legacy/zstd_v05.h
index a20e6c7068..5f5354a1c9 100644
--- a/contrib/libs/zstd06/legacy/zstd_v05.h
+++ b/contrib/libs/zstd06/legacy/zstd_v05.h
@@ -1,94 +1,94 @@
 #include <contrib/libs/zstd06/renames.h>
-/*
-    zstd_v05 - decoder for 0.5 format
-    Header File
-    Copyright (C) 2014-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 source repository : https://github.com/Cyan4973/zstd
-*/
-#ifndef ZSTDv05_H
-#define ZSTDv05_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include <stddef.h>   /* size_t */
+/* 
+    zstd_v05 - decoder for 0.5 format 
+    Header File 
+    Copyright (C) 2014-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 source repository : https://github.com/Cyan4973/zstd 
+*/ 
+#ifndef ZSTDv05_H 
+#define ZSTDv05_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/*-************************************* 
+*  Dependencies 
+***************************************/ 
+#include <stddef.h>   /* size_t */ 
 #include "mem.h"      /* U64, U32 */
-
-
-/* *************************************
-*  Simple functions
-***************************************/
-/*! ZSTDv05_decompress() :
-    `compressedSize` : is the _exact_ size of the compressed blob, otherwise decompression will fail.
-    `dstCapacity` must be large enough, equal or larger than originalSize.
-    @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),
-              or an errorCode if it fails (which can be tested using ZSTDv05_isError()) */
-size_t ZSTDv05_decompress( void* dst, size_t dstCapacity,
-                     const void* src, size_t compressedSize);
-
-
-/* *************************************
-*  Helper functions
-***************************************/
-/* Error Management */
-unsigned    ZSTDv05_isError(size_t code);          /*!< tells if a `size_t` function result is an error code */
-const char* ZSTDv05_getErrorName(size_t code);     /*!< provides readable string for an error code */
-
-
-/* *************************************
-*  Explicit memory management
-***************************************/
-/** Decompression context */
-typedef struct ZSTDv05_DCtx_s ZSTDv05_DCtx;
-ZSTDv05_DCtx* ZSTDv05_createDCtx(void);
+ 
+ 
+/* ************************************* 
+*  Simple functions 
+***************************************/ 
+/*! ZSTDv05_decompress() : 
+    `compressedSize` : is the _exact_ size of the compressed blob, otherwise decompression will fail. 
+    `dstCapacity` must be large enough, equal or larger than originalSize. 
+    @return : the number of bytes decompressed into `dst` (<= `dstCapacity`), 
+              or an errorCode if it fails (which can be tested using ZSTDv05_isError()) */ 
+size_t ZSTDv05_decompress( void* dst, size_t dstCapacity, 
+                     const void* src, size_t compressedSize); 
+ 
+ 
+/* ************************************* 
+*  Helper functions 
+***************************************/ 
+/* Error Management */ 
+unsigned    ZSTDv05_isError(size_t code);          /*!< tells if a `size_t` function result is an error code */ 
+const char* ZSTDv05_getErrorName(size_t code);     /*!< provides readable string for an error code */ 
+ 
+ 
+/* ************************************* 
+*  Explicit memory management 
+***************************************/ 
+/** Decompression context */ 
+typedef struct ZSTDv05_DCtx_s ZSTDv05_DCtx; 
+ZSTDv05_DCtx* ZSTDv05_createDCtx(void); 
 size_t ZSTDv05_freeDCtx(ZSTDv05_DCtx* dctx);      /*!< @return : errorCode */
-
-/** ZSTDv05_decompressDCtx() :
-*   Same as ZSTDv05_decompress(), but requires an already allocated ZSTDv05_DCtx (see ZSTDv05_createDCtx()) */
-size_t ZSTDv05_decompressDCtx(ZSTDv05_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-
-/*-***********************
+ 
+/** ZSTDv05_decompressDCtx() : 
+*   Same as ZSTDv05_decompress(), but requires an already allocated ZSTDv05_DCtx (see ZSTDv05_createDCtx()) */ 
+size_t ZSTDv05_decompressDCtx(ZSTDv05_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize); 
+ 
+ 
+/*-*********************** 
 *  Simple Dictionary API
-*************************/
-/*! ZSTDv05_decompress_usingDict() :
-*   Decompression using a pre-defined Dictionary content (see dictBuilder).
-*   Dictionary must be identical to the one used during compression, otherwise regenerated data will be corrupted.
-*   Note : dict can be NULL, in which case, it's equivalent to ZSTDv05_decompressDCtx() */
-size_t ZSTDv05_decompress_usingDict(ZSTDv05_DCtx* dctx,
+*************************/ 
+/*! ZSTDv05_decompress_usingDict() : 
+*   Decompression using a pre-defined Dictionary content (see dictBuilder). 
+*   Dictionary must be identical to the one used during compression, otherwise regenerated data will be corrupted. 
+*   Note : dict can be NULL, in which case, it's equivalent to ZSTDv05_decompressDCtx() */ 
+size_t ZSTDv05_decompress_usingDict(ZSTDv05_DCtx* dctx, 
                                             void* dst, size_t dstCapacity,
                                       const void* src, size_t srcSize,
                                       const void* dict,size_t dictSize);
-
+ 
 /*-************************
 *  Advanced Streaming API
 ***************************/
@@ -99,74 +99,74 @@ typedef struct {
     U32 contentLog; U32 hashLog; U32 searchLog; U32 searchLength; U32 targetLength; ZSTDv05_strategy strategy;
 } ZSTDv05_parameters;
 size_t ZSTDv05_getFrameParams(ZSTDv05_parameters* params, const void* src, size_t srcSize);
-
+ 
 size_t ZSTDv05_decompressBegin_usingDict(ZSTDv05_DCtx* dctx, const void* dict, size_t dictSize);
 void   ZSTDv05_copyDCtx(ZSTDv05_DCtx* dstDCtx, const ZSTDv05_DCtx* srcDCtx);
 size_t ZSTDv05_nextSrcSizeToDecompress(ZSTDv05_DCtx* dctx);
 size_t ZSTDv05_decompressContinue(ZSTDv05_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-
+ 
+ 
 /*-***********************
 *  ZBUFF API
 *************************/
-typedef struct ZBUFFv05_DCtx_s ZBUFFv05_DCtx;
-ZBUFFv05_DCtx* ZBUFFv05_createDCtx(void);
+typedef struct ZBUFFv05_DCtx_s ZBUFFv05_DCtx; 
+ZBUFFv05_DCtx* ZBUFFv05_createDCtx(void); 
 size_t         ZBUFFv05_freeDCtx(ZBUFFv05_DCtx* dctx);
-
-size_t ZBUFFv05_decompressInit(ZBUFFv05_DCtx* dctx);
-size_t ZBUFFv05_decompressInitDictionary(ZBUFFv05_DCtx* dctx, const void* dict, size_t dictSize);
-
-size_t ZBUFFv05_decompressContinue(ZBUFFv05_DCtx* dctx,
-                                            void* dst, size_t* dstCapacityPtr,
-                                      const void* src, size_t* srcSizePtr);
-
-/*-***************************************************************************
-*  Streaming decompression
-*
-*  A ZBUFFv05_DCtx object is required to track streaming operations.
-*  Use ZBUFFv05_createDCtx() and ZBUFFv05_freeDCtx() to create/release resources.
-*  Use ZBUFFv05_decompressInit() to start a new decompression operation,
-*   or ZBUFFv05_decompressInitDictionary() if decompression requires a dictionary.
-*  Note that ZBUFFv05_DCtx objects can be reused multiple times.
-*
-*  Use ZBUFFv05_decompressContinue() repetitively to consume your input.
-*  *srcSizePtr and *dstCapacityPtr can be any size.
-*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.
-*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.
-*  The content of @dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters or change @dst.
-*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency)
-*            or 0 when a frame is completely decoded
-*            or an error code, which can be tested using ZBUFFv05_isError().
-*
-*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv05_recommendedDInSize() / ZBUFFv05_recommendedDOutSize()
-*  output : ZBUFFv05_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
-*  input  : ZBUFFv05_recommendedDInSize==128Kb+3; just follow indications from ZBUFFv05_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
-* *******************************************************************************/
-
-
-/* *************************************
-*  Tool functions
-***************************************/
-unsigned ZBUFFv05_isError(size_t errorCode);
-const char* ZBUFFv05_getErrorName(size_t errorCode);
-
-/** Functions below provide recommended buffer sizes for Compression or Decompression operations.
-*   These sizes are just hints, and tend to offer better latency */
-size_t ZBUFFv05_recommendedDInSize(void);
-size_t ZBUFFv05_recommendedDOutSize(void);
-
-
-
-/*-*************************************
-*  Constants
-***************************************/
-#define ZSTDv05_MAGICNUMBER 0xFD2FB525   /* v0.5 */
-
-
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* ZSTDv0505_H */
+ 
+size_t ZBUFFv05_decompressInit(ZBUFFv05_DCtx* dctx); 
+size_t ZBUFFv05_decompressInitDictionary(ZBUFFv05_DCtx* dctx, const void* dict, size_t dictSize); 
+ 
+size_t ZBUFFv05_decompressContinue(ZBUFFv05_DCtx* dctx, 
+                                            void* dst, size_t* dstCapacityPtr, 
+                                      const void* src, size_t* srcSizePtr); 
+ 
+/*-*************************************************************************** 
+*  Streaming decompression 
+* 
+*  A ZBUFFv05_DCtx object is required to track streaming operations. 
+*  Use ZBUFFv05_createDCtx() and ZBUFFv05_freeDCtx() to create/release resources. 
+*  Use ZBUFFv05_decompressInit() to start a new decompression operation, 
+*   or ZBUFFv05_decompressInitDictionary() if decompression requires a dictionary. 
+*  Note that ZBUFFv05_DCtx objects can be reused multiple times. 
+* 
+*  Use ZBUFFv05_decompressContinue() repetitively to consume your input. 
+*  *srcSizePtr and *dstCapacityPtr can be any size. 
+*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr. 
+*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again. 
+*  The content of @dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters or change @dst. 
+*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to help latency) 
+*            or 0 when a frame is completely decoded 
+*            or an error code, which can be tested using ZBUFFv05_isError(). 
+* 
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv05_recommendedDInSize() / ZBUFFv05_recommendedDOutSize() 
+*  output : ZBUFFv05_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded. 
+*  input  : ZBUFFv05_recommendedDInSize==128Kb+3; just follow indications from ZBUFFv05_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 . 
+* *******************************************************************************/ 
+ 
+ 
+/* ************************************* 
+*  Tool functions 
+***************************************/ 
+unsigned ZBUFFv05_isError(size_t errorCode); 
+const char* ZBUFFv05_getErrorName(size_t errorCode); 
+ 
+/** Functions below provide recommended buffer sizes for Compression or Decompression operations. 
+*   These sizes are just hints, and tend to offer better latency */ 
+size_t ZBUFFv05_recommendedDInSize(void); 
+size_t ZBUFFv05_recommendedDOutSize(void); 
+ 
+ 
+ 
+/*-************************************* 
+*  Constants 
+***************************************/ 
+#define ZSTDv05_MAGICNUMBER 0xFD2FB525   /* v0.5 */ 
+ 
+ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* ZSTDv0505_H */ 
diff --git a/contrib/libs/zstd06/libzstd.pc.in b/contrib/libs/zstd06/libzstd.pc.in
index 28afc3add5..63e2483f55 100755
--- a/contrib/libs/zstd06/libzstd.pc.in
+++ b/contrib/libs/zstd06/libzstd.pc.in
@@ -1,14 +1,14 @@
-#   ZSTD - standard compression algorithm
-#   Copyright (C) 2014-2015, Yann Collet.
-#   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-prefix=@PREFIX@
-libdir=@LIBDIR@
-includedir=@INCLUDEDIR@
-
-Name: zstd
-Description: lossless compression algorithm library
-URL: https://github.com/Cyan4973/zstd
-Version: @VERSION@
-Libs: -L@LIBDIR@ -lzstd
-Cflags: -I@INCLUDEDIR@
+#   ZSTD - standard compression algorithm 
+#   Copyright (C) 2014-2015, Yann Collet. 
+#   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+prefix=@PREFIX@ 
+libdir=@LIBDIR@ 
+includedir=@INCLUDEDIR@ 
+ 
+Name: zstd 
+Description: lossless compression algorithm library 
+URL: https://github.com/Cyan4973/zstd 
+Version: @VERSION@ 
+Libs: -L@LIBDIR@ -lzstd 
+Cflags: -I@INCLUDEDIR@ 
diff --git a/contrib/libs/zstd06/ya.make b/contrib/libs/zstd06/ya.make
index e35f69f443..0446eaf7ca 100644
--- a/contrib/libs/zstd06/ya.make
+++ b/contrib/libs/zstd06/ya.make
@@ -1,5 +1,5 @@
-LIBRARY()
-
+LIBRARY() 
+ 
 VERSION(0.6.2)
 
 LICENSE(
@@ -14,10 +14,10 @@ OWNER(
     g:contrib
     g:cpp-contrib
 )
-
-NO_UTIL()
-
-SRCS(
+ 
+NO_UTIL() 
+ 
+SRCS( 
     common/entropy_common.c
     common/fse_decompress.c
     common/xxhash.c
@@ -31,28 +31,28 @@ SRCS(
     decompress/zstd_decompress.c
     dictBuilder/divsufsort.c
     dictBuilder/zdict.c
-    legacy/zstd_v01.c
-    legacy/zstd_v02.c
-    legacy/zstd_v03.c
-    legacy/zstd_v04.c
+    legacy/zstd_v01.c 
+    legacy/zstd_v02.c 
+    legacy/zstd_v03.c 
+    legacy/zstd_v04.c 
     legacy/zstd_v05.c
     legacy/zstd_v07.c
     legacy/zstd_v08.c
-)
-
+) 
+ 
 NO_COMPILER_WARNINGS()
 
 CFLAGS(
     -DZSTD_LEGACY_SUPPORT=1
 )
-
-ADDINCL(
-    contrib/libs/zstd06
+ 
+ADDINCL( 
+    contrib/libs/zstd06 
     contrib/libs/zstd06/common
     contrib/libs/zstd06/compress
     contrib/libs/zstd06/decompress
     contrib/libs/zstd06/dictBuilder
-    contrib/libs/zstd06/legacy
-)
-
-END()
+    contrib/libs/zstd06/legacy 
+) 
+ 
+END()