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

36 files changed, 31016 insertions, 31016 deletions

diff --git a/contrib/libs/zstd/lib/common/bitstream.h b/contrib/libs/zstd/lib/common/bitstream.h
index 84b6062ff3..ae6a211519 100644
--- a/contrib/libs/zstd/lib/common/bitstream.h
+++ b/contrib/libs/zstd/lib/common/bitstream.h
@@ -1,4 +1,4 @@
-/* ******************************************************************
+/* ****************************************************************** 
  * bitstream
  * Part of FSE library
  * Copyright (c) Yann Collet, Facebook, Inc.
@@ -10,138 +10,138 @@
  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-#ifndef 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 */
+****************************************************************** */ 
+#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 "compiler.h"       /* UNLIKELY() */
 #include "debug.h"          /* assert(), DEBUGLOG(), RAWLOG() */
-#include "error_private.h"  /* error codes and messages */
-
-
-/*=========================================
-*  Target specific
-=========================================*/
+#include "error_private.h"  /* error codes and messages */ 
+ 
+ 
+/*========================================= 
+*  Target specific 
+=========================================*/ 
 #ifndef ZSTD_NO_INTRINSICS
 #  if defined(__BMI__) && defined(__GNUC__)
 #    include <immintrin.h>   /* support for bextr (experimental) */
 #  elif defined(__ICCARM__)
 #    include <intrinsics.h>
 #  endif
-#endif
-
+#endif 
+ 
 #define STREAM_ACCUMULATOR_MIN_32  25
 #define STREAM_ACCUMULATOR_MIN_64  57
 #define STREAM_ACCUMULATOR_MIN    ((U32)(MEM_32bits() ? STREAM_ACCUMULATOR_MIN_32 : STREAM_ACCUMULATOR_MIN_64))
+ 
 
-
-/*-******************************************
-*  bitStream encoding API (write forward)
-********************************************/
-/* bitStream can mix input from multiple sources.
+/*-****************************************** 
+*  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;
+    size_t bitContainer; 
     unsigned 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)
-**********************************************/
+    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;
+    size_t   bitContainer; 
+    unsigned bitsConsumed; 
+    const char* ptr; 
+    const char* start; 
     const char* limitPtr;
-} 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
-****************************************************************/
+} 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 (U32 val)
-{
+{ 
     assert(val != 0);
     {
-#   if defined(_MSC_VER)   /* Visual */
+#   if defined(_MSC_VER)   /* Visual */ 
 #       if STATIC_BMI2 == 1
             return _lzcnt_u32(val) ^ 31;
 #       else
@@ -154,11 +154,11 @@ MEM_STATIC unsigned BIT_highbit32 (U32 val)
                 __assume(0);
             }
 #       endif
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */ 
         return __builtin_clz (val) ^ 31;
 #   elif defined(__ICCARM__)    /* IAR Intrinsic */
         return 31 - __CLZ(val);
-#   else   /* Software version */
+#   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,
@@ -170,11 +170,11 @@ MEM_STATIC unsigned BIT_highbit32 (U32 val)
         v |= v >> 8;
         v |= v >> 16;
         return DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
-#   endif
+#   endif 
     }
-}
-
-/*=====    Local Constants   =====*/
+} 
+ 
+/*=====    Local Constants   =====*/ 
 static const unsigned BIT_mask[] = {
     0,          1,         3,         7,         0xF,       0x1F,
     0x3F,       0x7F,      0xFF,      0x1FF,     0x3FF,     0x7FF,
@@ -183,121 +183,121 @@ static const unsigned BIT_mask[] = {
     0xFFFFFF,   0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, 0xFFFFFFF, 0x1FFFFFFF,
     0x3FFFFFFF, 0x7FFFFFFF}; /* up to 31 bits */
 #define BIT_MASK_SIZE (sizeof(BIT_mask) / sizeof(BIT_mask[0]))
-
-/*-**************************************************************
-*  bitStream encoding
-****************************************************************/
-/*! BIT_initCStream() :
+ 
+/*-************************************************************** 
+*  bitStream encoding 
+****************************************************************/ 
+/*! BIT_initCStream() : 
  *  `dstCapacity` must be > sizeof(size_t)
- *  @return : 0 if success,
+ *  @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->bitContainer = 0; 
+    bitC->bitPos = 0; 
+    bitC->startPtr = (char*)startPtr; 
+    bitC->ptr = bitC->startPtr; 
     bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->bitContainer);
     if (dstCapacity <= sizeof(bitC->bitContainer)) return ERROR(dstSize_tooSmall);
-    return 0;
-}
-
-/*! BIT_addBits() :
+    return 0; 
+} 
+ 
+/*! BIT_addBits() : 
  *  can add up to 31 bits into `bitC`.
  *  Note : does not check for register overflow ! */
 MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC,
                             size_t value, unsigned nbBits)
-{
+{ 
     DEBUG_STATIC_ASSERT(BIT_MASK_SIZE == 32);
     assert(nbBits < BIT_MASK_SIZE);
     assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);
-    bitC->bitContainer |= (value & BIT_mask[nbBits]) << bitC->bitPos;
-    bitC->bitPos += nbBits;
-}
-
-/*! BIT_addBitsFast() :
+    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)
-{
+{ 
     assert((value>>nbBits) == 0);
     assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);
-    bitC->bitContainer |= value << bitC->bitPos;
-    bitC->bitPos += nbBits;
-}
-
-/*! BIT_flushBitsFast() :
+    bitC->bitContainer |= value << bitC->bitPos; 
+    bitC->bitPos += nbBits; 
+} 
+ 
+/*! BIT_flushBitsFast() : 
  *  assumption : bitContainer has not overflowed
- *  unsafe version; does not check buffer overflow */
-MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC)
-{
-    size_t const nbBytes = bitC->bitPos >> 3;
+ *  unsafe version; does not check buffer overflow */ 
+MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC) 
+{ 
+    size_t const nbBytes = bitC->bitPos >> 3; 
     assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
     assert(bitC->ptr <= bitC->endPtr);
-    MEM_writeLEST(bitC->ptr, bitC->bitContainer);
-    bitC->ptr += nbBytes;
-    bitC->bitPos &= 7;
+    MEM_writeLEST(bitC->ptr, bitC->bitContainer); 
+    bitC->ptr += nbBytes; 
+    bitC->bitPos &= 7; 
     bitC->bitContainer >>= nbBytes*8;
-}
-
-/*! BIT_flushBits() :
+} 
+ 
+/*! BIT_flushBits() : 
  *  assumption : bitContainer has not overflowed
- *  safe version; check for buffer overflow, and prevents it.
+ *  safe version; check for buffer overflow, and prevents it. 
  *  note : does not signal buffer overflow.
  *  overflow 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_STATIC void BIT_flushBits(BIT_CStream_t* bitC) 
+{ 
+    size_t const nbBytes = bitC->bitPos >> 3; 
     assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
     assert(bitC->ptr <= bitC->endPtr);
-    MEM_writeLEST(bitC->ptr, bitC->bitContainer);
-    bitC->ptr += nbBytes;
-    if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr;
-    bitC->bitPos &= 7;
+    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;
-}
-
-/*! BIT_closeCStream() :
- *  @return : size of CStream, in bytes,
+} 
+ 
+/*! 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);
+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; /* overflow detected */
-    return (bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0);
-}
-
-
-/*-********************************************************
+    return (bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0); 
+} 
+ 
+ 
+/*-******************************************************** 
 *  bitStream decoding
-**********************************************************/
-/*! BIT_initDStream() :
+**********************************************************/ 
+/*! 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)
-{
+MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize) 
+{ 
     if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
-
+ 
     bitD->start = (const char*)srcBuffer;
     bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);
 
-    if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */
-        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);
-        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
+    if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */ 
+        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer); 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr); 
+        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; 
           bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;  /* ensures bitsConsumed is always set */
-          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
-    } else {
-        bitD->ptr   = bitD->start;
-        bitD->bitContainer = *(const BYTE*)(bitD->start);
-        switch(srcSize)
-        {
+          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ } 
+    } else { 
+        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);
                 ZSTD_FALLTHROUGH;
 
@@ -317,24 +317,24 @@ MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, si
                 ZSTD_FALLTHROUGH;
 
         default: break;
-        }
+        } 
         {   BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
             bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
             if (lastByte == 0) return ERROR(corruption_detected);  /* endMark not present */
         }
-        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
-    }
-
-    return srcSize;
-}
-
+        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; 
+    } 
+ 
+    return srcSize; 
+} 
+ 
 MEM_STATIC FORCE_INLINE_ATTR size_t BIT_getUpperBits(size_t bitContainer, U32 const start)
-{
-    return bitContainer >> start;
-}
-
+{ 
+    return bitContainer >> start; 
+} 
+ 
 MEM_STATIC FORCE_INLINE_ATTR size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 const nbBits)
-{
+{ 
     U32 const regMask = sizeof(bitContainer)*8 - 1;
     /* if start > regMask, bitstream is corrupted, and result is undefined */
     assert(nbBits < BIT_MASK_SIZE);
@@ -348,73 +348,73 @@ MEM_STATIC FORCE_INLINE_ATTR size_t BIT_getMiddleBits(size_t bitContainer, U32 c
 #else
     return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
 #endif
-}
-
+} 
+ 
 MEM_STATIC FORCE_INLINE_ATTR size_t BIT_getLowerBits(size_t bitContainer, U32 const nbBits)
-{
+{ 
 #if defined(STATIC_BMI2) && STATIC_BMI2 == 1
 	return  _bzhi_u64(bitContainer, nbBits);
 #else
     assert(nbBits < BIT_MASK_SIZE);
-    return bitContainer & BIT_mask[nbBits];
+    return bitContainer & BIT_mask[nbBits]; 
 #endif
-}
-
-/*! BIT_lookBits() :
- *  Provides next n bits from local register.
- *  local register is not modified.
- *  On 32-bits, maxNbBits==24.
- *  On 64-bits, maxNbBits==56.
+} 
+ 
+/*! 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  FORCE_INLINE_ATTR size_t BIT_lookBits(const BIT_DStream_t*  bitD, U32 nbBits)
-{
+{ 
     /* arbitrate between double-shift and shift+mask */
 #if 1
     /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8,
      * bitstream is likely corrupted, and result is undefined */
-    return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
-#else
+    return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits); 
+#else 
     /* this code path is slower on my os-x laptop */
     U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
     return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask);
-#endif
-}
-
-/*! BIT_lookBitsFast() :
+#endif 
+} 
+ 
+/*! BIT_lookBitsFast() : 
  *  unsafe version; only works if nbBits >= 1 */
-MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits)
-{
+MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits) 
+{ 
     U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;
     assert(nbBits >= 1);
     return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);
-}
-
+} 
+ 
 MEM_STATIC FORCE_INLINE_ATTR 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.
+{ 
+    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 FORCE_INLINE_ATTR size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits)
-{
-    size_t const value = BIT_lookBits(bitD, nbBits);
-    BIT_skipBits(bitD, nbBits);
-    return value;
-}
-
-/*! BIT_readBitsFast() :
+{ 
+    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, unsigned nbBits)
-{
-    size_t const value = BIT_lookBitsFast(bitD, nbBits);
+{ 
+    size_t const value = BIT_lookBitsFast(bitD, nbBits); 
     assert(nbBits >= 1);
-    BIT_skipBits(bitD, nbBits);
-    return value;
-}
-
+    BIT_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
 /*! BIT_reloadDStreamFast() :
  *  Similar to BIT_reloadDStream(), but with two differences:
  *  1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold!
@@ -432,47 +432,47 @@ MEM_STATIC BIT_DStream_status BIT_reloadDStreamFast(BIT_DStream_t* bitD)
     return BIT_DStream_unfinished;
 }
 
-/*! BIT_reloadDStream() :
+/*! BIT_reloadDStream() : 
  *  Refill `bitD` from buffer previously set in BIT_initDStream() .
  *  This function is safe, it guarantees it will not read beyond src buffer.
  * @return : status of `BIT_DStream_t` internal register.
  *           when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */
-MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
-{
+MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD) 
+{ 
     if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* overflow detected, like end of stream */
         return BIT_DStream_overflow;
-
+ 
     if (bitD->ptr >= bitD->limitPtr) {
         return BIT_reloadDStreamFast(bitD);
-    }
-    if (bitD->ptr == bitD->start) {
-        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
-        return BIT_DStream_completed;
-    }
+    } 
+    if (bitD->ptr == bitD->start) { 
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer; 
+        return BIT_DStream_completed; 
+    } 
     /* start < ptr < limitPtr */
-    {   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;
+    {   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->bitContainer), otherwise bitD->ptr == bitD->start */
-        return result;
-    }
-}
-
-/*! BIT_endOfDStream() :
+        return result; 
+    } 
+} 
+ 
+/*! BIT_endOfDStream() : 
  * @return : 1 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 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/zstd/lib/common/entropy_common.c b/contrib/libs/zstd/lib/common/entropy_common.c
index 4229b40c5e..19953650d6 100644
--- a/contrib/libs/zstd/lib/common/entropy_common.c
+++ b/contrib/libs/zstd/lib/common/entropy_common.c
@@ -11,35 +11,35 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
 ****************************************************************** */
-
-/* *************************************
-*  Dependencies
-***************************************/
-#include "mem.h"
-#include "error_private.h"       /* ERR_*, ERROR */
-#define FSE_STATIC_LINKING_ONLY  /* FSE_MIN_TABLELOG */
-#include "fse.h"
-#define HUF_STATIC_LINKING_ONLY  /* HUF_TABLELOG_ABSOLUTEMAX */
-#include "huf.h"
-
-
+ 
+/* ************************************* 
+*  Dependencies 
+***************************************/ 
+#include "mem.h" 
+#include "error_private.h"       /* ERR_*, ERROR */ 
+#define FSE_STATIC_LINKING_ONLY  /* FSE_MIN_TABLELOG */ 
+#include "fse.h" 
+#define HUF_STATIC_LINKING_ONLY  /* HUF_TABLELOG_ABSOLUTEMAX */ 
+#include "huf.h" 
+ 
+ 
 /*===   Version   ===*/
 unsigned FSE_versionNumber(void) { return FSE_VERSION_NUMBER; }
 
 
 /*===   Error Management   ===*/
 unsigned FSE_isError(size_t code) { return ERR_isError(code); }
-const char* FSE_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-unsigned HUF_isError(size_t code) { return ERR_isError(code); }
-const char* HUF_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-
-/*-**************************************************************
-*  FSE NCount encoding-decoding
-****************************************************************/
+const char* FSE_getErrorName(size_t code) { return ERR_getErrorName(code); } 
+ 
+unsigned HUF_isError(size_t code) { return ERR_isError(code); } 
+const char* HUF_getErrorName(size_t code) { return ERR_getErrorName(code); } 
+ 
+ 
+/*-************************************************************** 
+*  FSE NCount encoding-decoding 
+****************************************************************/ 
 static U32 FSE_ctz(U32 val)
-{
+{ 
     assert(val != 0);
     {
 #   if defined(_MSC_VER)   /* Visual */
@@ -70,18 +70,18 @@ FORCE_INLINE_TEMPLATE
 size_t FSE_readNCount_body(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;
+    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; 
     unsigned const maxSV1 = *maxSVPtr + 1;
-    int previous0 = 0;
-
+    int previous0 = 0; 
+ 
     if (hbSize < 8) {
         /* This function only works when hbSize >= 8 */
         char buffer[8] = {0};
@@ -96,18 +96,18 @@ size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigne
 
     /* init */
     ZSTD_memset(normalizedCounter, 0, (*maxSVPtr+1) * sizeof(normalizedCounter[0]));   /* all symbols not present in NCount have a frequency of 0 */
-    bitStream = MEM_readLE32(ip);
-    nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */
-    if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
-    bitStream >>= 4;
-    bitCount = 4;
-    *tableLogPtr = nbBits;
-    remaining = (1<<nbBits)+1;
-    threshold = 1<<nbBits;
-    nbBits++;
-
+    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++; 
+ 
     for (;;) {
-        if (previous0) {
+        if (previous0) { 
             /* Count the number of repeats. Each time the
              * 2-bit repeat code is 0b11 there is another
              * repeat.
@@ -118,14 +118,14 @@ size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigne
                 charnum += 3 * 12;
                 if (LIKELY(ip <= iend-7)) {
                     ip += 3;
-                } else {
+                } else { 
                     bitCount -= (int)(8 * (iend - 7 - ip));
                     bitCount &= 31;
                     ip = iend - 4;
                 }
                 bitStream = MEM_readLE32(ip) >> bitCount;
                 repeats = FSE_ctz(~bitStream | 0x80000000) >> 1;
-            }
+            } 
             charnum += 3 * repeats;
             bitStream >>= 2 * repeats;
             bitCount += 2 * repeats;
@@ -133,7 +133,7 @@ size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigne
             /* Add the final repeat which isn't 0b11. */
             assert((bitStream & 3) < 3);
             charnum += bitStream & 3;
-            bitCount += 2;
+            bitCount += 2; 
 
             /* This is an error, but break and return an error
              * at the end, because returning out of a loop makes
@@ -147,9 +147,9 @@ size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigne
 
             if (LIKELY(ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
                 assert((bitCount >> 3) <= 3); /* For first condition to work */
-                ip += bitCount>>3;
-                bitCount &= 7;
-            } else {
+                ip += bitCount>>3; 
+                bitCount &= 7; 
+            } else { 
                 bitCount -= (int)(8 * (iend - 4 - ip));
                 bitCount &= 31;
                 ip = iend - 4;
@@ -159,17 +159,17 @@ size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigne
         {
             int const max = (2*threshold-1) - remaining;
             int count;
-
-            if ((bitStream & (threshold-1)) < (U32)max) {
+ 
+            if ((bitStream & (threshold-1)) < (U32)max) { 
                 count = bitStream & (threshold-1);
                 bitCount += nbBits-1;
-            } else {
+            } else { 
                 count = bitStream & (2*threshold-1);
-                if (count >= threshold) count -= max;
+                if (count >= threshold) count -= max; 
                 bitCount += nbBits;
-            }
-
-            count--;   /* extra accuracy */
+            } 
+ 
+            count--;   /* extra accuracy */ 
             /* When it matters (small blocks), this is a
              * predictable branch, because we don't use -1.
              */
@@ -180,7 +180,7 @@ size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigne
                 remaining += count;
             }
             normalizedCounter[charnum++] = (short)count;
-            previous0 = !count;
+            previous0 = !count; 
 
             assert(threshold > 1);
             if (remaining < threshold) {
@@ -191,29 +191,29 @@ size_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigne
                 if (remaining <= 1) break;
                 nbBits = BIT_highbit32(remaining) + 1;
                 threshold = 1 << (nbBits - 1);
-            }
+            } 
             if (charnum >= maxSV1) break;
-
+ 
             if (LIKELY(ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
-                ip += bitCount>>3;
-                bitCount &= 7;
-            } else {
-                bitCount -= (int)(8 * (iend - 4 - ip));
+                ip += bitCount>>3; 
+                bitCount &= 7; 
+            } else { 
+                bitCount -= (int)(8 * (iend - 4 - ip)); 
                 bitCount &= 31;
-                ip = iend - 4;
-            }
+                ip = iend - 4; 
+            } 
             bitStream = MEM_readLE32(ip) >> bitCount;
     }   }
-    if (remaining != 1) return ERROR(corruption_detected);
+    if (remaining != 1) return ERROR(corruption_detected); 
     /* Only possible when there are too many zeros. */
     if (charnum > maxSV1) return ERROR(maxSymbolValue_tooSmall);
-    if (bitCount > 32) return ERROR(corruption_detected);
-    *maxSVPtr = charnum-1;
-
-    ip += (bitCount+7)>>3;
-    return ip-istart;
-}
-
+    if (bitCount > 32) return ERROR(corruption_detected); 
+    *maxSVPtr = charnum-1; 
+ 
+    ip += (bitCount+7)>>3; 
+    return ip-istart; 
+} 
+ 
 /* Avoids the FORCE_INLINE of the _body() function. */
 static size_t FSE_readNCount_body_default(
         short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
@@ -221,7 +221,7 @@ static size_t FSE_readNCount_body_default(
 {
     return FSE_readNCount_body(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);
 }
-
+ 
 #if DYNAMIC_BMI2
 BMI2_TARGET_ATTRIBUTE static size_t FSE_readNCount_body_bmi2(
         short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,
@@ -252,17 +252,17 @@ size_t FSE_readNCount(
 }
 
 
-/*! HUF_readStats() :
-    Read compact Huffman tree, saved by HUF_writeCTable().
-    `huffWeight` is destination buffer.
+/*! HUF_readStats() : 
+    Read compact Huffman tree, saved by HUF_writeCTable(). 
+    `huffWeight` is destination buffer. 
     `rankStats` is assumed to be a table of at least HUF_TABLELOG_MAX U32.
-    @return : size read from `src` , or an error Code .
-    Note : Needed by HUF_readCTable() and HUF_readDTableX?() .
-*/
-size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                     U32* nbSymbolsPtr, U32* tableLogPtr,
-                     const void* src, size_t srcSize)
-{
+    @return : size read from `src` , or an error Code . 
+    Note : Needed by HUF_readCTable() and HUF_readDTableX?() . 
+*/ 
+size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats, 
+                     U32* nbSymbolsPtr, U32* tableLogPtr, 
+                     const void* src, size_t srcSize) 
+{ 
     U32 wksp[HUF_READ_STATS_WORKSPACE_SIZE_U32];
     return HUF_readStats_wksp(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, wksp, sizeof(wksp), /* bmi2 */ 0);
 }
@@ -274,64 +274,64 @@ HUF_readStats_body(BYTE* huffWeight, size_t hwSize, U32* rankStats,
                    void* workSpace, size_t wkspSize,
                    int bmi2)
 {
-    U32 weightTotal;
-    const BYTE* ip = (const BYTE*) src;
+    U32 weightTotal; 
+    const BYTE* ip = (const BYTE*) src; 
     size_t iSize;
-    size_t oSize;
-
+    size_t oSize; 
+ 
     if (!srcSize) return ERROR(srcSize_wrong);
     iSize = ip[0];
     /* ZSTD_memset(huffWeight, 0, hwSize);   *//* is not necessary, even though some analyzer complain ... */
-
-    if (iSize >= 128) {  /* special header */
-        oSize = iSize - 127;
-        iSize = ((oSize+1)/2);
-        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
-        if (oSize >= hwSize) return ERROR(corruption_detected);
-        ip += 1;
-        {   U32 n;
-            for (n=0; n<oSize; n+=2) {
-                huffWeight[n]   = ip[n/2] >> 4;
-                huffWeight[n+1] = ip[n/2] & 15;
-    }   }   }
-    else  {   /* header compressed with FSE (normal case) */
-        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
+ 
+    if (iSize >= 128) {  /* special header */ 
+        oSize = iSize - 127; 
+        iSize = ((oSize+1)/2); 
+        if (iSize+1 > srcSize) return ERROR(srcSize_wrong); 
+        if (oSize >= hwSize) return ERROR(corruption_detected); 
+        ip += 1; 
+        {   U32 n; 
+            for (n=0; n<oSize; n+=2) { 
+                huffWeight[n]   = ip[n/2] >> 4; 
+                huffWeight[n+1] = ip[n/2] & 15; 
+    }   }   } 
+    else  {   /* header compressed with FSE (normal case) */ 
+        if (iSize+1 > srcSize) return ERROR(srcSize_wrong); 
         /* max (hwSize-1) values decoded, as last one is implied */
         oSize = FSE_decompress_wksp_bmi2(huffWeight, hwSize-1, ip+1, iSize, 6, workSpace, wkspSize, bmi2);
-        if (FSE_isError(oSize)) return oSize;
-    }
-
-    /* collect weight stats */
+        if (FSE_isError(oSize)) return oSize; 
+    } 
+ 
+    /* collect weight stats */ 
     ZSTD_memset(rankStats, 0, (HUF_TABLELOG_MAX + 1) * sizeof(U32));
-    weightTotal = 0;
-    {   U32 n; for (n=0; n<oSize; n++) {
+    weightTotal = 0; 
+    {   U32 n; for (n=0; n<oSize; n++) { 
             if (huffWeight[n] > HUF_TABLELOG_MAX) return ERROR(corruption_detected);
-            rankStats[huffWeight[n]]++;
-            weightTotal += (1 << huffWeight[n]) >> 1;
-    }   }
+            rankStats[huffWeight[n]]++; 
+            weightTotal += (1 << huffWeight[n]) >> 1; 
+    }   } 
     if (weightTotal == 0) return ERROR(corruption_detected);
-
-    /* get last non-null symbol weight (implied, total must be 2^n) */
-    {   U32 const tableLog = BIT_highbit32(weightTotal) + 1;
+ 
+    /* get last non-null symbol weight (implied, total must be 2^n) */ 
+    {   U32 const tableLog = BIT_highbit32(weightTotal) + 1; 
         if (tableLog > HUF_TABLELOG_MAX) return ERROR(corruption_detected);
-        *tableLogPtr = tableLog;
-        /* determine last weight */
-        {   U32 const total = 1 << tableLog;
-            U32 const rest = total - weightTotal;
-            U32 const verif = 1 << BIT_highbit32(rest);
-            U32 const lastWeight = BIT_highbit32(rest) + 1;
-            if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */
-            huffWeight[oSize] = (BYTE)lastWeight;
-            rankStats[lastWeight]++;
-    }   }
-
-    /* check tree construction validity */
-    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */
-
-    /* results */
-    *nbSymbolsPtr = (U32)(oSize+1);
-    return iSize+1;
-}
+        *tableLogPtr = tableLog; 
+        /* determine last weight */ 
+        {   U32 const total = 1 << tableLog; 
+            U32 const rest = total - weightTotal; 
+            U32 const verif = 1 << BIT_highbit32(rest); 
+            U32 const lastWeight = BIT_highbit32(rest) + 1; 
+            if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */ 
+            huffWeight[oSize] = (BYTE)lastWeight; 
+            rankStats[lastWeight]++; 
+    }   } 
+ 
+    /* check tree construction validity */ 
+    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */ 
+ 
+    /* results */ 
+    *nbSymbolsPtr = (U32)(oSize+1); 
+    return iSize+1; 
+} 
 
 /* Avoids the FORCE_INLINE of the _body() function. */
 static size_t HUF_readStats_body_default(BYTE* huffWeight, size_t hwSize, U32* rankStats,
diff --git a/contrib/libs/zstd/lib/common/error_private.h b/contrib/libs/zstd/lib/common/error_private.h
index 007d81066a..e2cbf5086e 100644
--- a/contrib/libs/zstd/lib/common/error_private.h
+++ b/contrib/libs/zstd/lib/common/error_private.h
@@ -7,74 +7,74 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-/* 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
-******************************************/
+ 
+/* 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 "../zstd_errors.h"  /* enum list */
 #include "compiler.h"
 #include "debug.h"
 #include "zstd_deps.h"       /* size_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
-
-
-/*-****************************************
-*  Customization (error_public.h)
-******************************************/
-typedef ZSTD_ErrorCode ERR_enum;
-#define PREFIX(name) ZSTD_error_##name
-
-
-/*-****************************************
-*  Error codes handling
-******************************************/
+ 
+ 
+/* **************************************** 
+*  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 
+******************************************/ 
 #undef ERROR   /* already defined on Visual Studio */
 #define ERROR(name) ZSTD_ERROR(name)
 #define ZSTD_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); }
-
+ 
+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); } 
+ 
 /* check and forward error code */
 #define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e
 #define CHECK_F(f)   { CHECK_V_F(_var_err__, f); }
+ 
 
-
-/*-****************************************
-*  Error Strings
-******************************************/
-
+/*-**************************************** 
+*  Error Strings 
+******************************************/ 
+ 
 const char* ERR_getErrorString(ERR_enum code);   /* error_private.c */
-
-ERR_STATIC const char* ERR_getErrorName(size_t code)
-{
-    return ERR_getErrorString(ERR_getErrorCode(code));
-}
-
+ 
+ERR_STATIC const char* ERR_getErrorName(size_t code) 
+{ 
+    return ERR_getErrorString(ERR_getErrorCode(code)); 
+} 
+ 
 /**
  * Ignore: this is an internal helper.
  *
@@ -152,8 +152,8 @@ void _force_has_format_string(const char *format, ...) {
     } \
   } while(0);
 
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* ERROR_H_MODULE */
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* ERROR_H_MODULE */ 
diff --git a/contrib/libs/zstd/lib/common/fse.h b/contrib/libs/zstd/lib/common/fse.h
index 714bfd3e7f..132d406376 100644
--- a/contrib/libs/zstd/lib/common/fse.h
+++ b/contrib/libs/zstd/lib/common/fse.h
@@ -1,4 +1,4 @@
-/* ******************************************************************
+/* ****************************************************************** 
  * FSE : Finite State Entropy codec
  * Public Prototypes declaration
  * Copyright (c) Yann Collet, Facebook, Inc.
@@ -10,22 +10,22 @@
  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
+****************************************************************** */ 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
 #ifndef FSE_H
 #define FSE_H
+ 
 
-
-/*-*****************************************
-*  Dependencies
-******************************************/
+/*-***************************************** 
+*  Dependencies 
+******************************************/ 
 #include "zstd_deps.h"    /* size_t, ptrdiff_t */
-
-
+ 
+ 
 /*-*****************************************
 *  FSE_PUBLIC_API : control library symbols visibility
 ******************************************/
@@ -53,187 +53,187 @@ extern "C" {
 FSE_PUBLIC_API unsigned FSE_versionNumber(void);   /**< library version number; to be used when checking dll version */
 
 
-/*-****************************************
-*  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())
-*/
+/*-**************************************** 
+*  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()) 
+*/ 
 FSE_PUBLIC_API 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.
-*/
+ 
+/*! 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. 
+*/ 
 FSE_PUBLIC_API size_t FSE_decompress(void* dst,  size_t dstCapacity,
                                const void* cSrc, size_t cSrcSize);
-
-
-/*-*****************************************
-*  Tool functions
-******************************************/
+ 
+ 
+/*-***************************************** 
+*  Tool functions 
+******************************************/ 
 FSE_PUBLIC_API size_t FSE_compressBound(size_t size);       /* maximum compressed size */
-
-/* Error Management */
+ 
+/* Error Management */ 
 FSE_PUBLIC_API unsigned    FSE_isError(size_t code);        /* tells if a return value is an error code */
 FSE_PUBLIC_API 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.
-*/
+ 
+ 
+/*-***************************************** 
+*  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. 
+*/ 
 FSE_PUBLIC_API 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:
+ 
+ 
+/*-***************************************** 
+*  FSE detailed API 
+******************************************/ 
+/*! 
+FSE_compress() does the following: 
 1. count symbol occurrence from source[] into table count[] (see hist.h)
-2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog)
-3. save normalized counters to memory buffer using writeNCount()
-4. build encoding table 'CTable' from normalized counters
-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_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 <= 'maxTableLog') */
+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_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 <= 'maxTableLog') */ 
 FSE_PUBLIC_API unsigned FSE_optimalTableLog(unsigned maxTableLog, 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).
+ 
+/*! FSE_normalizeCount(): 
+    normalize counts so that sum(count[]) == Power_of_2 (2^tableLog) 
+    'normalizedCounter' is a table of short, of minimum size (maxSymbolValue+1). 
     useLowProbCount is a boolean parameter which trades off compressed size for
     faster header decoding. When it is set to 1, the compressed data will be slightly
     smaller. And when it is set to 0, FSE_readNCount() and FSE_buildDTable() will be
     faster. If you are compressing a small amount of data (< 2 KB) then useLowProbCount=0
     is a good default, since header deserialization makes a big speed difference.
     Otherwise, useLowProbCount=1 is a good default, since the speed difference is small.
-    @return : tableLog,
-              or an errorCode, which can be tested using FSE_isError() */
+    @return : tableLog, 
+              or an errorCode, which can be tested using FSE_isError() */ 
 FSE_PUBLIC_API size_t FSE_normalizeCount(short* normalizedCounter, unsigned tableLog,
                     const unsigned* count, size_t srcSize, unsigned maxSymbolValue, unsigned useLowProbCount);
-
-/*! FSE_NCountWriteBound():
-    Provides the maximum possible size of an FSE normalized table, given 'maxSymbolValue' and 'tableLog'.
-    Typically useful for allocation purpose. */
+ 
+/*! FSE_NCountWriteBound(): 
+    Provides the maximum possible size of an FSE normalized table, given 'maxSymbolValue' and 'tableLog'. 
+    Typically useful for allocation purpose. */ 
 FSE_PUBLIC_API 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(). */
+ 
+/*! FSE_writeNCount(): 
+    Compactly save 'normalizedCounter' into 'buffer'. 
+    @return : size of the compressed table, 
+              or an errorCode, which can be tested using FSE_isError(). */ 
 FSE_PUBLIC_API size_t FSE_writeNCount (void* buffer, size_t bufferSize,
                                  const short* normalizedCounter,
                                  unsigned maxSymbolValue, unsigned tableLog);
-
-/*! 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* */
+ 
+/*! 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_PUBLIC_API FSE_CTable* FSE_createCTable (unsigned maxSymbolValue, unsigned tableLog);
 FSE_PUBLIC_API 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() */
+ 
+/*! FSE_buildCTable(): 
+    Builds `ct`, which must be already allocated, using FSE_createCTable(). 
+    @return : 0, or an errorCode, which can be tested using FSE_isError() */ 
 FSE_PUBLIC_API 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() */
+ 
+/*! 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() */ 
 FSE_PUBLIC_API 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 */
+ 
+/*! 
+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 */ 
 FSE_PUBLIC_API size_t FSE_readNCount (short* normalizedCounter,
                            unsigned* maxSymbolValuePtr, unsigned* tableLogPtr,
                            const void* rBuffer, size_t rBuffSize);
-
+ 
 /*! FSE_readNCount_bmi2():
  * Same as FSE_readNCount() but pass bmi2=1 when your CPU supports BMI2 and 0 otherwise.
  */
@@ -241,85 +241,85 @@ FSE_PUBLIC_API size_t FSE_readNCount_bmi2(short* normalizedCounter,
                            unsigned* maxSymbolValuePtr, unsigned* tableLogPtr,
                            const void* rBuffer, size_t rBuffSize, int bmi2);
 
-/*! 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* */
+/*! 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_PUBLIC_API FSE_DTable* FSE_createDTable(unsigned tableLog);
 FSE_PUBLIC_API 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() */
+ 
+/*! FSE_buildDTable(): 
+    Builds 'dt', which must be already allocated, using FSE_createDTable(). 
+    return : 0, or an errorCode, which can be tested using FSE_isError() */ 
 FSE_PUBLIC_API 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() */
+ 
+/*! 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() */ 
 FSE_PUBLIC_API 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)
-*/
-
+ 
+/*! 
+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) 
+*/ 
+ 
 #endif  /* FSE_H */
-
+ 
 #if defined(FSE_STATIC_LINKING_ONLY) && !defined(FSE_H_FSE_STATIC_LINKING_ONLY)
 #define FSE_H_FSE_STATIC_LINKING_ONLY
-
-/* *** Dependency *** */
-#include "bitstream.h"
-
-
-/* *****************************************
-*  Static allocation
-*******************************************/
-/* FSE buffer bounds */
-#define FSE_NCOUNTBOUND 512
+ 
+/* *** Dependency *** */ 
+#include "bitstream.h" 
+ 
+ 
+/* ***************************************** 
+*  Static allocation 
+*******************************************/ 
+/* FSE buffer bounds */ 
+#define FSE_NCOUNTBOUND 512 
 #define FSE_BLOCKBOUND(size) ((size) + ((size)>>7) + 4 /* fse states */ + sizeof(size_t) /* bitContainer */)
-#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
-
+#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 FSE_CTable/FSE_DTable 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)))
-
+ 
 /* or use the size to malloc() space directly. Pay attention to alignment restrictions though */
 #define FSE_CTABLE_SIZE(maxTableLog, maxSymbolValue)   (FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) * sizeof(FSE_CTable))
 #define FSE_DTABLE_SIZE(maxTableLog)                   (FSE_DTABLE_SIZE_U32(maxTableLog) * sizeof(FSE_DTable))
+ 
 
-
-/* *****************************************
+/* ***************************************** 
  *  FSE advanced API
  ***************************************** */
 
-unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus);
-/**< same as FSE_optimalTableLog(), which used `minus==2` */
-
+unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus); 
+/**< same as FSE_optimalTableLog(), which used `minus==2` */ 
+ 
 /* FSE_compress_wksp() :
  * Same as FSE_compress2(), but using an externally allocated scratch buffer (`workSpace`).
  * FSE_COMPRESS_WKSP_SIZE_U32() provides the minimum size required for `workSpace` as a table of FSE_CTable.
@@ -327,12 +327,12 @@ unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsi
 #define FSE_COMPRESS_WKSP_SIZE_U32(maxTableLog, maxSymbolValue)   ( FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) + ((maxTableLog > 12) ? (1 << (maxTableLog - 2)) : 1024) )
 size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);
 
-size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits);
+size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits); 
 /**< build a fake FSE_CTable, designed for a flat distribution, 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_buildCTable_rle (FSE_CTable* ct, unsigned char symbolValue); 
+/**< build a fake FSE_CTable, designed to compress always the same symbolValue */ 
+ 
 /* FSE_buildCTable_wksp() :
  * Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`).
  * `wkspSize` must be >= `FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(maxSymbolValue, tableLog)` of `unsigned`.
@@ -347,17 +347,17 @@ size_t FSE_buildCTable_wksp(FSE_CTable* ct, const short* normalizedCounter, unsi
 FSE_PUBLIC_API size_t FSE_buildDTable_wksp(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);
 /**< Same as FSE_buildDTable(), using an externally allocated `workspace` produced with `FSE_BUILD_DTABLE_WKSP_SIZE_U32(maxSymbolValue)` */
 
-size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits);
+size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits); 
 /**< build a fake FSE_DTable, designed to read a flat distribution 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 */
-
+ 
+size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue); 
+/**< build a fake FSE_DTable, designed to always generate the same symbolValue */ 
+ 
 #define FSE_DECOMPRESS_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) (FSE_DTABLE_SIZE_U32(maxTableLog) + FSE_BUILD_DTABLE_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) + (FSE_MAX_SYMBOL_VALUE + 1) / 2 + 1)
 #define FSE_DECOMPRESS_WKSP_SIZE(maxTableLog, maxSymbolValue) (FSE_DECOMPRESS_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) * sizeof(unsigned))
 size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize);
 /**< same as FSE_decompress(), using an externally allocated `workSpace` produced with `FSE_DECOMPRESS_WKSP_SIZE_U32(maxLog, maxSymbolValue)` */
-
+ 
 size_t FSE_decompress_wksp_bmi2(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize, int bmi2);
 /**< Same as FSE_decompress_wksp() but with dynamic BMI2 support. Pass 1 if your CPU supports BMI2 or 0 if it doesn't. */
 
@@ -367,192 +367,192 @@ typedef enum {
    FSE_repeat_valid  /**< Can use the previous table and it is assumed to be valid */
  } FSE_repeat;
 
-/* *****************************************
-*  FSE symbol compression API
-*******************************************/
-/*!
-   This API consists of small unitary functions, which highly benefit from being inlined.
+/* ***************************************** 
+*  FSE symbol compression API 
+*******************************************/ 
+/*! 
+   This API consists of small unitary functions, which highly benefit from being inlined. 
    Hence their body are included in next section.
-*/
-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
-*******************************************/
+    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 {
-    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;
+    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 = ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1);
-    statePtr->stateLog = tableLog;
-}
-
-
-/*! FSE_initCState2() :
-*   Same as FSE_initCState(), but the first symbol to include (which will be the last to be read)
-*   uses the smallest state value possible, saving the cost of this symbol */
-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];
-    }
-}
-
+    statePtr->stateLog = tableLog; 
+} 
+ 
+ 
+/*! FSE_initCState2() : 
+*   Same as FSE_initCState(), but the first symbol to include (which will be the last to be read) 
+*   uses the smallest state value possible, saving the cost of this symbol */ 
+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, unsigned symbol)
-{
+{ 
     FSE_symbolCompressionTransform const symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
-    const U16* const stateTable = (const U16*)(statePtr->stateTable);
+    const U16* const stateTable = (const U16*)(statePtr->stateTable); 
     U32 const 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);
-}
-
-
+    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); 
+} 
+ 
+ 
 /* FSE_getMaxNbBits() :
  * Approximate maximum cost of a symbol, in bits.
  * Fractional get rounded up (i.e : a symbol with a normalized frequency of 3 gives the same result as a frequency of 2)
@@ -588,82 +588,82 @@ MEM_STATIC U32 FSE_bitCost(const void* symbolTTPtr, U32 tableLog, U32 symbolValu
 
 /* ======    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
-
-/* **************************************************************
-*  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 */
+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 
+ 
+/* ************************************************************** 
+*  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 */ 
 #ifndef FSE_MAX_MEMORY_USAGE
 #  define FSE_MAX_MEMORY_USAGE 14
 #endif
@@ -673,45 +673,45 @@ MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
 #if (FSE_DEFAULT_MEMORY_USAGE > FSE_MAX_MEMORY_USAGE)
 #  error "FSE_DEFAULT_MEMORY_USAGE must be <= FSE_MAX_MEMORY_USAGE"
 #endif
-
-/*!FSE_MAX_SYMBOL_VALUE :
-*  Maximum symbol value authorized.
-*  Required for proper stack allocation */
+ 
+/*!FSE_MAX_SYMBOL_VALUE : 
+*  Maximum symbol value authorized. 
+*  Required for proper stack allocation */ 
 #ifndef FSE_MAX_SYMBOL_VALUE
 #  define FSE_MAX_SYMBOL_VALUE 255
 #endif
-
-/* **************************************************************
-*  template functions type & suffix
-****************************************************************/
-#define FSE_FUNCTION_TYPE BYTE
-#define FSE_FUNCTION_EXTENSION
-#define FSE_DECODE_TYPE FSE_decode_t
-
-
-#endif   /* !FSE_COMMONDEFS_ONLY */
-
-
-/* ***************************************************************
-*  Constants
-*****************************************************************/
-#define FSE_MAX_TABLELOG  (FSE_MAX_MEMORY_USAGE-2)
-#define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELOG)
-#define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESIZE-1)
-#define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMORY_USAGE-2)
-#define FSE_MIN_TABLELOG 5
-
-#define FSE_TABLELOG_ABSOLUTE_MAX 15
-#if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX
-#  error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported"
-#endif
-
+ 
+/* ************************************************************** 
+*  template functions type & suffix 
+****************************************************************/ 
+#define FSE_FUNCTION_TYPE BYTE 
+#define FSE_FUNCTION_EXTENSION 
+#define FSE_DECODE_TYPE FSE_decode_t 
+ 
+ 
+#endif   /* !FSE_COMMONDEFS_ONLY */ 
+ 
+ 
+/* *************************************************************** 
+*  Constants 
+*****************************************************************/ 
+#define FSE_MAX_TABLELOG  (FSE_MAX_MEMORY_USAGE-2) 
+#define FSE_MAX_TABLESIZE (1U<<FSE_MAX_TABLELOG) 
+#define FSE_MAXTABLESIZE_MASK (FSE_MAX_TABLESIZE-1) 
+#define FSE_DEFAULT_TABLELOG (FSE_DEFAULT_MEMORY_USAGE-2) 
+#define FSE_MIN_TABLELOG 5 
+ 
+#define FSE_TABLELOG_ABSOLUTE_MAX 15 
+#if FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX 
+#  error "FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported" 
+#endif 
+ 
 #define FSE_TABLESTEP(tableSize) (((tableSize)>>1) + ((tableSize)>>3) + 3)
-
-
-#endif /* FSE_STATIC_LINKING_ONLY */
-
-
-#if defined (__cplusplus)
-}
-#endif
+ 
+ 
+#endif /* FSE_STATIC_LINKING_ONLY */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
diff --git a/contrib/libs/zstd/lib/common/fse_decompress.c b/contrib/libs/zstd/lib/common/fse_decompress.c
index a5a358015f..d8c9ae1753 100644
--- a/contrib/libs/zstd/lib/common/fse_decompress.c
+++ b/contrib/libs/zstd/lib/common/fse_decompress.c
@@ -1,4 +1,4 @@
-/* ******************************************************************
+/* ****************************************************************** 
  * FSE : Finite State Entropy decoder
  * Copyright (c) Yann Collet, Facebook, Inc.
  *
@@ -10,98 +10,98 @@
  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-
-/* **************************************************************
-*  Includes
-****************************************************************/
+****************************************************************** */ 
+ 
+ 
+/* ************************************************************** 
+*  Includes 
+****************************************************************/ 
 #include "debug.h"      /* assert */
-#include "bitstream.h"
+#include "bitstream.h" 
 #include "compiler.h"
-#define FSE_STATIC_LINKING_ONLY
-#include "fse.h"
+#define FSE_STATIC_LINKING_ONLY 
+#include "fse.h" 
 #include "error_private.h"
 #define ZSTD_DEPS_NEED_MALLOC
 #include "zstd_deps.h"
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#define FSE_isError ERR_isError
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#define FSE_isError ERR_isError 
 #define FSE_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)   /* use only *after* variable declarations */
-
-
-/* **************************************************************
-*  Templates
-****************************************************************/
-/*
-  designed to be included
-  for type-specific functions (template emulation in C)
-  Objective is to write these functions only once, for improved maintenance
-*/
-
-/* safety checks */
-#ifndef FSE_FUNCTION_EXTENSION
-#  error "FSE_FUNCTION_EXTENSION must be defined"
-#endif
-#ifndef FSE_FUNCTION_TYPE
-#  error "FSE_FUNCTION_TYPE must be defined"
-#endif
-
-/* Function names */
-#define FSE_CAT(X,Y) X##Y
-#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)
-#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)
-
-
-/* Function templates */
-FSE_DTable* FSE_createDTable (unsigned tableLog)
-{
-    if (tableLog > FSE_TABLELOG_ABSOLUTE_MAX) tableLog = FSE_TABLELOG_ABSOLUTE_MAX;
+ 
+ 
+/* ************************************************************** 
+*  Templates 
+****************************************************************/ 
+/* 
+  designed to be included 
+  for type-specific functions (template emulation in C) 
+  Objective is to write these functions only once, for improved maintenance 
+*/ 
+ 
+/* safety checks */ 
+#ifndef FSE_FUNCTION_EXTENSION 
+#  error "FSE_FUNCTION_EXTENSION must be defined" 
+#endif 
+#ifndef FSE_FUNCTION_TYPE 
+#  error "FSE_FUNCTION_TYPE must be defined" 
+#endif 
+ 
+/* Function names */ 
+#define FSE_CAT(X,Y) X##Y 
+#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y) 
+#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y) 
+ 
+ 
+/* Function templates */ 
+FSE_DTable* FSE_createDTable (unsigned tableLog) 
+{ 
+    if (tableLog > FSE_TABLELOG_ABSOLUTE_MAX) tableLog = FSE_TABLELOG_ABSOLUTE_MAX; 
     return (FSE_DTable*)ZSTD_malloc( FSE_DTABLE_SIZE_U32(tableLog) * sizeof (U32) );
-}
-
-void FSE_freeDTable (FSE_DTable* dt)
-{
+} 
+ 
+void FSE_freeDTable (FSE_DTable* dt) 
+{ 
     ZSTD_free(dt);
-}
-
+} 
+ 
 static size_t FSE_buildDTable_internal(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize)
-{
-    void* const tdPtr = dt+1;   /* because *dt is unsigned, 32-bits aligned on 32-bits */
-    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*) (tdPtr);
+{ 
+    void* const tdPtr = dt+1;   /* because *dt is unsigned, 32-bits aligned on 32-bits */ 
+    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*) (tdPtr); 
     U16* symbolNext = (U16*)workSpace;
     BYTE* spread = (BYTE*)(symbolNext + maxSymbolValue + 1);
-
-    U32 const maxSV1 = maxSymbolValue + 1;
-    U32 const tableSize = 1 << tableLog;
-    U32 highThreshold = tableSize-1;
-
-    /* Sanity Checks */
+ 
+    U32 const maxSV1 = maxSymbolValue + 1; 
+    U32 const tableSize = 1 << tableLog; 
+    U32 highThreshold = tableSize-1; 
+ 
+    /* Sanity Checks */ 
     if (FSE_BUILD_DTABLE_WKSP_SIZE(tableLog, maxSymbolValue) > wkspSize) return ERROR(maxSymbolValue_tooLarge);
-    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
-    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
-
-    /* Init, lay down lowprob symbols */
-    {   FSE_DTableHeader DTableH;
-        DTableH.tableLog = (U16)tableLog;
-        DTableH.fastMode = 1;
-        {   S16 const largeLimit= (S16)(1 << (tableLog-1));
-            U32 s;
-            for (s=0; s<maxSV1; s++) {
-                if (normalizedCounter[s]==-1) {
-                    tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;
-                    symbolNext[s] = 1;
-                } else {
-                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
-                    symbolNext[s] = normalizedCounter[s];
-        }   }   }
+    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge); 
+    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge); 
+ 
+    /* Init, lay down lowprob symbols */ 
+    {   FSE_DTableHeader DTableH; 
+        DTableH.tableLog = (U16)tableLog; 
+        DTableH.fastMode = 1; 
+        {   S16 const largeLimit= (S16)(1 << (tableLog-1)); 
+            U32 s; 
+            for (s=0; s<maxSV1; s++) { 
+                if (normalizedCounter[s]==-1) { 
+                    tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s; 
+                    symbolNext[s] = 1; 
+                } else { 
+                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0; 
+                    symbolNext[s] = normalizedCounter[s]; 
+        }   }   } 
         ZSTD_memcpy(dt, &DTableH, sizeof(DTableH));
-    }
-
-    /* Spread symbols */
+    } 
+ 
+    /* Spread symbols */ 
     if (highThreshold == tableSize - 1) {
         size_t const tableMask = tableSize-1;
         size_t const step = FSE_TABLESTEP(tableSize);
@@ -149,164 +149,164 @@ static size_t FSE_buildDTable_internal(FSE_DTable* dt, const short* normalizedCo
         }
     } else {
         U32 const tableMask = tableSize-1;
-        U32 const step = FSE_TABLESTEP(tableSize);
-        U32 s, position = 0;
-        for (s=0; s<maxSV1; s++) {
-            int i;
-            for (i=0; i<normalizedCounter[s]; i++) {
-                tableDecode[position].symbol = (FSE_FUNCTION_TYPE)s;
-                position = (position + step) & tableMask;
-                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
-        }   }
-        if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
-    }
-
-    /* Build Decoding table */
-    {   U32 u;
-        for (u=0; u<tableSize; u++) {
-            FSE_FUNCTION_TYPE const symbol = (FSE_FUNCTION_TYPE)(tableDecode[u].symbol);
+        U32 const step = FSE_TABLESTEP(tableSize); 
+        U32 s, position = 0; 
+        for (s=0; s<maxSV1; s++) { 
+            int i; 
+            for (i=0; i<normalizedCounter[s]; i++) { 
+                tableDecode[position].symbol = (FSE_FUNCTION_TYPE)s; 
+                position = (position + step) & tableMask; 
+                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */ 
+        }   } 
+        if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */ 
+    } 
+ 
+    /* Build Decoding table */ 
+    {   U32 u; 
+        for (u=0; u<tableSize; u++) { 
+            FSE_FUNCTION_TYPE const symbol = (FSE_FUNCTION_TYPE)(tableDecode[u].symbol); 
             U32 const nextState = symbolNext[symbol]++;
             tableDecode[u].nbBits = (BYTE) (tableLog - BIT_highbit32(nextState) );
-            tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
-    }   }
-
-    return 0;
-}
-
+            tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize); 
+    }   } 
+ 
+    return 0; 
+} 
+ 
 size_t FSE_buildDTable_wksp(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize)
 {
     return FSE_buildDTable_internal(dt, normalizedCounter, maxSymbolValue, tableLog, workSpace, wkspSize);
 }
-
-
-#ifndef FSE_COMMONDEFS_ONLY
-
-/*-*******************************************************
-*  Decompression (Byte symbols)
-*********************************************************/
-size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
-{
-    void* ptr = dt;
-    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
-    void* dPtr = dt + 1;
-    FSE_decode_t* const cell = (FSE_decode_t*)dPtr;
-
-    DTableH->tableLog = 0;
-    DTableH->fastMode = 0;
-
-    cell->newState = 0;
-    cell->symbol = symbolValue;
-    cell->nbBits = 0;
-
-    return 0;
-}
-
-
-size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
-{
-    void* ptr = dt;
-    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
-    void* dPtr = dt + 1;
-    FSE_decode_t* const dinfo = (FSE_decode_t*)dPtr;
-    const unsigned tableSize = 1 << nbBits;
-    const unsigned tableMask = tableSize - 1;
-    const unsigned maxSV1 = tableMask+1;
-    unsigned s;
-
-    /* Sanity checks */
-    if (nbBits < 1) return ERROR(GENERIC);         /* min size */
-
-    /* Build Decoding Table */
-    DTableH->tableLog = (U16)nbBits;
-    DTableH->fastMode = 1;
-    for (s=0; s<maxSV1; s++) {
-        dinfo[s].newState = 0;
-        dinfo[s].symbol = (BYTE)s;
-        dinfo[s].nbBits = (BYTE)nbBits;
-    }
-
-    return 0;
-}
-
+ 
+
+#ifndef FSE_COMMONDEFS_ONLY 
+ 
+/*-******************************************************* 
+*  Decompression (Byte symbols) 
+*********************************************************/ 
+size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue) 
+{ 
+    void* ptr = dt; 
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; 
+    void* dPtr = dt + 1; 
+    FSE_decode_t* const cell = (FSE_decode_t*)dPtr; 
+ 
+    DTableH->tableLog = 0; 
+    DTableH->fastMode = 0; 
+ 
+    cell->newState = 0; 
+    cell->symbol = symbolValue; 
+    cell->nbBits = 0; 
+ 
+    return 0; 
+} 
+ 
+ 
+size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits) 
+{ 
+    void* ptr = dt; 
+    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr; 
+    void* dPtr = dt + 1; 
+    FSE_decode_t* const dinfo = (FSE_decode_t*)dPtr; 
+    const unsigned tableSize = 1 << nbBits; 
+    const unsigned tableMask = tableSize - 1; 
+    const unsigned maxSV1 = tableMask+1; 
+    unsigned s; 
+ 
+    /* Sanity checks */ 
+    if (nbBits < 1) return ERROR(GENERIC);         /* min size */ 
+ 
+    /* Build Decoding Table */ 
+    DTableH->tableLog = (U16)nbBits; 
+    DTableH->fastMode = 1; 
+    for (s=0; s<maxSV1; s++) { 
+        dinfo[s].newState = 0; 
+        dinfo[s].symbol = (BYTE)s; 
+        dinfo[s].nbBits = (BYTE)nbBits; 
+    } 
+ 
+    return 0; 
+} 
+ 
 FORCE_INLINE_TEMPLATE size_t FSE_decompress_usingDTable_generic(
-          void* dst, size_t maxDstSize,
-    const void* cSrc, size_t cSrcSize,
-    const FSE_DTable* dt, const unsigned fast)
-{
-    BYTE* const ostart = (BYTE*) dst;
-    BYTE* op = ostart;
-    BYTE* const omax = op + maxDstSize;
-    BYTE* const olimit = omax-3;
-
-    BIT_DStream_t bitD;
-    FSE_DState_t state1;
-    FSE_DState_t state2;
-
-    /* Init */
+          void* dst, size_t maxDstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const FSE_DTable* dt, const unsigned fast) 
+{ 
+    BYTE* const ostart = (BYTE*) dst; 
+    BYTE* op = ostart; 
+    BYTE* const omax = op + maxDstSize; 
+    BYTE* const olimit = omax-3; 
+ 
+    BIT_DStream_t bitD; 
+    FSE_DState_t state1; 
+    FSE_DState_t state2; 
+ 
+    /* Init */ 
     CHECK_F(BIT_initDStream(&bitD, cSrc, cSrcSize));
-
-    FSE_initDState(&state1, &bitD, dt);
-    FSE_initDState(&state2, &bitD, dt);
-
-#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)
-
-    /* 4 symbols per loop */
+ 
+    FSE_initDState(&state1, &bitD, dt); 
+    FSE_initDState(&state2, &bitD, dt); 
+ 
+#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD) 
+ 
+    /* 4 symbols per loop */ 
     for ( ; (BIT_reloadDStream(&bitD)==BIT_DStream_unfinished) & (op<olimit) ; op+=4) {
-        op[0] = FSE_GETSYMBOL(&state1);
-
-        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            BIT_reloadDStream(&bitD);
-
-        op[1] = FSE_GETSYMBOL(&state2);
-
-        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }
-
-        op[2] = FSE_GETSYMBOL(&state1);
-
-        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            BIT_reloadDStream(&bitD);
-
-        op[3] = FSE_GETSYMBOL(&state2);
-    }
-
-    /* tail */
-    /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */
-    while (1) {
-        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
-        *op++ = FSE_GETSYMBOL(&state1);
-        if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) {
-            *op++ = FSE_GETSYMBOL(&state2);
-            break;
-        }
-
-        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
-        *op++ = FSE_GETSYMBOL(&state2);
-        if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) {
-            *op++ = FSE_GETSYMBOL(&state1);
-            break;
-    }   }
-
-    return op-ostart;
-}
-
-
-size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
-                            const void* cSrc, size_t cSrcSize,
-                            const FSE_DTable* dt)
-{
-    const void* ptr = dt;
-    const FSE_DTableHeader* DTableH = (const FSE_DTableHeader*)ptr;
-    const U32 fastMode = DTableH->fastMode;
-
-    /* select fast mode (static) */
-    if (fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
-    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
-}
-
-
+        op[0] = FSE_GETSYMBOL(&state1); 
+ 
+        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            BIT_reloadDStream(&bitD); 
+ 
+        op[1] = FSE_GETSYMBOL(&state2); 
+ 
+        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } } 
+ 
+        op[2] = FSE_GETSYMBOL(&state1); 
+ 
+        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            BIT_reloadDStream(&bitD); 
+ 
+        op[3] = FSE_GETSYMBOL(&state2); 
+    } 
+ 
+    /* tail */ 
+    /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */ 
+    while (1) { 
+        if (op>(omax-2)) return ERROR(dstSize_tooSmall); 
+        *op++ = FSE_GETSYMBOL(&state1); 
+        if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) { 
+            *op++ = FSE_GETSYMBOL(&state2); 
+            break; 
+        } 
+ 
+        if (op>(omax-2)) return ERROR(dstSize_tooSmall); 
+        *op++ = FSE_GETSYMBOL(&state2); 
+        if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) { 
+            *op++ = FSE_GETSYMBOL(&state1); 
+            break; 
+    }   } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+size_t FSE_decompress_usingDTable(void* dst, size_t originalSize, 
+                            const void* cSrc, size_t cSrcSize, 
+                            const FSE_DTable* dt) 
+{ 
+    const void* ptr = dt; 
+    const FSE_DTableHeader* DTableH = (const FSE_DTableHeader*)ptr; 
+    const U32 fastMode = DTableH->fastMode; 
+ 
+    /* select fast mode (static) */ 
+    if (fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1); 
+    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0); 
+} 
+ 
+ 
 size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize)
-{
+{ 
     return FSE_decompress_wksp_bmi2(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize, /* bmi2 */ 0);
 }
 
@@ -322,16 +322,16 @@ FORCE_INLINE_TEMPLATE size_t FSE_decompress_wksp_body(
         unsigned maxLog, void* workSpace, size_t wkspSize,
         int bmi2)
 {
-    const BYTE* const istart = (const BYTE*)cSrc;
-    const BYTE* ip = istart;
-    unsigned tableLog;
-    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
+    const BYTE* const istart = (const BYTE*)cSrc; 
+    const BYTE* ip = istart; 
+    unsigned tableLog; 
+    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE; 
     FSE_DecompressWksp* const wksp = (FSE_DecompressWksp*)workSpace;
-
+ 
     DEBUG_STATIC_ASSERT((FSE_MAX_SYMBOL_VALUE + 1) % 2 == 0);
     if (wkspSize < sizeof(*wksp)) return ERROR(GENERIC);
 
-    /* normal FSE decoding mode */
+    /* normal FSE decoding mode */ 
     {
         size_t const NCountLength = FSE_readNCount_bmi2(wksp->ncount, &maxSymbolValue, &tableLog, istart, cSrcSize, bmi2);
         if (FSE_isError(NCountLength)) return NCountLength;
@@ -340,11 +340,11 @@ FORCE_INLINE_TEMPLATE size_t FSE_decompress_wksp_body(
         ip += NCountLength;
         cSrcSize -= NCountLength;
     }
-
+ 
     if (FSE_DECOMPRESS_WKSP_SIZE(tableLog, maxSymbolValue) > wkspSize) return ERROR(tableLog_tooLarge);
     workSpace = wksp->dtable + FSE_DTABLE_SIZE_U32(tableLog);
     wkspSize -= sizeof(*wksp) + FSE_DTABLE_SIZE(tableLog);
-
+ 
     CHECK_F( FSE_buildDTable_internal(wksp->dtable, wksp->ncount, maxSymbolValue, tableLog, workSpace, wkspSize) );
 
     {
@@ -356,14 +356,14 @@ FORCE_INLINE_TEMPLATE size_t FSE_decompress_wksp_body(
         if (fastMode) return FSE_decompress_usingDTable_generic(dst, dstCapacity, ip, cSrcSize, wksp->dtable, 1);
         return FSE_decompress_usingDTable_generic(dst, dstCapacity, ip, cSrcSize, wksp->dtable, 0);
     }
-}
-
+} 
+ 
 /* Avoids the FORCE_INLINE of the _body() function. */
 static size_t FSE_decompress_wksp_body_default(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize)
 {
     return FSE_decompress_wksp_body(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize, 0);
 }
-
+ 
 #if DYNAMIC_BMI2
 BMI2_TARGET_ATTRIBUTE static size_t FSE_decompress_wksp_body_bmi2(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize)
 {
@@ -384,7 +384,7 @@ size_t FSE_decompress_wksp_bmi2(void* dst, size_t dstCapacity, const void* cSrc,
 
 
 typedef FSE_DTable DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];
-
+ 
 #ifndef ZSTD_NO_UNUSED_FUNCTIONS
 size_t FSE_buildDTable(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) {
     U32 wksp[FSE_BUILD_DTABLE_WKSP_SIZE_U32(FSE_TABLELOG_ABSOLUTE_MAX, FSE_MAX_SYMBOL_VALUE)];
@@ -400,4 +400,4 @@ size_t FSE_decompress(void* dst, size_t dstCapacity, const void* cSrc, size_t cS
 #endif
 
 
-#endif   /* FSE_COMMONDEFS_ONLY */
+#endif   /* FSE_COMMONDEFS_ONLY */ 
diff --git a/contrib/libs/zstd/lib/common/huf.h b/contrib/libs/zstd/lib/common/huf.h
index 85518481ec..6b9f79bee0 100644
--- a/contrib/libs/zstd/lib/common/huf.h
+++ b/contrib/libs/zstd/lib/common/huf.h
@@ -1,4 +1,4 @@
-/* ******************************************************************
+/* ****************************************************************** 
  * huff0 huffman codec,
  * part of Finite State Entropy library
  * Copyright (c) Yann Collet, Facebook, Inc.
@@ -10,19 +10,19 @@
  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
+****************************************************************** */ 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
 #ifndef HUF_H_298734234
 #define HUF_H_298734234
-
-/* *** Dependencies *** */
+ 
+/* *** Dependencies *** */ 
 #include "zstd_deps.h"    /* size_t */
-
-
+ 
+ 
 /* *** library symbols visibility *** */
 /* Note : when linking with -fvisibility=hidden on gcc, or by default on Visual,
  *        HUF symbols remain "private" (internal symbols for library only).
@@ -36,12 +36,12 @@ extern "C" {
 #else
 #  define HUF_PUBLIC_API
 #endif
-
-
+ 
+ 
 /* ========================== */
 /* ***  simple functions  *** */
 /* ========================== */
-
+ 
 /** HUF_compress() :
  *  Compress content from buffer 'src', of size 'srcSize', into buffer 'dst'.
  * 'dst' buffer must be already allocated.
@@ -71,22 +71,22 @@ HUF_PUBLIC_API size_t HUF_decompress(void* dst,  size_t originalSize,
 /* ***   Tool functions *** */
 #define HUF_BLOCKSIZE_MAX (128 * 1024)                  /**< maximum input size for a single block compressed with HUF_compress */
 HUF_PUBLIC_API size_t HUF_compressBound(size_t size);   /**< maximum compressed size (worst case) */
-
-/* Error Management */
+ 
+/* Error Management */ 
 HUF_PUBLIC_API unsigned    HUF_isError(size_t code);       /**< tells if a return value is an error code */
 HUF_PUBLIC_API const char* HUF_getErrorName(size_t code);  /**< provides error code string (useful for debugging) */
-
-
+ 
+ 
 /* ***   Advanced function   *** */
-
-/** HUF_compress2() :
+ 
+/** HUF_compress2() : 
  *  Same as HUF_compress(), but offers control over `maxSymbolValue` and `tableLog`.
  * `maxSymbolValue` must be <= HUF_SYMBOLVALUE_MAX .
  * `tableLog` must be `<= HUF_TABLELOG_MAX` . */
 HUF_PUBLIC_API size_t HUF_compress2 (void* dst, size_t dstCapacity,
                                const void* src, size_t srcSize,
                                unsigned maxSymbolValue, unsigned tableLog);
-
+ 
 /** HUF_compress4X_wksp() :
  *  Same as HUF_compress2(), but uses externally allocated `workSpace`.
  * `workspace` must be at least as large as HUF_WORKSPACE_SIZE */
@@ -96,7 +96,7 @@ HUF_PUBLIC_API size_t HUF_compress4X_wksp (void* dst, size_t dstCapacity,
                                      const void* src, size_t srcSize,
                                      unsigned maxSymbolValue, unsigned tableLog,
                                      void* workSpace, size_t wkspSize);
-
+ 
 #endif   /* HUF_H_298734234 */
 
 /* ******************************************************************
@@ -109,58 +109,58 @@ HUF_PUBLIC_API size_t HUF_compress4X_wksp (void* dst, size_t dstCapacity,
 #if defined(HUF_STATIC_LINKING_ONLY) && !defined(HUF_H_HUF_STATIC_LINKING_ONLY)
 #define HUF_H_HUF_STATIC_LINKING_ONLY
 
-/* *** Dependencies *** */
-#include "mem.h"   /* U32 */
+/* *** Dependencies *** */ 
+#include "mem.h"   /* U32 */ 
 #define FSE_STATIC_LINKING_ONLY
 #include "fse.h"
-
-
-/* *** Constants *** */
+ 
+ 
+/* *** Constants *** */ 
 #define HUF_TABLELOG_MAX      12      /* max runtime value of tableLog (due to static allocation); can be modified up to HUF_TABLELOG_ABSOLUTEMAX */
 #define HUF_TABLELOG_DEFAULT  11      /* default tableLog value when none specified */
 #define HUF_SYMBOLVALUE_MAX  255
 
 #define HUF_TABLELOG_ABSOLUTEMAX  12  /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */
-#if (HUF_TABLELOG_MAX > HUF_TABLELOG_ABSOLUTEMAX)
-#  error "HUF_TABLELOG_MAX is too large !"
-#endif
-
-
-/* ****************************************
-*  Static allocation
-******************************************/
-/* HUF buffer bounds */
-#define HUF_CTABLEBOUND 129
+#if (HUF_TABLELOG_MAX > HUF_TABLELOG_ABSOLUTEMAX) 
+#  error "HUF_TABLELOG_MAX is too large !" 
+#endif 
+ 
+ 
+/* **************************************** 
+*  Static allocation 
+******************************************/ 
+/* HUF buffer bounds */ 
+#define HUF_CTABLEBOUND 129 
 #define HUF_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true when incompressible is pre-filtered with fast heuristic */
-#define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
-
-/* static allocation of HUF's Compression Table */
+#define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size))   /* Macro version, useful for static allocation */ 
+ 
+/* static allocation of HUF's Compression Table */ 
 /* this is a private definition, just exposed for allocation and strict aliasing purpose. never EVER access its members directly */
 typedef size_t HUF_CElt;   /* consider it an incomplete type */
 #define HUF_CTABLE_SIZE_ST(maxSymbolValue)   ((maxSymbolValue)+2)   /* Use tables of size_t, for proper alignment */
 #define HUF_CTABLE_SIZE(maxSymbolValue)       (HUF_CTABLE_SIZE_ST(maxSymbolValue) * sizeof(size_t))
-#define HUF_CREATE_STATIC_CTABLE(name, maxSymbolValue) \
+#define HUF_CREATE_STATIC_CTABLE(name, maxSymbolValue) \ 
     HUF_CElt name[HUF_CTABLE_SIZE_ST(maxSymbolValue)] /* no final ; */
-
-/* static allocation of HUF's DTable */
-typedef U32 HUF_DTable;
-#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<(maxTableLog)))
+ 
+/* static allocation of HUF's DTable */ 
+typedef U32 HUF_DTable; 
+#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<(maxTableLog))) 
 #define HUF_CREATE_STATIC_DTABLEX1(DTable, maxTableLog) \
         HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1) * 0x01000001) }
-#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
+#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \ 
         HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) }
-
-
-/* ****************************************
-*  Advanced decompression functions
-******************************************/
+ 
+ 
+/* **************************************** 
+*  Advanced decompression functions 
+******************************************/ 
 size_t HUF_decompress4X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */
 #ifndef HUF_FORCE_DECOMPRESS_X1
 size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */
 #endif
-
-size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< decodes RLE and uncompressed */
-size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */
+ 
+size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< decodes RLE and uncompressed */ 
+size_t HUF_decompress4X_hufOnly(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */ 
 size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /**< considers RLE and uncompressed as errors */
 size_t HUF_decompress4X1_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */
 size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize);   /**< single-symbol decoder */
@@ -168,12 +168,12 @@ size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
 size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */
 size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize);   /**< double-symbols decoder */
 #endif
-
-
-/* ****************************************
+ 
+ 
+/* **************************************** 
  *  HUF detailed API
  * ****************************************/
-
+ 
 /*! HUF_compress() does the following:
  *  1. count symbol occurrence from source[] into table count[] using FSE_count() (exposed within "fse.h")
  *  2. (optional) refine tableLog using HUF_optimalTableLog()
@@ -185,15 +185,15 @@ size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
  *  For example, it's possible to compress several blocks using the same 'CTable',
  *  or to save and regenerate 'CTable' using external methods.
  */
-unsigned HUF_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue);
+unsigned HUF_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue); 
 size_t HUF_buildCTable (HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue, unsigned maxNbBits);   /* @return : maxNbBits; CTable and count can overlap. In which case, CTable will overwrite count content */
-size_t HUF_writeCTable (void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog);
+size_t HUF_writeCTable (void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog); 
 size_t HUF_writeCTable_wksp(void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog, void* workspace, size_t workspaceSize);
-size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
+size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable); 
 size_t HUF_compress4X_usingCTable_bmi2(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int bmi2);
 size_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue);
 int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue);
-
+ 
 typedef enum {
    HUF_repeat_none,  /**< Cannot use the previous table */
    HUF_repeat_check, /**< Can use the previous table but it must be checked. Note : The previous table must have been constructed by HUF_compress{1, 4}X_repeat */
@@ -210,7 +210,7 @@ size_t HUF_compress4X_repeat(void* dst, size_t dstSize,
                        unsigned maxSymbolValue, unsigned tableLog,
                        void* workSpace, size_t wkspSize,    /**< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */
                        HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2, unsigned suspectUncompressible);
-
+ 
 /** HUF_buildCTable_wksp() :
  *  Same as HUF_buildCTable(), but using externally allocated scratch buffer.
  * `workSpace` must be aligned on 4-bytes boundaries, and its size must be >= HUF_CTABLE_WORKSPACE_SIZE.
@@ -221,15 +221,15 @@ size_t HUF_buildCTable_wksp (HUF_CElt* tree,
                        const unsigned* count, U32 maxSymbolValue, U32 maxNbBits,
                              void* workSpace, size_t wkspSize);
 
-/*! HUF_readStats() :
+/*! HUF_readStats() : 
  *  Read compact Huffman tree, saved by HUF_writeCTable().
  * `huffWeight` is destination buffer.
  * @return : size read from `src` , or an error Code .
  *  Note : Needed by HUF_readCTable() and HUF_readDTableXn() . */
 size_t HUF_readStats(BYTE* huffWeight, size_t hwSize,
                      U32* rankStats, U32* nbSymbolsPtr, U32* tableLogPtr,
-                     const void* src, size_t srcSize);
-
+                     const void* src, size_t srcSize); 
+ 
 /*! HUF_readStats_wksp() :
  * Same as HUF_readStats() but takes an external workspace which must be
  * 4-byte aligned and its size must be >= HUF_READ_STATS_WORKSPACE_SIZE.
@@ -243,29 +243,29 @@ size_t HUF_readStats_wksp(BYTE* huffWeight, size_t hwSize,
                           void* workspace, size_t wkspSize,
                           int bmi2);
 
-/** HUF_readCTable() :
+/** HUF_readCTable() : 
  *  Loading a CTable saved with HUF_writeCTable() */
 size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize, unsigned *hasZeroWeights);
-
+ 
 /** HUF_getNbBitsFromCTable() :
  *  Read nbBits from CTable symbolTable, for symbol `symbolValue` presumed <= HUF_SYMBOLVALUE_MAX
  *  Note 1 : is not inlined, as HUF_CElt definition is private */
 U32 HUF_getNbBitsFromCTable(const HUF_CElt* symbolTable, U32 symbolValue);
-
-/*
+ 
+/* 
  * HUF_decompress() does the following:
  * 1. select the decompression algorithm (X1, X2) based on pre-computed heuristics
  * 2. build Huffman table from save, using HUF_readDTableX?()
  * 3. decode 1 or 4 segments in parallel using HUF_decompress?X?_usingDTable()
  */
-
-/** HUF_selectDecoder() :
+ 
+/** HUF_selectDecoder() : 
  *  Tells which decoder is likely to decode faster,
  *  based on a set of pre-computed metrics.
  * @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 .
  *  Assumption : 0 < dstSize <= 128 KB */
-U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize);
-
+U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize); 
+ 
 /**
  *  The minimum workspace size for the `workSpace` used in
  *  HUF_readDTableX1_wksp() and HUF_readDTableX2_wksp().
@@ -284,26 +284,26 @@ size_t HUF_readDTableX1 (HUF_DTable* DTable, const void* src, size_t srcSize);
 size_t HUF_readDTableX1_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize);
 #endif
 #ifndef HUF_FORCE_DECOMPRESS_X1
-size_t HUF_readDTableX2 (HUF_DTable* DTable, const void* src, size_t srcSize);
+size_t HUF_readDTableX2 (HUF_DTable* DTable, const void* src, size_t srcSize); 
 size_t HUF_readDTableX2_wksp (HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize);
 #endif
-
-size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
+ 
+size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); 
 #ifndef HUF_FORCE_DECOMPRESS_X2
 size_t HUF_decompress4X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
 #endif
 #ifndef HUF_FORCE_DECOMPRESS_X1
-size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
+size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); 
 #endif
-
-
+ 
+ 
 /* ====================== */
-/* single stream variants */
+/* single stream variants */ 
 /* ====================== */
-
-size_t HUF_compress1X (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);
+ 
+size_t HUF_compress1X (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog); 
 size_t HUF_compress1X_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);  /**< `workSpace` must be a table of at least HUF_WORKSPACE_SIZE_U64 U64 */
-size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable);
+size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable); 
 size_t HUF_compress1X_usingCTable_bmi2(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int bmi2);
 /** HUF_compress1X_repeat() :
  *  Same as HUF_compress1X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none.
@@ -316,12 +316,12 @@ size_t HUF_compress1X_repeat(void* dst, size_t dstSize,
                        unsigned maxSymbolValue, unsigned tableLog,
                        void* workSpace, size_t wkspSize,   /**< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */
                        HUF_CElt* hufTable, HUF_repeat* repeat, int preferRepeat, int bmi2, unsigned suspectUncompressible);
-
+ 
 size_t HUF_decompress1X1 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
 #ifndef HUF_FORCE_DECOMPRESS_X1
 size_t HUF_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */
 #endif
-
+ 
 size_t HUF_decompress1X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
 size_t HUF_decompress1X_DCtx_wksp (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize);
 #ifndef HUF_FORCE_DECOMPRESS_X2
@@ -338,9 +338,9 @@ size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cS
 size_t HUF_decompress1X1_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
 #endif
 #ifndef HUF_FORCE_DECOMPRESS_X1
-size_t HUF_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
+size_t HUF_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); 
 #endif
-
+ 
 /* BMI2 variants.
  * If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0.
  */
@@ -357,8 +357,8 @@ size_t HUF_readDTableX1_wksp_bmi2(HUF_DTable* DTable, const void* src, size_t sr
 size_t HUF_readDTableX2_wksp_bmi2(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize, int bmi2);
 #endif
 
-#endif /* HUF_STATIC_LINKING_ONLY */
-
-#if defined (__cplusplus)
-}
-#endif
+#endif /* HUF_STATIC_LINKING_ONLY */ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
diff --git a/contrib/libs/zstd/lib/common/mem.h b/contrib/libs/zstd/lib/common/mem.h
index 85581c3847..c1f1599889 100644
--- a/contrib/libs/zstd/lib/common/mem.h
+++ b/contrib/libs/zstd/lib/common/mem.h
@@ -7,44 +7,44 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-#ifndef MEM_H_MODULE
-#define MEM_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/*-****************************************
-*  Dependencies
-******************************************/
+ 
+#ifndef MEM_H_MODULE 
+#define MEM_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/*-**************************************** 
+*  Dependencies 
+******************************************/ 
 #include <stddef.h>  /* size_t, ptrdiff_t */
 #include "compiler.h"  /* __has_builtin */
 #include "debug.h"  /* DEBUG_STATIC_ASSERT */
 #include "zstd_deps.h"  /* ZSTD_memcpy */
-
-
-/*-****************************************
-*  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 __inline __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 (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+ 
+ 
+/*-**************************************** 
+*  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 __inline __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 (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) ) 
 #  if defined(_AIX)
 #    include <inttypes.h>
 #  else
@@ -59,7 +59,7 @@ extern "C" {
   typedef   int32_t S32;
   typedef  uint64_t U64;
   typedef   int64_t S64;
-#else
+#else 
 # include <limits.h>
 #if CHAR_BIT != 8
 #  error "this implementation requires char to be exactly 8-bit type"
@@ -70,23 +70,23 @@ extern "C" {
 #if USHRT_MAX != 65535
 #  error "this implementation requires short to be exactly 16-bit type"
 #endif
-  typedef unsigned short      U16;
-  typedef   signed short      S16;
+  typedef unsigned short      U16; 
+  typedef   signed short      S16; 
 #if UINT_MAX != 4294967295
 #  error "this implementation requires int to be exactly 32-bit type"
 #endif
-  typedef unsigned int        U32;
-  typedef   signed int        S32;
+  typedef unsigned int        U32; 
+  typedef   signed int        S32; 
 /* note : there are no limits defined for long long type in C90.
  * limits exist in C99, however, in such case, <stdint.h> is preferred */
-  typedef unsigned long long  U64;
-  typedef   signed long long  S64;
-#endif
-
-
-/*-**************************************************************
+  typedef unsigned long long  U64; 
+  typedef   signed long long  S64; 
+#endif 
+ 
+ 
+/*-************************************************************** 
 *  Memory I/O API
-*****************************************************************/
+*****************************************************************/ 
 /*=== Static platform detection ===*/
 MEM_STATIC unsigned MEM_32bits(void);
 MEM_STATIC unsigned MEM_64bits(void);
@@ -133,30 +133,30 @@ MEM_STATIC size_t MEM_swapST(size_t in);
 /*-**************************************************************
 *  Memory I/O Implementation
 *****************************************************************/
-/* 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.
+/* 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 (i.e., 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.
+ *            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 (i.e. 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 */
+ * 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(__INTEL_COMPILER) || defined(__GNUC__) || defined(__ICCARM__)
-#    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)
-{
+#    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) 
+{ 
 #if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
     return 1;
 #elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
@@ -170,28 +170,28 @@ MEM_STATIC unsigned MEM_isLittleEndian(void)
 #elif defined(__DMC__) && defined(_M_IX86)
     return 1;
 #else
-    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
-    return one.c[0];
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */ 
+    return one.c[0]; 
 #endif
-}
-
-#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; }
+} 
+ 
+#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 size_t 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 */
+ 
+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 */ 
 #if defined(_MSC_VER) || (defined(__INTEL_COMPILER) && defined(WIN32))
     __pragma( pack(push, 1) )
     typedef struct { U16 v; } unalign16;
@@ -205,238 +205,238 @@ MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }
     typedef struct { U64 v; } __attribute__((packed)) unalign64;
     typedef struct { size_t v; } __attribute__((packed)) unalignArch;
 #endif
-
+ 
 MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign16*)ptr)->v; }
 MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign32*)ptr)->v; }
 MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign64*)ptr)->v; }
 MEM_STATIC size_t MEM_readST(const void* ptr) { return ((const unalignArch*)ptr)->v; }
-
+ 
 MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign16*)memPtr)->v = value; }
 MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign32*)memPtr)->v = value; }
 MEM_STATIC void MEM_write64(void* memPtr, U64 value) { ((unalign64*)memPtr)->v = value; }
-
-#else
-
-/* default method, safe and standard.
-   can sometimes prove slower */
-
-MEM_STATIC U16 MEM_read16(const void* memPtr)
-{
+ 
+#else 
+ 
+/* default method, safe and standard. 
+   can sometimes prove slower */ 
+ 
+MEM_STATIC U16 MEM_read16(const void* memPtr) 
+{ 
     U16 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC U32 MEM_read32(const void* memPtr)
-{
+} 
+ 
+MEM_STATIC U32 MEM_read32(const void* memPtr) 
+{ 
     U32 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC U64 MEM_read64(const void* memPtr)
-{
+} 
+ 
+MEM_STATIC U64 MEM_read64(const void* memPtr) 
+{ 
     U64 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC size_t MEM_readST(const void* memPtr)
-{
+} 
+ 
+MEM_STATIC size_t MEM_readST(const void* memPtr) 
+{ 
     size_t val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-MEM_STATIC void MEM_write16(void* memPtr, U16 value)
-{
+} 
+ 
+MEM_STATIC void MEM_write16(void* memPtr, U16 value) 
+{ 
     ZSTD_memcpy(memPtr, &value, sizeof(value));
-}
-
-MEM_STATIC void MEM_write32(void* memPtr, U32 value)
-{
+} 
+ 
+MEM_STATIC void MEM_write32(void* memPtr, U32 value) 
+{ 
     ZSTD_memcpy(memPtr, &value, sizeof(value));
-}
-
-MEM_STATIC void MEM_write64(void* memPtr, U64 value)
-{
+} 
+ 
+MEM_STATIC void MEM_write64(void* memPtr, U64 value) 
+{ 
     ZSTD_memcpy(memPtr, &value, sizeof(value));
-}
-
-#endif /* MEM_FORCE_MEMORY_ACCESS */
-
-MEM_STATIC U32 MEM_swap32(U32 in)
-{
-#if defined(_MSC_VER)     /* Visual Studio */
-    return _byteswap_ulong(in);
+} 
+ 
+#endif /* MEM_FORCE_MEMORY_ACCESS */ 
+ 
+MEM_STATIC U32 MEM_swap32(U32 in) 
+{ 
+#if defined(_MSC_VER)     /* Visual Studio */ 
+    return _byteswap_ulong(in); 
 #elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
   || (defined(__clang__) && __has_builtin(__builtin_bswap32))
-    return __builtin_bswap32(in);
-#else
-    return  ((in << 24) & 0xff000000 ) |
-            ((in <<  8) & 0x00ff0000 ) |
-            ((in >>  8) & 0x0000ff00 ) |
-            ((in >> 24) & 0x000000ff );
-#endif
-}
-
-MEM_STATIC U64 MEM_swap64(U64 in)
-{
-#if defined(_MSC_VER)     /* Visual Studio */
-    return _byteswap_uint64(in);
+    return __builtin_bswap32(in); 
+#else 
+    return  ((in << 24) & 0xff000000 ) | 
+            ((in <<  8) & 0x00ff0000 ) | 
+            ((in >>  8) & 0x0000ff00 ) | 
+            ((in >> 24) & 0x000000ff ); 
+#endif 
+} 
+ 
+MEM_STATIC U64 MEM_swap64(U64 in) 
+{ 
+#if defined(_MSC_VER)     /* Visual Studio */ 
+    return _byteswap_uint64(in); 
 #elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
   || (defined(__clang__) && __has_builtin(__builtin_bswap64))
-    return __builtin_bswap64(in);
-#else
-    return  ((in << 56) & 0xff00000000000000ULL) |
-            ((in << 40) & 0x00ff000000000000ULL) |
-            ((in << 24) & 0x0000ff0000000000ULL) |
-            ((in << 8)  & 0x000000ff00000000ULL) |
-            ((in >> 8)  & 0x00000000ff000000ULL) |
-            ((in >> 24) & 0x0000000000ff0000ULL) |
-            ((in >> 40) & 0x000000000000ff00ULL) |
-            ((in >> 56) & 0x00000000000000ffULL);
-#endif
-}
-
-MEM_STATIC size_t MEM_swapST(size_t in)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_swap32((U32)in);
-    else
-        return (size_t)MEM_swap64((U64)in);
-}
-
-/*=== Little endian r/w ===*/
-
-MEM_STATIC U16 MEM_readLE16(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        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 __builtin_bswap64(in); 
+#else 
+    return  ((in << 56) & 0xff00000000000000ULL) | 
+            ((in << 40) & 0x00ff000000000000ULL) | 
+            ((in << 24) & 0x0000ff0000000000ULL) | 
+            ((in << 8)  & 0x000000ff00000000ULL) | 
+            ((in >> 8)  & 0x00000000ff000000ULL) | 
+            ((in >> 24) & 0x0000000000ff0000ULL) | 
+            ((in >> 40) & 0x000000000000ff00ULL) | 
+            ((in >> 56) & 0x00000000000000ffULL); 
+#endif 
+} 
+ 
+MEM_STATIC size_t MEM_swapST(size_t in) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_swap32((U32)in); 
+    else 
+        return (size_t)MEM_swap64((U64)in); 
+} 
+ 
+/*=== Little endian r/w ===*/ 
+ 
+MEM_STATIC U16 MEM_readLE16(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        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 (U32)MEM_readLE16(memPtr) + ((U32)(((const BYTE*)memPtr)[2]) << 16);
-}
-
-MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val)
-{
-    MEM_writeLE16(memPtr, (U16)val);
-    ((BYTE*)memPtr)[2] = (BYTE)(val>>16);
-}
-
-MEM_STATIC U32 MEM_readLE32(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read32(memPtr);
-    else
-        return MEM_swap32(MEM_read32(memPtr));
-}
-
-MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)
-{
-    if (MEM_isLittleEndian())
-        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);
-    else
-        return MEM_swap64(MEM_read64(memPtr));
-}
-
-MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)
-{
-    if (MEM_isLittleEndian())
-        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);
-}
-
-/*=== Big endian r/w ===*/
-
-MEM_STATIC U32 MEM_readBE32(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_swap32(MEM_read32(memPtr));
-    else
-        return MEM_read32(memPtr);
-}
-
-MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32)
-{
-    if (MEM_isLittleEndian())
-        MEM_write32(memPtr, MEM_swap32(val32));
-    else
-        MEM_write32(memPtr, val32);
-}
-
-MEM_STATIC U64 MEM_readBE64(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_swap64(MEM_read64(memPtr));
-    else
-        return MEM_read64(memPtr);
-}
-
-MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64)
-{
-    if (MEM_isLittleEndian())
-        MEM_write64(memPtr, MEM_swap64(val64));
-    else
-        MEM_write64(memPtr, val64);
-}
-
-MEM_STATIC size_t MEM_readBEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readBE32(memPtr);
-    else
-        return (size_t)MEM_readBE64(memPtr);
-}
-
-MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val)
-{
-    if (MEM_32bits())
-        MEM_writeBE32(memPtr, (U32)val);
-    else
-        MEM_writeBE64(memPtr, (U64)val);
-}
-
+} 
+ 
+MEM_STATIC void MEM_writeLE24(void* memPtr, U32 val) 
+{ 
+    MEM_writeLE16(memPtr, (U16)val); 
+    ((BYTE*)memPtr)[2] = (BYTE)(val>>16); 
+} 
+ 
+MEM_STATIC U32 MEM_readLE32(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read32(memPtr); 
+    else 
+        return MEM_swap32(MEM_read32(memPtr)); 
+} 
+ 
+MEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32) 
+{ 
+    if (MEM_isLittleEndian()) 
+        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); 
+    else 
+        return MEM_swap64(MEM_read64(memPtr)); 
+} 
+ 
+MEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64) 
+{ 
+    if (MEM_isLittleEndian()) 
+        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); 
+} 
+ 
+/*=== Big endian r/w ===*/ 
+ 
+MEM_STATIC U32 MEM_readBE32(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_swap32(MEM_read32(memPtr)); 
+    else 
+        return MEM_read32(memPtr); 
+} 
+ 
+MEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32) 
+{ 
+    if (MEM_isLittleEndian()) 
+        MEM_write32(memPtr, MEM_swap32(val32)); 
+    else 
+        MEM_write32(memPtr, val32); 
+} 
+ 
+MEM_STATIC U64 MEM_readBE64(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_swap64(MEM_read64(memPtr)); 
+    else 
+        return MEM_read64(memPtr); 
+} 
+ 
+MEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64) 
+{ 
+    if (MEM_isLittleEndian()) 
+        MEM_write64(memPtr, MEM_swap64(val64)); 
+    else 
+        MEM_write64(memPtr, val64); 
+} 
+ 
+MEM_STATIC size_t MEM_readBEST(const void* memPtr) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_readBE32(memPtr); 
+    else 
+        return (size_t)MEM_readBE64(memPtr); 
+} 
+ 
+MEM_STATIC void MEM_writeBEST(void* memPtr, size_t val) 
+{ 
+    if (MEM_32bits()) 
+        MEM_writeBE32(memPtr, (U32)val); 
+    else 
+        MEM_writeBE64(memPtr, (U64)val); 
+} 
+ 
 /* code only tested on 32 and 64 bits systems */
 MEM_STATIC void MEM_check(void) { DEBUG_STATIC_ASSERT((sizeof(size_t)==4) || (sizeof(size_t)==8)); }
+ 
 
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* MEM_H_MODULE */
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* MEM_H_MODULE */ 
diff --git a/contrib/libs/zstd/lib/common/zstd_common.c b/contrib/libs/zstd/lib/common/zstd_common.c
index 3d7e35b309..ff9502fcf6 100644
--- a/contrib/libs/zstd/lib/common/zstd_common.c
+++ b/contrib/libs/zstd/lib/common/zstd_common.c
@@ -7,61 +7,61 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-
-
-/*-*************************************
-*  Dependencies
-***************************************/
+ 
+ 
+ 
+/*-************************************* 
+*  Dependencies 
+***************************************/ 
 #define ZSTD_DEPS_NEED_MALLOC
 #include "zstd_deps.h"   /* ZSTD_malloc, ZSTD_calloc, ZSTD_free, ZSTD_memset */
-#include "error_private.h"
+#include "error_private.h" 
 #include "zstd_internal.h"
-
-
-/*-****************************************
-*  Version
-******************************************/
+ 
+ 
+/*-**************************************** 
+*  Version 
+******************************************/ 
 unsigned ZSTD_versionNumber(void) { return ZSTD_VERSION_NUMBER; }
-
+ 
 const char* ZSTD_versionString(void) { return ZSTD_VERSION_STRING; }
+ 
 
-
-/*-****************************************
-*  ZSTD Error Management
-******************************************/
+/*-**************************************** 
+*  ZSTD Error Management 
+******************************************/ 
 #undef ZSTD_isError   /* defined within zstd_internal.h */
-/*! ZSTD_isError() :
+/*! ZSTD_isError() : 
  *  tells if a return value is an error code
  *  symbol is required for external callers */
-unsigned ZSTD_isError(size_t code) { return ERR_isError(code); }
-
-/*! ZSTD_getErrorName() :
+unsigned ZSTD_isError(size_t code) { return ERR_isError(code); } 
+ 
+/*! ZSTD_getErrorName() : 
  *  provides error code string from function result (useful for debugging) */
-const char* ZSTD_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-/*! ZSTD_getError() :
+const char* ZSTD_getErrorName(size_t code) { return ERR_getErrorName(code); } 
+ 
+/*! ZSTD_getError() : 
  *  convert a `size_t` function result into a proper ZSTD_errorCode enum */
-ZSTD_ErrorCode ZSTD_getErrorCode(size_t code) { return ERR_getErrorCode(code); }
-
-/*! ZSTD_getErrorString() :
+ZSTD_ErrorCode ZSTD_getErrorCode(size_t code) { return ERR_getErrorCode(code); } 
+ 
+/*! ZSTD_getErrorString() : 
  *  provides error code string from enum */
 const char* ZSTD_getErrorString(ZSTD_ErrorCode code) { return ERR_getErrorString(code); }
-
-
-
+ 
+ 
+ 
 /*=**************************************************************
 *  Custom allocator
 ****************************************************************/
 void* ZSTD_customMalloc(size_t size, ZSTD_customMem customMem)
-{
+{ 
     if (customMem.customAlloc)
         return customMem.customAlloc(customMem.opaque, size);
     return ZSTD_malloc(size);
-}
-
+} 
+ 
 void* ZSTD_customCalloc(size_t size, ZSTD_customMem customMem)
-{
+{ 
     if (customMem.customAlloc) {
         /* calloc implemented as malloc+memset;
          * not as efficient as calloc, but next best guess for custom malloc */
@@ -70,7 +70,7 @@ void* ZSTD_customCalloc(size_t size, ZSTD_customMem customMem)
         return ptr;
     }
     return ZSTD_calloc(1, size);
-}
+} 
 
 void ZSTD_customFree(void* ptr, ZSTD_customMem customMem)
 {
diff --git a/contrib/libs/zstd/lib/common/zstd_internal.h b/contrib/libs/zstd/lib/common/zstd_internal.h
index 1dee37cdbe..e39864dca6 100644
--- a/contrib/libs/zstd/lib/common/zstd_internal.h
+++ b/contrib/libs/zstd/lib/common/zstd_internal.h
@@ -7,24 +7,24 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-#ifndef ZSTD_CCOMMON_H_MODULE
-#define ZSTD_CCOMMON_H_MODULE
-
+ 
+#ifndef ZSTD_CCOMMON_H_MODULE 
+#define ZSTD_CCOMMON_H_MODULE 
+ 
 /* this module contains definitions which must be identical
  * across compression, decompression and dictBuilder.
  * It also contains a few functions useful to at least 2 of them
  * and which benefit from being inlined */
 
-/*-*************************************
-*  Dependencies
-***************************************/
+/*-************************************* 
+*  Dependencies 
+***************************************/ 
 #include "compiler.h"
 #include "cpu.h"
-#include "mem.h"
+#include "mem.h" 
 #include "debug.h"                 /* assert, DEBUGLOG, RAWLOG, g_debuglevel */
-#include "error_private.h"
-#define ZSTD_STATIC_LINKING_ONLY
+#include "error_private.h" 
+#define ZSTD_STATIC_LINKING_ONLY 
 #include "../zstd.h"
 #define FSE_STATIC_LINKING_ONLY
 #include "fse.h"
@@ -39,7 +39,7 @@
 #else
 #  define ZSTD_TRACE 0
 #endif
-
+ 
 #if defined (__cplusplus)
 extern "C" {
 #endif
@@ -53,67 +53,67 @@ extern "C" {
 
 /*-*************************************
 *  shared macros
-***************************************/
+***************************************/ 
 #undef MIN
 #undef MAX
-#define MIN(a,b) ((a)<(b) ? (a) : (b))
-#define MAX(a,b) ((a)>(b) ? (a) : (b))
+#define MIN(a,b) ((a)<(b) ? (a) : (b)) 
+#define MAX(a,b) ((a)>(b) ? (a) : (b)) 
 #define BOUNDED(min,val,max) (MAX(min,MIN(val,max)))
+ 
 
-
-/*-*************************************
-*  Common constants
-***************************************/
-#define ZSTD_OPT_NUM    (1<<12)
-
+/*-************************************* 
+*  Common constants 
+***************************************/ 
+#define ZSTD_OPT_NUM    (1<<12) 
+ 
 #define ZSTD_REP_NUM      3                 /* number of repcodes */
 static UNUSED_ATTR const U32 repStartValue[ZSTD_REP_NUM] = { 1, 4, 8 };
-
-#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 10
+ 
+#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 10 
 static UNUSED_ATTR const size_t ZSTD_fcs_fieldSize[4] = { 0, 2, 4, 8 };
 static UNUSED_ATTR const size_t ZSTD_did_fieldSize[4] = { 0, 1, 2, 4 };
-
+ 
 #define ZSTD_FRAMEIDSIZE 4   /* magic number size */
 
-#define ZSTD_BLOCKHEADERSIZE 3   /* C standard doesn't allow `static const` variable to be init using another `static const` variable */
+#define ZSTD_BLOCKHEADERSIZE 3   /* C standard doesn't allow `static const` variable to be init using another `static const` variable */ 
 static UNUSED_ATTR const size_t ZSTD_blockHeaderSize = ZSTD_BLOCKHEADERSIZE;
-typedef enum { bt_raw, bt_rle, bt_compressed, bt_reserved } blockType_e;
-
+typedef enum { bt_raw, bt_rle, bt_compressed, bt_reserved } blockType_e; 
+ 
 #define ZSTD_FRAMECHECKSUMSIZE 4
 
-#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
-typedef enum { set_basic, set_rle, set_compressed, set_repeat } symbolEncodingType_e;
-
-#define LONGNBSEQ 0x7F00
-
-#define MINMATCH 3
-
-#define Litbits  8
-#define MaxLit ((1<<Litbits) - 1)
+#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 
+typedef enum { set_basic, set_rle, set_compressed, set_repeat } symbolEncodingType_e; 
+ 
+#define LONGNBSEQ 0x7F00 
+ 
+#define MINMATCH 3 
+ 
+#define Litbits  8 
+#define MaxLit ((1<<Litbits) - 1) 
 #define MaxML   52
 #define MaxLL   35
 #define DefaultMaxOff 28
 #define MaxOff  31
-#define MaxSeq MAX(MaxLL, MaxML)   /* Assumption : MaxOff < MaxLL,MaxML */
-#define MLFSELog    9
-#define LLFSELog    9
-#define OffFSELog   8
+#define MaxSeq MAX(MaxLL, MaxML)   /* Assumption : MaxOff < MaxLL,MaxML */ 
+#define MLFSELog    9 
+#define LLFSELog    9 
+#define OffFSELog   8 
 #define MaxFSELog  MAX(MAX(MLFSELog, LLFSELog), OffFSELog)
-
+ 
 #define ZSTD_MAX_HUF_HEADER_SIZE 128 /* header + <= 127 byte tree description */
 /* Each table cannot take more than #symbols * FSELog bits */
 #define ZSTD_MAX_FSE_HEADERS_SIZE (((MaxML + 1) * MLFSELog + (MaxLL + 1) * LLFSELog + (MaxOff + 1) * OffFSELog + 7) / 8)
@@ -134,7 +134,7 @@ static UNUSED_ATTR const S16 LL_defaultNorm[MaxLL+1] = {
 };
 #define LL_DEFAULTNORMLOG 6  /* for static allocation */
 static UNUSED_ATTR const U32 LL_defaultNormLog = LL_DEFAULTNORMLOG;
-
+ 
 static UNUSED_ATTR const U8 ML_bits[MaxML+1] = {
      0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0,
@@ -155,7 +155,7 @@ static UNUSED_ATTR const S16 ML_defaultNorm[MaxML+1] = {
 };
 #define ML_DEFAULTNORMLOG 6  /* for static allocation */
 static UNUSED_ATTR const U32 ML_defaultNormLog = ML_DEFAULTNORMLOG;
-
+ 
 static UNUSED_ATTR const S16 OF_defaultNorm[DefaultMaxOff+1] = {
      1, 1, 1, 1, 1, 1, 2, 2,
      2, 1, 1, 1, 1, 1, 1, 1,
@@ -164,11 +164,11 @@ static UNUSED_ATTR const S16 OF_defaultNorm[DefaultMaxOff+1] = {
 };
 #define OF_DEFAULTNORMLOG 5  /* for static allocation */
 static UNUSED_ATTR const U32 OF_defaultNormLog = OF_DEFAULTNORMLOG;
-
-
-/*-*******************************************
-*  Shared functions to include for inlining
-*********************************************/
+ 
+ 
+/*-******************************************* 
+*  Shared functions to include for inlining 
+*********************************************/ 
 static void ZSTD_copy8(void* dst, const void* src) {
 #if defined(ZSTD_ARCH_ARM_NEON)
     vst1_u8((uint8_t*)dst, vld1_u8((const uint8_t*)src));
@@ -197,7 +197,7 @@ static void ZSTD_copy16(void* dst, const void* src) {
 #endif
 }
 #define COPY16(d,s) { ZSTD_copy16(d,s); d+=16; s+=16; }
-
+ 
 #define WILDCOPY_OVERLENGTH 32
 #define WILDCOPY_VECLEN 16
 
@@ -207,7 +207,7 @@ typedef enum {
     /*  ZSTD_overlap_dst_before_src, */
 } ZSTD_overlap_e;
 
-/*! ZSTD_wildcopy() :
+/*! ZSTD_wildcopy() : 
  *  Custom version of ZSTD_memcpy(), can over read/write up to WILDCOPY_OVERLENGTH bytes (if length==0)
  *  @param ovtype controls the overlap detection
  *         - ZSTD_no_overlap: The source and destination are guaranteed to be at least WILDCOPY_VECLEN bytes apart.
@@ -216,11 +216,11 @@ typedef enum {
  */
 MEM_STATIC FORCE_INLINE_ATTR
 void ZSTD_wildcopy(void* dst, const void* src, ptrdiff_t length, ZSTD_overlap_e const ovtype)
-{
+{ 
     ptrdiff_t diff = (BYTE*)dst - (const BYTE*)src;
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + length;
+    const BYTE* ip = (const BYTE*)src; 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + length; 
 
     if (ovtype == ZSTD_overlap_src_before_dst && diff < WILDCOPY_VECLEN) {
         /* Handle short offset copies. */
@@ -262,7 +262,7 @@ MEM_STATIC size_t ZSTD_limitCopy(void* dst, size_t dstCapacity, const void* src,
     }
     return length;
 }
-
+ 
 /* define "workspace is too large" as this number of times larger than needed */
 #define ZSTD_WORKSPACETOOLARGE_FACTOR 3
 
@@ -280,15 +280,15 @@ typedef enum {
 } ZSTD_bufferMode_e;
 
 
-/*-*******************************************
+/*-******************************************* 
 *  Private declarations
-*********************************************/
-typedef struct seqDef_s {
+*********************************************/ 
+typedef struct seqDef_s { 
     U32 offBase;   /* offBase == Offset + ZSTD_REP_NUM, or repcode 1,2,3 */
-    U16 litLength;
+    U16 litLength; 
     U16 mlBase;    /* mlBase == matchLength - MINMATCH */
-} seqDef;
-
+} seqDef; 
+ 
 /* Controls whether seqStore has a single "long" litLength or matchLength. See seqStore_t. */
 typedef enum {
     ZSTD_llt_none = 0,             /* no longLengthType */
@@ -296,14 +296,14 @@ typedef enum {
     ZSTD_llt_matchLength = 2       /* represents a long match */
 } ZSTD_longLengthType_e;
 
-typedef struct {
-    seqDef* sequencesStart;
+typedef struct { 
+    seqDef* sequencesStart; 
     seqDef* sequences;      /* ptr to end of sequences */
-    BYTE* litStart;
+    BYTE* litStart; 
     BYTE* lit;              /* ptr to end of literals */
-    BYTE* llCode;
-    BYTE* mlCode;
-    BYTE* ofCode;
+    BYTE* llCode; 
+    BYTE* mlCode; 
+    BYTE* ofCode; 
     size_t maxNbSeq;
     size_t maxNbLit;
 
@@ -313,8 +313,8 @@ typedef struct {
      */
     ZSTD_longLengthType_e   longLengthType;
     U32                     longLengthPos;  /* Index of the sequence to apply long length modification to */
-} seqStore_t;
-
+} seqStore_t; 
+ 
 typedef struct {
     U32 litLength;
     U32 matchLength;
@@ -353,18 +353,18 @@ typedef struct {
 
 const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx);   /* compress & dictBuilder */
 void ZSTD_seqToCodes(const seqStore_t* seqStorePtr);   /* compress, dictBuilder, decodeCorpus (shouldn't get its definition from here) */
-
-/* custom memory allocation functions */
+ 
+/* custom memory allocation functions */ 
 void* ZSTD_customMalloc(size_t size, ZSTD_customMem customMem);
 void* ZSTD_customCalloc(size_t size, ZSTD_customMem customMem);
 void ZSTD_customFree(void* ptr, ZSTD_customMem customMem);
-
+ 
 
 MEM_STATIC U32 ZSTD_highbit32(U32 val)   /* compress, dictBuilder, decodeCorpus */
-{
+{ 
     assert(val != 0);
     {
-#   if defined(_MSC_VER)   /* Visual */
+#   if defined(_MSC_VER)   /* Visual */ 
 #       if STATIC_BMI2 == 1
             return _lzcnt_u32(val)^31;
 #       else
@@ -377,11 +377,11 @@ MEM_STATIC U32 ZSTD_highbit32(U32 val)   /* compress, dictBuilder, decodeCorpus
                 __assume(0);
             }
 #       endif
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* GCC Intrinsic */
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* GCC Intrinsic */ 
         return __builtin_clz (val) ^ 31;
 #   elif defined(__ICCARM__)    /* IAR Intrinsic */
         return 31 - __CLZ(val);
-#   else   /* Software version */
+#   else   /* Software version */ 
         static const U32 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;
         v |= v >> 1;
@@ -390,10 +390,10 @@ MEM_STATIC U32 ZSTD_highbit32(U32 val)   /* compress, dictBuilder, decodeCorpus
         v |= v >> 8;
         v |= v >> 16;
         return DeBruijnClz[(v * 0x07C4ACDDU) >> 27];
-#   endif
+#   endif 
     }
-}
-
+} 
+ 
 /**
  * Counts the number of trailing zeros of a `size_t`.
  * Most compilers should support CTZ as a builtin. A backup
@@ -450,7 +450,7 @@ MEM_STATIC unsigned ZSTD_countTrailingZeros(size_t val)
 #       endif
     }
 }
-
+ 
 
 /* ZSTD_invalidateRepCodes() :
  * ensures next compression will not use repcodes from previous block.
@@ -490,4 +490,4 @@ MEM_STATIC int ZSTD_cpuSupportsBmi2(void)
 }
 #endif
 
-#endif   /* ZSTD_CCOMMON_H_MODULE */
+#endif   /* ZSTD_CCOMMON_H_MODULE */ 
diff --git a/contrib/libs/zstd/lib/compress/fse_compress.c b/contrib/libs/zstd/lib/compress/fse_compress.c
index 5547b4ac09..dbce9566ae 100644
--- a/contrib/libs/zstd/lib/compress/fse_compress.c
+++ b/contrib/libs/zstd/lib/compress/fse_compress.c
@@ -1,4 +1,4 @@
-/* ******************************************************************
+/* ****************************************************************** 
  * FSE : Finite State Entropy encoder
  * Copyright (c) Yann Collet, Facebook, Inc.
  *
@@ -10,54 +10,54 @@
  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-/* **************************************************************
-*  Includes
-****************************************************************/
+****************************************************************** */ 
+ 
+/* ************************************************************** 
+*  Includes 
+****************************************************************/ 
 #include "../common/compiler.h"
 #include "../common/mem.h"        /* U32, U16, etc. */
 #include "../common/debug.h"      /* assert, DEBUGLOG */
 #include "hist.h"       /* HIST_count_wksp */
 #include "../common/bitstream.h"
-#define FSE_STATIC_LINKING_ONLY
+#define FSE_STATIC_LINKING_ONLY 
 #include "../common/fse.h"
 #include "../common/error_private.h"
 #define ZSTD_DEPS_NEED_MALLOC
 #define ZSTD_DEPS_NEED_MATH64
 #include "../common/zstd_deps.h"  /* ZSTD_malloc, ZSTD_free, ZSTD_memcpy, ZSTD_memset */
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
 #define FSE_isError ERR_isError
-
-
-/* **************************************************************
-*  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 */
+ 
+ 
+/* ************************************************************** 
+*  Templates 
+****************************************************************/ 
+/* 
+  designed to be included 
+  for type-specific functions (template emulation in C) 
+  Objective is to write these functions only once, for improved maintenance 
+*/ 
+ 
+/* safety checks */ 
+#ifndef FSE_FUNCTION_EXTENSION 
+#  error "FSE_FUNCTION_EXTENSION must be defined" 
+#endif 
+#ifndef FSE_FUNCTION_TYPE 
+#  error "FSE_FUNCTION_TYPE must be defined" 
+#endif 
+ 
+/* Function names */ 
+#define FSE_CAT(X,Y) X##Y 
+#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y) 
+#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y) 
+ 
+ 
+/* Function templates */ 
 
 /* FSE_buildCTable_wksp() :
  * Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`).
@@ -67,51 +67,51 @@
 size_t FSE_buildCTable_wksp(FSE_CTable* ct,
                       const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
                             void* workSpace, size_t wkspSize)
-{
-    U32 const tableSize = 1 << tableLog;
-    U32 const tableMask = tableSize - 1;
-    void* const ptr = ct;
-    U16* const tableU16 = ( (U16*) ptr) + 2;
-    void* const FSCT = ((U32*)ptr) + 1 /* header */ + (tableLog ? tableSize>>1 : 1) ;
-    FSE_symbolCompressionTransform* const symbolTT = (FSE_symbolCompressionTransform*) (FSCT);
-    U32 const step = FSE_TABLESTEP(tableSize);
+{ 
+    U32 const tableSize = 1 << tableLog; 
+    U32 const tableMask = tableSize - 1; 
+    void* const ptr = ct; 
+    U16* const tableU16 = ( (U16*) ptr) + 2; 
+    void* const FSCT = ((U32*)ptr) + 1 /* header */ + (tableLog ? tableSize>>1 : 1) ; 
+    FSE_symbolCompressionTransform* const symbolTT = (FSE_symbolCompressionTransform*) (FSCT); 
+    U32 const step = FSE_TABLESTEP(tableSize); 
     U32 const maxSV1 = maxSymbolValue+1;
-
+ 
     U16* cumul = (U16*)workSpace;   /* size = maxSV1 */
     FSE_FUNCTION_TYPE* const tableSymbol = (FSE_FUNCTION_TYPE*)(cumul + (maxSV1+1));  /* size = tableSize */
 
-    U32 highThreshold = tableSize-1;
-
+    U32 highThreshold = tableSize-1; 
+ 
     assert(((size_t)workSpace & 1) == 0);  /* Must be 2 bytes-aligned */
     if (FSE_BUILD_CTABLE_WORKSPACE_SIZE(maxSymbolValue, tableLog) > wkspSize) return ERROR(tableLog_tooLarge);
-    /* CTable header */
-    tableU16[-2] = (U16) tableLog;
-    tableU16[-1] = (U16) maxSymbolValue;
+    /* CTable header */ 
+    tableU16[-2] = (U16) tableLog; 
+    tableU16[-1] = (U16) maxSymbolValue; 
     assert(tableLog < 16);   /* required for threshold strategy to work */
-
-    /* For explanations on how to distribute symbol values over the table :
+ 
+    /* For explanations on how to distribute symbol values over the table : 
      * http://fastcompression.blogspot.fr/2014/02/fse-distributing-symbol-values.html */
-
+ 
      #ifdef __clang_analyzer__
      ZSTD_memset(tableSymbol, 0, sizeof(*tableSymbol) * tableSize);   /* useless initialization, just to keep scan-build happy */
      #endif
 
-    /* symbol start positions */
-    {   U32 u;
-        cumul[0] = 0;
+    /* symbol start positions */ 
+    {   U32 u; 
+        cumul[0] = 0; 
         for (u=1; u <= maxSV1; u++) {
-            if (normalizedCounter[u-1]==-1) {  /* Low proba symbol */
-                cumul[u] = cumul[u-1] + 1;
-                tableSymbol[highThreshold--] = (FSE_FUNCTION_TYPE)(u-1);
-            } else {
+            if (normalizedCounter[u-1]==-1) {  /* Low proba symbol */ 
+                cumul[u] = cumul[u-1] + 1; 
+                tableSymbol[highThreshold--] = (FSE_FUNCTION_TYPE)(u-1); 
+            } else { 
                 assert(normalizedCounter[u-1] >= 0);
                 cumul[u] = cumul[u-1] + (U16)normalizedCounter[u-1];
                 assert(cumul[u] >= cumul[u-1]);  /* no overflow */
-        }   }
+        }   } 
         cumul[maxSV1] = (U16)(tableSize+1);
-    }
-
-    /* Spread symbols */
+    } 
+ 
+    /* Spread symbols */ 
     if (highThreshold == tableSize - 1) {
         /* Case for no low prob count symbols. Lay down 8 bytes at a time
          * to reduce branch misses since we are operating on a small block
@@ -152,52 +152,52 @@ size_t FSE_buildCTable_wksp(FSE_CTable* ct,
         }
     } else {
         U32 position = 0;
-        U32 symbol;
+        U32 symbol; 
         for (symbol=0; symbol<maxSV1; symbol++) {
             int nbOccurrences;
             int const freq = normalizedCounter[symbol];
             for (nbOccurrences=0; nbOccurrences<freq; nbOccurrences++) {
-                tableSymbol[position] = (FSE_FUNCTION_TYPE)symbol;
-                position = (position + step) & tableMask;
+                tableSymbol[position] = (FSE_FUNCTION_TYPE)symbol; 
+                position = (position + step) & tableMask; 
                 while (position > highThreshold)
                     position = (position + step) & tableMask;   /* Low proba area */
-        }   }
+        }   } 
         assert(position==0);  /* Must have initialized all positions */
-    }
-
-    /* Build table */
-    {   U32 u; for (u=0; u<tableSize; u++) {
-        FSE_FUNCTION_TYPE s = tableSymbol[u];   /* note : static analyzer may not understand tableSymbol is properly initialized */
-        tableU16[cumul[s]++] = (U16) (tableSize+u);   /* TableU16 : sorted by symbol order; gives next state value */
-    }   }
-
-    /* Build Symbol Transformation Table */
-    {   unsigned total = 0;
-        unsigned s;
-        for (s=0; s<=maxSymbolValue; s++) {
-            switch (normalizedCounter[s])
-            {
+    } 
+ 
+    /* Build table */ 
+    {   U32 u; for (u=0; u<tableSize; u++) { 
+        FSE_FUNCTION_TYPE s = tableSymbol[u];   /* note : static analyzer may not understand tableSymbol is properly initialized */ 
+        tableU16[cumul[s]++] = (U16) (tableSize+u);   /* TableU16 : sorted by symbol order; gives next state value */ 
+    }   } 
+ 
+    /* Build Symbol Transformation Table */ 
+    {   unsigned total = 0; 
+        unsigned s; 
+        for (s=0; s<=maxSymbolValue; s++) { 
+            switch (normalizedCounter[s]) 
+            { 
             case  0:
                 /* filling nonetheless, for compatibility with FSE_getMaxNbBits() */
                 symbolTT[s].deltaNbBits = ((tableLog+1) << 16) - (1<<tableLog);
                 break;
-
-            case -1:
-            case  1:
-                symbolTT[s].deltaNbBits = (tableLog << 16) - (1<<tableLog);
+ 
+            case -1: 
+            case  1: 
+                symbolTT[s].deltaNbBits = (tableLog << 16) - (1<<tableLog); 
                 assert(total <= INT_MAX);
                 symbolTT[s].deltaFindState = (int)(total - 1);
-                total ++;
-                break;
-            default :
+                total ++; 
+                break; 
+            default : 
                 assert(normalizedCounter[s] > 1);
                 {   U32 const maxBitsOut = tableLog - BIT_highbit32 ((U32)normalizedCounter[s]-1);
                     U32 const minStatePlus = (U32)normalizedCounter[s] << maxBitsOut;
-                    symbolTT[s].deltaNbBits = (maxBitsOut << 16) - minStatePlus;
+                    symbolTT[s].deltaNbBits = (maxBitsOut << 16) - minStatePlus; 
                     symbolTT[s].deltaFindState = (int)(total - (unsigned)normalizedCounter[s]);
                     total +=  (unsigned)normalizedCounter[s];
-    }   }   }   }
-
+    }   }   }   } 
+ 
 #if 0  /* debug : symbol costs */
     DEBUGLOG(5, "\n --- table statistics : ");
     {   U32 symbol;
@@ -209,241 +209,241 @@ size_t FSE_buildCTable_wksp(FSE_CTable* ct,
     }   }
 #endif
 
-    return 0;
-}
-
-
+    return 0; 
+} 
+ 
+ 
 
-#ifndef FSE_COMMONDEFS_ONLY
-
-/*-**************************************************************
+#ifndef FSE_COMMONDEFS_ONLY 
+ 
+/*-************************************************************** 
 *  FSE NCount encoding
-****************************************************************/
-size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog)
-{
+****************************************************************/ 
+size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog) 
+{ 
     size_t const maxHeaderSize = (((maxSymbolValue+1) * tableLog
                                    + 4 /* bitCount initialized at 4 */
                                    + 2 /* first two symbols may use one additional bit each */) / 8)
                                     + 1 /* round up to whole nb bytes */
                                     + 2 /* additional two bytes for bitstream flush */;
-    return maxSymbolValue ? maxHeaderSize : FSE_NCOUNTBOUND;  /* maxSymbolValue==0 ? use default */
-}
-
+    return maxSymbolValue ? maxHeaderSize : FSE_NCOUNTBOUND;  /* maxSymbolValue==0 ? use default */ 
+} 
+ 
 static size_t
 FSE_writeNCount_generic (void* header, size_t headerBufferSize,
                    const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,
                          unsigned writeIsSafe)
-{
-    BYTE* const ostart = (BYTE*) header;
-    BYTE* out = ostart;
-    BYTE* const oend = ostart + headerBufferSize;
-    int nbBits;
-    const int tableSize = 1 << tableLog;
-    int remaining;
-    int threshold;
+{ 
+    BYTE* const ostart = (BYTE*) header; 
+    BYTE* out = ostart; 
+    BYTE* const oend = ostart + headerBufferSize; 
+    int nbBits; 
+    const int tableSize = 1 << tableLog; 
+    int remaining; 
+    int threshold; 
     U32 bitStream = 0;
     int bitCount = 0;
     unsigned symbol = 0;
     unsigned const alphabetSize = maxSymbolValue + 1;
     int previousIs0 = 0;
-
-    /* Table Size */
-    bitStream += (tableLog-FSE_MIN_TABLELOG) << bitCount;
-    bitCount  += 4;
-
-    /* Init */
-    remaining = tableSize+1;   /* +1 for extra accuracy */
-    threshold = tableSize;
-    nbBits = tableLog+1;
-
+ 
+    /* Table Size */ 
+    bitStream += (tableLog-FSE_MIN_TABLELOG) << bitCount; 
+    bitCount  += 4; 
+ 
+    /* Init */ 
+    remaining = tableSize+1;   /* +1 for extra accuracy */ 
+    threshold = tableSize; 
+    nbBits = tableLog+1; 
+ 
     while ((symbol < alphabetSize) && (remaining>1)) {  /* stops at 1 */
         if (previousIs0) {
             unsigned start = symbol;
             while ((symbol < alphabetSize) && !normalizedCounter[symbol]) symbol++;
             if (symbol == alphabetSize) break;   /* incorrect distribution */
             while (symbol >= start+24) {
-                start+=24;
-                bitStream += 0xFFFFU << bitCount;
+                start+=24; 
+                bitStream += 0xFFFFU << bitCount; 
                 if ((!writeIsSafe) && (out > oend-2))
                     return ERROR(dstSize_tooSmall);   /* Buffer overflow */
-                out[0] = (BYTE) bitStream;
-                out[1] = (BYTE)(bitStream>>8);
-                out+=2;
-                bitStream>>=16;
-            }
+                out[0] = (BYTE) bitStream; 
+                out[1] = (BYTE)(bitStream>>8); 
+                out+=2; 
+                bitStream>>=16; 
+            } 
             while (symbol >= start+3) {
-                start+=3;
-                bitStream += 3 << bitCount;
-                bitCount += 2;
-            }
+                start+=3; 
+                bitStream += 3 << bitCount; 
+                bitCount += 2; 
+            } 
             bitStream += (symbol-start) << bitCount;
-            bitCount += 2;
-            if (bitCount>16) {
+            bitCount += 2; 
+            if (bitCount>16) { 
                 if ((!writeIsSafe) && (out > oend - 2))
                     return ERROR(dstSize_tooSmall);   /* Buffer overflow */
-                out[0] = (BYTE)bitStream;
-                out[1] = (BYTE)(bitStream>>8);
-                out += 2;
-                bitStream >>= 16;
-                bitCount -= 16;
-        }   }
+                out[0] = (BYTE)bitStream; 
+                out[1] = (BYTE)(bitStream>>8); 
+                out += 2; 
+                bitStream >>= 16; 
+                bitCount -= 16; 
+        }   } 
         {   int count = normalizedCounter[symbol++];
             int const max = (2*threshold-1) - remaining;
             remaining -= count < 0 ? -count : count;
-            count++;   /* +1 for extra accuracy */
+            count++;   /* +1 for extra accuracy */ 
             if (count>=threshold)
                 count += max;   /* [0..max[ [max..threshold[ (...) [threshold+max 2*threshold[ */
-            bitStream += count << bitCount;
-            bitCount  += nbBits;
-            bitCount  -= (count<max);
+            bitStream += count << bitCount; 
+            bitCount  += nbBits; 
+            bitCount  -= (count<max); 
             previousIs0  = (count==1);
             if (remaining<1) return ERROR(GENERIC);
             while (remaining<threshold) { nbBits--; threshold>>=1; }
-        }
-        if (bitCount>16) {
+        } 
+        if (bitCount>16) { 
             if ((!writeIsSafe) && (out > oend - 2))
                 return ERROR(dstSize_tooSmall);   /* Buffer overflow */
-            out[0] = (BYTE)bitStream;
-            out[1] = (BYTE)(bitStream>>8);
-            out += 2;
-            bitStream >>= 16;
-            bitCount -= 16;
-    }   }
-
+            out[0] = (BYTE)bitStream; 
+            out[1] = (BYTE)(bitStream>>8); 
+            out += 2; 
+            bitStream >>= 16; 
+            bitCount -= 16; 
+    }   } 
+ 
     if (remaining != 1)
         return ERROR(GENERIC);  /* incorrect normalized distribution */
     assert(symbol <= alphabetSize);
 
-    /* flush remaining bitStream */
+    /* flush remaining bitStream */ 
     if ((!writeIsSafe) && (out > oend - 2))
         return ERROR(dstSize_tooSmall);   /* Buffer overflow */
-    out[0] = (BYTE)bitStream;
-    out[1] = (BYTE)(bitStream>>8);
-    out+= (bitCount+7) /8;
-
-    return (out-ostart);
-}
-
-
+    out[0] = (BYTE)bitStream; 
+    out[1] = (BYTE)(bitStream>>8); 
+    out+= (bitCount+7) /8; 
+ 
+    return (out-ostart); 
+} 
+ 
+ 
 size_t FSE_writeNCount (void* buffer, size_t bufferSize,
                   const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
-{
+{ 
     if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);   /* Unsupported */
-    if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC);   /* Unsupported */
-
-    if (bufferSize < FSE_NCountWriteBound(maxSymbolValue, tableLog))
-        return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 0);
-
+    if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC);   /* Unsupported */ 
+ 
+    if (bufferSize < FSE_NCountWriteBound(maxSymbolValue, tableLog)) 
+        return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 0); 
+ 
     return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 1 /* write in buffer is safe */);
-}
-
-
-/*-**************************************************************
-*  FSE Compression Code
-****************************************************************/
-
-FSE_CTable* FSE_createCTable (unsigned maxSymbolValue, unsigned tableLog)
-{
-    size_t size;
-    if (tableLog > FSE_TABLELOG_ABSOLUTE_MAX) tableLog = FSE_TABLELOG_ABSOLUTE_MAX;
-    size = FSE_CTABLE_SIZE_U32 (tableLog, maxSymbolValue) * sizeof(U32);
+} 
+ 
+ 
+/*-************************************************************** 
+*  FSE Compression Code 
+****************************************************************/ 
+ 
+FSE_CTable* FSE_createCTable (unsigned maxSymbolValue, unsigned tableLog) 
+{ 
+    size_t size; 
+    if (tableLog > FSE_TABLELOG_ABSOLUTE_MAX) tableLog = FSE_TABLELOG_ABSOLUTE_MAX; 
+    size = FSE_CTABLE_SIZE_U32 (tableLog, maxSymbolValue) * sizeof(U32); 
     return (FSE_CTable*)ZSTD_malloc(size);
-}
-
+} 
+ 
 void FSE_freeCTable (FSE_CTable* ct) { ZSTD_free(ct); }
-
-/* provides the minimum logSize to safely represent a distribution */
-static unsigned FSE_minTableLog(size_t srcSize, unsigned maxSymbolValue)
-{
+ 
+/* provides the minimum logSize to safely represent a distribution */ 
+static unsigned FSE_minTableLog(size_t srcSize, unsigned maxSymbolValue) 
+{ 
     U32 minBitsSrc = BIT_highbit32((U32)(srcSize)) + 1;
     U32 minBitsSymbols = BIT_highbit32(maxSymbolValue) + 2;
     U32 minBits = minBitsSrc < minBitsSymbols ? minBitsSrc : minBitsSymbols;
     assert(srcSize > 1); /* Not supported, RLE should be used instead */
     return minBits;
-}
-
-unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus)
-{
+} 
+ 
+unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus) 
+{ 
     U32 maxBitsSrc = BIT_highbit32((U32)(srcSize - 1)) - minus;
-    U32 tableLog = maxTableLog;
+    U32 tableLog = maxTableLog; 
     U32 minBits = FSE_minTableLog(srcSize, maxSymbolValue);
     assert(srcSize > 1); /* Not supported, RLE should be used instead */
-    if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;
+    if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG; 
     if (maxBitsSrc < tableLog) tableLog = maxBitsSrc;   /* Accuracy can be reduced */
     if (minBits > tableLog) tableLog = minBits;   /* Need a minimum to safely represent all symbol values */
-    if (tableLog < FSE_MIN_TABLELOG) tableLog = FSE_MIN_TABLELOG;
-    if (tableLog > FSE_MAX_TABLELOG) tableLog = FSE_MAX_TABLELOG;
-    return tableLog;
-}
-
-unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue)
-{
-    return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 2);
-}
-
-/* Secondary normalization method.
-   To be used when primary method fails. */
-
+    if (tableLog < FSE_MIN_TABLELOG) tableLog = FSE_MIN_TABLELOG; 
+    if (tableLog > FSE_MAX_TABLELOG) tableLog = FSE_MAX_TABLELOG; 
+    return tableLog; 
+} 
+ 
+unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue) 
+{ 
+    return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 2); 
+} 
+ 
+/* Secondary normalization method. 
+   To be used when primary method fails. */ 
+ 
 static size_t FSE_normalizeM2(short* norm, U32 tableLog, const unsigned* count, size_t total, U32 maxSymbolValue, short lowProbCount)
-{
+{ 
     short const NOT_YET_ASSIGNED = -2;
-    U32 s;
-    U32 distributed = 0;
-    U32 ToDistribute;
-
-    /* Init */
+    U32 s; 
+    U32 distributed = 0; 
+    U32 ToDistribute; 
+ 
+    /* Init */ 
     U32 const lowThreshold = (U32)(total >> tableLog);
-    U32 lowOne = (U32)((total * 3) >> (tableLog + 1));
-
-    for (s=0; s<=maxSymbolValue; s++) {
-        if (count[s] == 0) {
-            norm[s]=0;
-            continue;
-        }
-        if (count[s] <= lowThreshold) {
+    U32 lowOne = (U32)((total * 3) >> (tableLog + 1)); 
+ 
+    for (s=0; s<=maxSymbolValue; s++) { 
+        if (count[s] == 0) { 
+            norm[s]=0; 
+            continue; 
+        } 
+        if (count[s] <= lowThreshold) { 
             norm[s] = lowProbCount;
-            distributed++;
-            total -= count[s];
-            continue;
-        }
-        if (count[s] <= lowOne) {
-            norm[s] = 1;
-            distributed++;
-            total -= count[s];
-            continue;
-        }
+            distributed++; 
+            total -= count[s]; 
+            continue; 
+        } 
+        if (count[s] <= lowOne) { 
+            norm[s] = 1; 
+            distributed++; 
+            total -= count[s]; 
+            continue; 
+        } 
 
         norm[s]=NOT_YET_ASSIGNED;
-    }
-    ToDistribute = (1 << tableLog) - distributed;
-
+    } 
+    ToDistribute = (1 << tableLog) - distributed; 
+ 
     if (ToDistribute == 0)
         return 0;
 
-    if ((total / ToDistribute) > lowOne) {
-        /* risk of rounding to zero */
-        lowOne = (U32)((total * 3) / (ToDistribute * 2));
-        for (s=0; s<=maxSymbolValue; s++) {
+    if ((total / ToDistribute) > lowOne) { 
+        /* risk of rounding to zero */ 
+        lowOne = (U32)((total * 3) / (ToDistribute * 2)); 
+        for (s=0; s<=maxSymbolValue; s++) { 
             if ((norm[s] == NOT_YET_ASSIGNED) && (count[s] <= lowOne)) {
-                norm[s] = 1;
-                distributed++;
-                total -= count[s];
-                continue;
-        }   }
-        ToDistribute = (1 << tableLog) - distributed;
-    }
-
-    if (distributed == maxSymbolValue+1) {
-        /* all values are pretty poor;
-           probably incompressible data (should have already been detected);
-           find max, then give all remaining points to max */
-        U32 maxV = 0, maxC = 0;
-        for (s=0; s<=maxSymbolValue; s++)
+                norm[s] = 1; 
+                distributed++; 
+                total -= count[s]; 
+                continue; 
+        }   } 
+        ToDistribute = (1 << tableLog) - distributed; 
+    } 
+ 
+    if (distributed == maxSymbolValue+1) { 
+        /* all values are pretty poor; 
+           probably incompressible data (should have already been detected); 
+           find max, then give all remaining points to max */ 
+        U32 maxV = 0, maxC = 0; 
+        for (s=0; s<=maxSymbolValue; s++) 
             if (count[s] > maxC) { maxV=s; maxC=count[s]; }
-        norm[maxV] += (short)ToDistribute;
-        return 0;
-    }
-
+        norm[maxV] += (short)ToDistribute; 
+        return 0; 
+    } 
+ 
     if (total == 0) {
         /* all of the symbols were low enough for the lowOne or lowThreshold */
         for (s=0; ToDistribute > 0; s = (s+1)%(maxSymbolValue+1))
@@ -452,270 +452,270 @@ static size_t FSE_normalizeM2(short* norm, U32 tableLog, const unsigned* count,
     }
 
     {   U64 const vStepLog = 62 - tableLog;
-        U64 const mid = (1ULL << (vStepLog-1)) - 1;
+        U64 const mid = (1ULL << (vStepLog-1)) - 1; 
         U64 const rStep = ZSTD_div64((((U64)1<<vStepLog) * ToDistribute) + mid, (U32)total);   /* scale on remaining */
-        U64 tmpTotal = mid;
-        for (s=0; s<=maxSymbolValue; s++) {
+        U64 tmpTotal = mid; 
+        for (s=0; s<=maxSymbolValue; s++) { 
             if (norm[s]==NOT_YET_ASSIGNED) {
                 U64 const end = tmpTotal + (count[s] * rStep);
                 U32 const sStart = (U32)(tmpTotal >> vStepLog);
                 U32 const sEnd = (U32)(end >> vStepLog);
                 U32 const weight = sEnd - sStart;
-                if (weight < 1)
-                    return ERROR(GENERIC);
-                norm[s] = (short)weight;
-                tmpTotal = end;
-    }   }   }
-
-    return 0;
-}
-
-size_t FSE_normalizeCount (short* normalizedCounter, unsigned tableLog,
-                           const unsigned* count, size_t total,
+                if (weight < 1) 
+                    return ERROR(GENERIC); 
+                norm[s] = (short)weight; 
+                tmpTotal = end; 
+    }   }   } 
+ 
+    return 0; 
+} 
+ 
+size_t FSE_normalizeCount (short* normalizedCounter, unsigned tableLog, 
+                           const unsigned* count, size_t total, 
                            unsigned maxSymbolValue, unsigned useLowProbCount)
-{
-    /* Sanity checks */
-    if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;
-    if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC);   /* Unsupported size */
-    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);   /* Unsupported size */
-    if (tableLog < FSE_minTableLog(total, maxSymbolValue)) return ERROR(GENERIC);   /* Too small tableLog, compression potentially impossible */
-
+{ 
+    /* Sanity checks */ 
+    if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG; 
+    if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC);   /* Unsupported size */ 
+    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);   /* Unsupported size */ 
+    if (tableLog < FSE_minTableLog(total, maxSymbolValue)) return ERROR(GENERIC);   /* Too small tableLog, compression potentially impossible */ 
+ 
     {   static U32 const rtbTable[] = {     0, 473195, 504333, 520860, 550000, 700000, 750000, 830000 };
         short const lowProbCount = useLowProbCount ? -1 : 1;
-        U64 const scale = 62 - tableLog;
+        U64 const scale = 62 - tableLog; 
         U64 const step = ZSTD_div64((U64)1<<62, (U32)total);   /* <== here, one division ! */
-        U64 const vStep = 1ULL<<(scale-20);
-        int stillToDistribute = 1<<tableLog;
-        unsigned s;
-        unsigned largest=0;
-        short largestP=0;
-        U32 lowThreshold = (U32)(total >> tableLog);
-
-        for (s=0; s<=maxSymbolValue; s++) {
-            if (count[s] == total) return 0;   /* rle special case */
-            if (count[s] == 0) { normalizedCounter[s]=0; continue; }
-            if (count[s] <= lowThreshold) {
+        U64 const vStep = 1ULL<<(scale-20); 
+        int stillToDistribute = 1<<tableLog; 
+        unsigned s; 
+        unsigned largest=0; 
+        short largestP=0; 
+        U32 lowThreshold = (U32)(total >> tableLog); 
+ 
+        for (s=0; s<=maxSymbolValue; s++) { 
+            if (count[s] == total) return 0;   /* rle special case */ 
+            if (count[s] == 0) { normalizedCounter[s]=0; continue; } 
+            if (count[s] <= lowThreshold) { 
                 normalizedCounter[s] = lowProbCount;
-                stillToDistribute--;
-            } else {
-                short proba = (short)((count[s]*step) >> scale);
-                if (proba<8) {
-                    U64 restToBeat = vStep * rtbTable[proba];
-                    proba += (count[s]*step) - ((U64)proba<<scale) > restToBeat;
-                }
+                stillToDistribute--; 
+            } else { 
+                short proba = (short)((count[s]*step) >> scale); 
+                if (proba<8) { 
+                    U64 restToBeat = vStep * rtbTable[proba]; 
+                    proba += (count[s]*step) - ((U64)proba<<scale) > restToBeat; 
+                } 
                 if (proba > largestP) { largestP=proba; largest=s; }
-                normalizedCounter[s] = proba;
-                stillToDistribute -= proba;
-        }   }
-        if (-stillToDistribute >= (normalizedCounter[largest] >> 1)) {
-            /* corner case, need another normalization method */
+                normalizedCounter[s] = proba; 
+                stillToDistribute -= proba; 
+        }   } 
+        if (-stillToDistribute >= (normalizedCounter[largest] >> 1)) { 
+            /* corner case, need another normalization method */ 
             size_t const errorCode = FSE_normalizeM2(normalizedCounter, tableLog, count, total, maxSymbolValue, lowProbCount);
-            if (FSE_isError(errorCode)) return errorCode;
-        }
-        else normalizedCounter[largest] += (short)stillToDistribute;
-    }
-
-#if 0
-    {   /* Print Table (debug) */
-        U32 s;
-        U32 nTotal = 0;
-        for (s=0; s<=maxSymbolValue; s++)
+            if (FSE_isError(errorCode)) return errorCode; 
+        } 
+        else normalizedCounter[largest] += (short)stillToDistribute; 
+    } 
+ 
+#if 0 
+    {   /* Print Table (debug) */ 
+        U32 s; 
+        U32 nTotal = 0; 
+        for (s=0; s<=maxSymbolValue; s++) 
             RAWLOG(2, "%3i: %4i \n", s, normalizedCounter[s]);
-        for (s=0; s<=maxSymbolValue; s++)
-            nTotal += abs(normalizedCounter[s]);
-        if (nTotal != (1U<<tableLog))
+        for (s=0; s<=maxSymbolValue; s++) 
+            nTotal += abs(normalizedCounter[s]); 
+        if (nTotal != (1U<<tableLog)) 
             RAWLOG(2, "Warning !!! Total == %u != %u !!!", nTotal, 1U<<tableLog);
-        getchar();
-    }
-#endif
-
-    return tableLog;
-}
-
-
-/* fake FSE_CTable, for raw (uncompressed) input */
-size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits)
-{
-    const unsigned tableSize = 1 << nbBits;
-    const unsigned tableMask = tableSize - 1;
-    const unsigned maxSymbolValue = tableMask;
-    void* const ptr = ct;
-    U16* const tableU16 = ( (U16*) ptr) + 2;
-    void* const FSCT = ((U32*)ptr) + 1 /* header */ + (tableSize>>1);   /* assumption : tableLog >= 1 */
-    FSE_symbolCompressionTransform* const symbolTT = (FSE_symbolCompressionTransform*) (FSCT);
-    unsigned s;
-
-    /* Sanity checks */
-    if (nbBits < 1) return ERROR(GENERIC);             /* min size */
-
-    /* header */
-    tableU16[-2] = (U16) nbBits;
-    tableU16[-1] = (U16) maxSymbolValue;
-
-    /* Build table */
-    for (s=0; s<tableSize; s++)
-        tableU16[s] = (U16)(tableSize + s);
-
-    /* Build Symbol Transformation Table */
-    {   const U32 deltaNbBits = (nbBits << 16) - (1 << nbBits);
-        for (s=0; s<=maxSymbolValue; s++) {
-            symbolTT[s].deltaNbBits = deltaNbBits;
-            symbolTT[s].deltaFindState = s-1;
-    }   }
-
-    return 0;
-}
-
+        getchar(); 
+    } 
+#endif 
+ 
+    return tableLog; 
+} 
+ 
+ 
+/* fake FSE_CTable, for raw (uncompressed) input */ 
+size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits) 
+{ 
+    const unsigned tableSize = 1 << nbBits; 
+    const unsigned tableMask = tableSize - 1; 
+    const unsigned maxSymbolValue = tableMask; 
+    void* const ptr = ct; 
+    U16* const tableU16 = ( (U16*) ptr) + 2; 
+    void* const FSCT = ((U32*)ptr) + 1 /* header */ + (tableSize>>1);   /* assumption : tableLog >= 1 */ 
+    FSE_symbolCompressionTransform* const symbolTT = (FSE_symbolCompressionTransform*) (FSCT); 
+    unsigned s; 
+ 
+    /* Sanity checks */ 
+    if (nbBits < 1) return ERROR(GENERIC);             /* min size */ 
+ 
+    /* header */ 
+    tableU16[-2] = (U16) nbBits; 
+    tableU16[-1] = (U16) maxSymbolValue; 
+ 
+    /* Build table */ 
+    for (s=0; s<tableSize; s++) 
+        tableU16[s] = (U16)(tableSize + s); 
+ 
+    /* Build Symbol Transformation Table */ 
+    {   const U32 deltaNbBits = (nbBits << 16) - (1 << nbBits); 
+        for (s=0; s<=maxSymbolValue; s++) { 
+            symbolTT[s].deltaNbBits = deltaNbBits; 
+            symbolTT[s].deltaFindState = s-1; 
+    }   } 
+ 
+    return 0; 
+} 
+ 
 /* fake FSE_CTable, for rle input (always same symbol) */
-size_t FSE_buildCTable_rle (FSE_CTable* ct, BYTE symbolValue)
-{
-    void* ptr = ct;
-    U16* tableU16 = ( (U16*) ptr) + 2;
-    void* FSCTptr = (U32*)ptr + 2;
-    FSE_symbolCompressionTransform* symbolTT = (FSE_symbolCompressionTransform*) FSCTptr;
-
-    /* header */
-    tableU16[-2] = (U16) 0;
-    tableU16[-1] = (U16) symbolValue;
-
-    /* Build table */
-    tableU16[0] = 0;
-    tableU16[1] = 0;   /* just in case */
-
-    /* Build Symbol Transformation Table */
-    symbolTT[symbolValue].deltaNbBits = 0;
-    symbolTT[symbolValue].deltaFindState = 0;
-
-    return 0;
-}
-
-
-static size_t FSE_compress_usingCTable_generic (void* dst, size_t dstSize,
-                           const void* src, size_t srcSize,
-                           const FSE_CTable* ct, const unsigned fast)
-{
-    const BYTE* const istart = (const BYTE*) src;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* ip=iend;
-
-    BIT_CStream_t bitC;
-    FSE_CState_t CState1, CState2;
-
-    /* init */
-    if (srcSize <= 2) return 0;
+size_t FSE_buildCTable_rle (FSE_CTable* ct, BYTE symbolValue) 
+{ 
+    void* ptr = ct; 
+    U16* tableU16 = ( (U16*) ptr) + 2; 
+    void* FSCTptr = (U32*)ptr + 2; 
+    FSE_symbolCompressionTransform* symbolTT = (FSE_symbolCompressionTransform*) FSCTptr; 
+ 
+    /* header */ 
+    tableU16[-2] = (U16) 0; 
+    tableU16[-1] = (U16) symbolValue; 
+ 
+    /* Build table */ 
+    tableU16[0] = 0; 
+    tableU16[1] = 0;   /* just in case */ 
+ 
+    /* Build Symbol Transformation Table */ 
+    symbolTT[symbolValue].deltaNbBits = 0; 
+    symbolTT[symbolValue].deltaFindState = 0; 
+ 
+    return 0; 
+} 
+ 
+ 
+static size_t FSE_compress_usingCTable_generic (void* dst, size_t dstSize, 
+                           const void* src, size_t srcSize, 
+                           const FSE_CTable* ct, const unsigned fast) 
+{ 
+    const BYTE* const istart = (const BYTE*) src; 
+    const BYTE* const iend = istart + srcSize; 
+    const BYTE* ip=iend; 
+ 
+    BIT_CStream_t bitC; 
+    FSE_CState_t CState1, CState2; 
+ 
+    /* init */ 
+    if (srcSize <= 2) return 0; 
     { size_t const initError = BIT_initCStream(&bitC, dst, dstSize);
       if (FSE_isError(initError)) return 0; /* not enough space available to write a bitstream */ }
-
-#define FSE_FLUSHBITS(s)  (fast ? BIT_flushBitsFast(s) : BIT_flushBits(s))
-
-    if (srcSize & 1) {
-        FSE_initCState2(&CState1, ct, *--ip);
-        FSE_initCState2(&CState2, ct, *--ip);
-        FSE_encodeSymbol(&bitC, &CState1, *--ip);
-        FSE_FLUSHBITS(&bitC);
-    } else {
-        FSE_initCState2(&CState2, ct, *--ip);
-        FSE_initCState2(&CState1, ct, *--ip);
-    }
-
-    /* join to mod 4 */
-    srcSize -= 2;
-    if ((sizeof(bitC.bitContainer)*8 > FSE_MAX_TABLELOG*4+7 ) && (srcSize & 2)) {  /* test bit 2 */
-        FSE_encodeSymbol(&bitC, &CState2, *--ip);
-        FSE_encodeSymbol(&bitC, &CState1, *--ip);
-        FSE_FLUSHBITS(&bitC);
-    }
-
-    /* 2 or 4 encoding per loop */
+ 
+#define FSE_FLUSHBITS(s)  (fast ? BIT_flushBitsFast(s) : BIT_flushBits(s)) 
+ 
+    if (srcSize & 1) { 
+        FSE_initCState2(&CState1, ct, *--ip); 
+        FSE_initCState2(&CState2, ct, *--ip); 
+        FSE_encodeSymbol(&bitC, &CState1, *--ip); 
+        FSE_FLUSHBITS(&bitC); 
+    } else { 
+        FSE_initCState2(&CState2, ct, *--ip); 
+        FSE_initCState2(&CState1, ct, *--ip); 
+    } 
+ 
+    /* join to mod 4 */ 
+    srcSize -= 2; 
+    if ((sizeof(bitC.bitContainer)*8 > FSE_MAX_TABLELOG*4+7 ) && (srcSize & 2)) {  /* test bit 2 */ 
+        FSE_encodeSymbol(&bitC, &CState2, *--ip); 
+        FSE_encodeSymbol(&bitC, &CState1, *--ip); 
+        FSE_FLUSHBITS(&bitC); 
+    } 
+ 
+    /* 2 or 4 encoding per loop */ 
     while ( ip>istart ) {
-
-        FSE_encodeSymbol(&bitC, &CState2, *--ip);
-
-        if (sizeof(bitC.bitContainer)*8 < FSE_MAX_TABLELOG*2+7 )   /* this test must be static */
-            FSE_FLUSHBITS(&bitC);
-
-        FSE_encodeSymbol(&bitC, &CState1, *--ip);
-
-        if (sizeof(bitC.bitContainer)*8 > FSE_MAX_TABLELOG*4+7 ) {  /* this test must be static */
-            FSE_encodeSymbol(&bitC, &CState2, *--ip);
-            FSE_encodeSymbol(&bitC, &CState1, *--ip);
-        }
-
-        FSE_FLUSHBITS(&bitC);
-    }
-
-    FSE_flushCState(&bitC, &CState2);
-    FSE_flushCState(&bitC, &CState1);
-    return BIT_closeCStream(&bitC);
-}
-
-size_t FSE_compress_usingCTable (void* dst, size_t dstSize,
-                           const void* src, size_t srcSize,
-                           const FSE_CTable* ct)
-{
+ 
+        FSE_encodeSymbol(&bitC, &CState2, *--ip); 
+ 
+        if (sizeof(bitC.bitContainer)*8 < FSE_MAX_TABLELOG*2+7 )   /* this test must be static */ 
+            FSE_FLUSHBITS(&bitC); 
+ 
+        FSE_encodeSymbol(&bitC, &CState1, *--ip); 
+ 
+        if (sizeof(bitC.bitContainer)*8 > FSE_MAX_TABLELOG*4+7 ) {  /* this test must be static */ 
+            FSE_encodeSymbol(&bitC, &CState2, *--ip); 
+            FSE_encodeSymbol(&bitC, &CState1, *--ip); 
+        } 
+ 
+        FSE_FLUSHBITS(&bitC); 
+    } 
+ 
+    FSE_flushCState(&bitC, &CState2); 
+    FSE_flushCState(&bitC, &CState1); 
+    return BIT_closeCStream(&bitC); 
+} 
+ 
+size_t FSE_compress_usingCTable (void* dst, size_t dstSize, 
+                           const void* src, size_t srcSize, 
+                           const FSE_CTable* ct) 
+{ 
     unsigned const fast = (dstSize >= FSE_BLOCKBOUND(srcSize));
-
-    if (fast)
-        return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 1);
-    else
-        return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 0);
-}
-
-
-size_t FSE_compressBound(size_t size) { return FSE_COMPRESSBOUND(size); }
-
+ 
+    if (fast) 
+        return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 1); 
+    else 
+        return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 0); 
+} 
+ 
+ 
+size_t FSE_compressBound(size_t size) { return FSE_COMPRESSBOUND(size); } 
+ 
 #ifndef ZSTD_NO_UNUSED_FUNCTIONS
 /* FSE_compress_wksp() :
  * Same as FSE_compress2(), but using an externally allocated scratch buffer (`workSpace`).
  * `wkspSize` size must be `(1<<tableLog)`.
  */
 size_t FSE_compress_wksp (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize)
-{
-    BYTE* const ostart = (BYTE*) dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + dstSize;
-
+{ 
+    BYTE* const ostart = (BYTE*) dst; 
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + dstSize; 
+ 
     unsigned count[FSE_MAX_SYMBOL_VALUE+1];
-    S16   norm[FSE_MAX_SYMBOL_VALUE+1];
+    S16   norm[FSE_MAX_SYMBOL_VALUE+1]; 
     FSE_CTable* CTable = (FSE_CTable*)workSpace;
     size_t const CTableSize = FSE_CTABLE_SIZE_U32(tableLog, maxSymbolValue);
     void* scratchBuffer = (void*)(CTable + CTableSize);
     size_t const scratchBufferSize = wkspSize - (CTableSize * sizeof(FSE_CTable));
-
-    /* init conditions */
+ 
+    /* init conditions */ 
     if (wkspSize < FSE_COMPRESS_WKSP_SIZE_U32(tableLog, maxSymbolValue)) return ERROR(tableLog_tooLarge);
     if (srcSize <= 1) return 0;  /* Not compressible */
-    if (!maxSymbolValue) maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
-    if (!tableLog) tableLog = FSE_DEFAULT_TABLELOG;
-
-    /* Scan input and build symbol stats */
+    if (!maxSymbolValue) maxSymbolValue = FSE_MAX_SYMBOL_VALUE; 
+    if (!tableLog) tableLog = FSE_DEFAULT_TABLELOG; 
+ 
+    /* Scan input and build symbol stats */ 
     {   CHECK_V_F(maxCount, HIST_count_wksp(count, &maxSymbolValue, src, srcSize, scratchBuffer, scratchBufferSize) );
         if (maxCount == srcSize) return 1;   /* only a single symbol in src : rle */
         if (maxCount == 1) return 0;         /* each symbol present maximum once => not compressible */
         if (maxCount < (srcSize >> 7)) return 0;   /* Heuristic : not compressible enough */
     }
-
-    tableLog = FSE_optimalTableLog(tableLog, srcSize, maxSymbolValue);
+ 
+    tableLog = FSE_optimalTableLog(tableLog, srcSize, maxSymbolValue); 
     CHECK_F( FSE_normalizeCount(norm, tableLog, count, srcSize, maxSymbolValue, /* useLowProbCount */ srcSize >= 2048) );
-
-    /* Write table description header */
+ 
+    /* Write table description header */ 
     {   CHECK_V_F(nc_err, FSE_writeNCount(op, oend-op, norm, maxSymbolValue, tableLog) );
         op += nc_err;
     }
-
-    /* Compress */
+ 
+    /* Compress */ 
     CHECK_F( FSE_buildCTable_wksp(CTable, norm, maxSymbolValue, tableLog, scratchBuffer, scratchBufferSize) );
     {   CHECK_V_F(cSize, FSE_compress_usingCTable(op, oend - op, src, srcSize, CTable) );
         if (cSize == 0) return 0;   /* not enough space for compressed data */
         op += cSize;
     }
-
-    /* check compressibility */
+ 
+    /* check compressibility */ 
     if ( (size_t)(op-ostart) >= srcSize-1 ) return 0;
-
-    return op-ostart;
-}
-
+ 
+    return op-ostart; 
+} 
+ 
 typedef struct {
     FSE_CTable CTable_max[FSE_CTABLE_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE)];
     union {
@@ -725,17 +725,17 @@ typedef struct {
 } fseWkspMax_t;
 
 size_t FSE_compress2 (void* dst, size_t dstCapacity, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog)
-{
+{ 
     fseWkspMax_t scratchBuffer;
     DEBUG_STATIC_ASSERT(sizeof(scratchBuffer) >= FSE_COMPRESS_WKSP_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE));   /* compilation failures here means scratchBuffer is not large enough */
     if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
     return FSE_compress_wksp(dst, dstCapacity, src, srcSize, maxSymbolValue, tableLog, &scratchBuffer, sizeof(scratchBuffer));
-}
-
+} 
+ 
 size_t FSE_compress (void* dst, size_t dstCapacity, const void* src, size_t srcSize)
 {
     return FSE_compress2(dst, dstCapacity, src, srcSize, FSE_MAX_SYMBOL_VALUE, FSE_DEFAULT_TABLELOG);
 }
 #endif
-
-#endif   /* FSE_COMMONDEFS_ONLY */
+ 
+#endif   /* FSE_COMMONDEFS_ONLY */ 
diff --git a/contrib/libs/zstd/lib/compress/huf_compress.c b/contrib/libs/zstd/lib/compress/huf_compress.c
index 2b3d6adc2a..137671d31a 100644
--- a/contrib/libs/zstd/lib/compress/huf_compress.c
+++ b/contrib/libs/zstd/lib/compress/huf_compress.c
@@ -1,4 +1,4 @@
-/* ******************************************************************
+/* ****************************************************************** 
  * Huffman encoder, part of New Generation Entropy library
  * Copyright (c) Yann Collet, Facebook, Inc.
  *
@@ -10,49 +10,49 @@
  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-/* **************************************************************
-*  Compiler specifics
-****************************************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#endif
-
-
-/* **************************************************************
-*  Includes
-****************************************************************/
+****************************************************************** */ 
+ 
+/* ************************************************************** 
+*  Compiler specifics 
+****************************************************************/ 
+#ifdef _MSC_VER    /* Visual Studio */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#endif 
+ 
+ 
+/* ************************************************************** 
+*  Includes 
+****************************************************************/ 
 #include "../common/zstd_deps.h"     /* ZSTD_memcpy, ZSTD_memset */
 #include "../common/compiler.h"
 #include "../common/bitstream.h"
 #include "hist.h"
-#define FSE_STATIC_LINKING_ONLY   /* FSE_optimalTableLog_internal */
+#define FSE_STATIC_LINKING_ONLY   /* FSE_optimalTableLog_internal */ 
 #include "../common/fse.h"        /* header compression */
-#define HUF_STATIC_LINKING_ONLY
+#define HUF_STATIC_LINKING_ONLY 
 #include "../common/huf.h"
 #include "../common/error_private.h"
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
 #define HUF_isError ERR_isError
 #define HUF_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)   /* use only *after* variable declarations */
-
-
-/* **************************************************************
-*  Utils
-****************************************************************/
-unsigned HUF_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue)
-{
-    return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 1);
-}
-
-
-/* *******************************************************
-*  HUF : Huffman block compression
-*********************************************************/
+ 
+ 
+/* ************************************************************** 
+*  Utils 
+****************************************************************/ 
+unsigned HUF_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue) 
+{ 
+    return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 1); 
+} 
+ 
+ 
+/* ******************************************************* 
+*  HUF : Huffman block compression 
+*********************************************************/ 
 #define HUF_WORKSPACE_MAX_ALIGNMENT 8
 
 static void* HUF_alignUpWorkspace(void* workspace, size_t* workspaceSizePtr, size_t align)
@@ -166,7 +166,7 @@ static void HUF_setValue(HUF_CElt* elt, size_t value)
 typedef struct {
     HUF_CompressWeightsWksp wksp;
     BYTE bitsToWeight[HUF_TABLELOG_MAX + 1];   /* precomputed conversion table */
-    BYTE huffWeight[HUF_SYMBOLVALUE_MAX];
+    BYTE huffWeight[HUF_SYMBOLVALUE_MAX]; 
 } HUF_WriteCTableWksp;
 
 size_t HUF_writeCTable_wksp(void* dst, size_t maxDstSize,
@@ -174,39 +174,39 @@ size_t HUF_writeCTable_wksp(void* dst, size_t maxDstSize,
                             void* workspace, size_t workspaceSize)
 {
     HUF_CElt const* const ct = CTable + 1;
-    BYTE* op = (BYTE*)dst;
-    U32 n;
+    BYTE* op = (BYTE*)dst; 
+    U32 n; 
     HUF_WriteCTableWksp* wksp = (HUF_WriteCTableWksp*)HUF_alignUpWorkspace(workspace, &workspaceSize, ZSTD_ALIGNOF(U32));
-
+ 
     /* check conditions */
     if (workspaceSize < sizeof(HUF_WriteCTableWksp)) return ERROR(GENERIC);
     if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);
-
-    /* convert to weight */
+ 
+    /* convert to weight */ 
     wksp->bitsToWeight[0] = 0;
-    for (n=1; n<huffLog+1; n++)
+    for (n=1; n<huffLog+1; n++) 
         wksp->bitsToWeight[n] = (BYTE)(huffLog + 1 - n);
-    for (n=0; n<maxSymbolValue; n++)
+    for (n=0; n<maxSymbolValue; n++) 
         wksp->huffWeight[n] = wksp->bitsToWeight[HUF_getNbBits(ct[n])];
-
+ 
     /* attempt weights compression by FSE */
     if (maxDstSize < 1) return ERROR(dstSize_tooSmall);
     {   CHECK_V_F(hSize, HUF_compressWeights(op+1, maxDstSize-1, wksp->huffWeight, maxSymbolValue, &wksp->wksp, sizeof(wksp->wksp)) );
         if ((hSize>1) & (hSize < maxSymbolValue/2)) {   /* FSE compressed */
             op[0] = (BYTE)hSize;
             return hSize+1;
-    }   }
-
+    }   } 
+ 
     /* write raw values as 4-bits (max : 15) */
     if (maxSymbolValue > (256-128)) return ERROR(GENERIC);   /* should not happen : likely means source cannot be compressed */
-    if (((maxSymbolValue+1)/2) + 1 > maxDstSize) return ERROR(dstSize_tooSmall);   /* not enough space within dst buffer */
-    op[0] = (BYTE)(128 /*special case*/ + (maxSymbolValue-1));
+    if (((maxSymbolValue+1)/2) + 1 > maxDstSize) return ERROR(dstSize_tooSmall);   /* not enough space within dst buffer */ 
+    op[0] = (BYTE)(128 /*special case*/ + (maxSymbolValue-1)); 
     wksp->huffWeight[maxSymbolValue] = 0;   /* to be sure it doesn't cause msan issue in final combination */
-    for (n=0; n<maxSymbolValue; n+=2)
+    for (n=0; n<maxSymbolValue; n+=2) 
         op[(n/2)+1] = (BYTE)((wksp->huffWeight[n] << 4) + wksp->huffWeight[n+1]);
-    return ((maxSymbolValue+1)/2) + 1;
-}
-
+    return ((maxSymbolValue+1)/2) + 1; 
+} 
+ 
 /*! HUF_writeCTable() :
     `CTable` : Huffman tree to save, using huf representation.
     @return : size of saved CTable */
@@ -216,67 +216,67 @@ size_t HUF_writeCTable (void* dst, size_t maxDstSize,
     HUF_WriteCTableWksp wksp;
     return HUF_writeCTable_wksp(dst, maxDstSize, CTable, maxSymbolValue, huffLog, &wksp, sizeof(wksp));
 }
-
+ 
 
 size_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize, unsigned* hasZeroWeights)
-{
+{ 
     BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1];   /* init not required, even though some static analyzer may complain */
-    U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1];   /* large enough for values from 0 to 16 */
-    U32 tableLog = 0;
-    U32 nbSymbols = 0;
+    U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1];   /* large enough for values from 0 to 16 */ 
+    U32 tableLog = 0; 
+    U32 nbSymbols = 0; 
     HUF_CElt* const ct = CTable + 1;
-
-    /* get symbol weights */
+ 
+    /* get symbol weights */ 
     CHECK_V_F(readSize, HUF_readStats(huffWeight, HUF_SYMBOLVALUE_MAX+1, rankVal, &nbSymbols, &tableLog, src, srcSize));
     *hasZeroWeights = (rankVal[0] > 0);
-
-    /* check result */
-    if (tableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
+ 
+    /* check result */ 
+    if (tableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge); 
     if (nbSymbols > *maxSymbolValuePtr+1) return ERROR(maxSymbolValue_tooSmall);
-
+ 
     CTable[0] = tableLog;
 
-    /* Prepare base value per rank */
-    {   U32 n, nextRankStart = 0;
-        for (n=1; n<=tableLog; n++) {
+    /* Prepare base value per rank */ 
+    {   U32 n, nextRankStart = 0; 
+        for (n=1; n<=tableLog; n++) { 
             U32 curr = nextRankStart;
-            nextRankStart += (rankVal[n] << (n-1));
+            nextRankStart += (rankVal[n] << (n-1)); 
             rankVal[n] = curr;
-    }   }
-
-    /* fill nbBits */
-    {   U32 n; for (n=0; n<nbSymbols; n++) {
-            const U32 w = huffWeight[n];
+    }   } 
+ 
+    /* fill nbBits */ 
+    {   U32 n; for (n=0; n<nbSymbols; n++) { 
+            const U32 w = huffWeight[n]; 
             HUF_setNbBits(ct + n, (BYTE)(tableLog + 1 - w) & -(w != 0));
-    }   }
-
-    /* fill val */
+    }   } 
+ 
+    /* fill val */ 
     {   U16 nbPerRank[HUF_TABLELOG_MAX+2]  = {0};  /* support w=0=>n=tableLog+1 */
         U16 valPerRank[HUF_TABLELOG_MAX+2] = {0};
         { U32 n; for (n=0; n<nbSymbols; n++) nbPerRank[HUF_getNbBits(ct[n])]++; }
-        /* determine stating value per rank */
+        /* determine stating value per rank */ 
         valPerRank[tableLog+1] = 0;   /* for w==0 */
-        {   U16 min = 0;
+        {   U16 min = 0; 
             U32 n; for (n=tableLog; n>0; n--) {  /* start at n=tablelog <-> w=1 */
                 valPerRank[n] = min;     /* get starting value within each rank */
-                min += nbPerRank[n];
-                min >>= 1;
-        }   }
-        /* assign value within rank, symbol order */
+                min += nbPerRank[n]; 
+                min >>= 1; 
+        }   } 
+        /* assign value within rank, symbol order */ 
         { U32 n; for (n=0; n<nbSymbols; n++) HUF_setValue(ct + n, valPerRank[HUF_getNbBits(ct[n])]++); }
-    }
-
+    } 
+ 
     *maxSymbolValuePtr = nbSymbols - 1;
-    return readSize;
-}
-
+    return readSize; 
+} 
+ 
 U32 HUF_getNbBitsFromCTable(HUF_CElt const* CTable, U32 symbolValue)
 {
     const HUF_CElt* ct = CTable + 1;
     assert(symbolValue <= HUF_SYMBOLVALUE_MAX);
     return (U32)HUF_getNbBits(ct[symbolValue]);
 }
-
+ 
 
 typedef struct nodeElt_s {
     U32 count;
@@ -305,83 +305,83 @@ typedef struct nodeElt_s {
  * @return            The maximum number of bits of the Huffman tree after adjustment,
  *                    necessarily no more than maxNbBits.
  */
-static U32 HUF_setMaxHeight(nodeElt* huffNode, U32 lastNonNull, U32 maxNbBits)
-{
-    const U32 largestBits = huffNode[lastNonNull].nbBits;
+static U32 HUF_setMaxHeight(nodeElt* huffNode, U32 lastNonNull, U32 maxNbBits) 
+{ 
+    const U32 largestBits = huffNode[lastNonNull].nbBits; 
     /* early exit : no elt > maxNbBits, so the tree is already valid. */
     if (largestBits <= maxNbBits) return largestBits;
-
-    /* there are several too large elements (at least >= 2) */
-    {   int totalCost = 0;
-        const U32 baseCost = 1 << (largestBits - maxNbBits);
+ 
+    /* there are several too large elements (at least >= 2) */ 
+    {   int totalCost = 0; 
+        const U32 baseCost = 1 << (largestBits - maxNbBits); 
         int n = (int)lastNonNull;
-
+ 
         /* Adjust any ranks > maxNbBits to maxNbBits.
          * Compute totalCost, which is how far the sum of the ranks is
          * we are over 2^largestBits after adjust the offending ranks.
          */
-        while (huffNode[n].nbBits > maxNbBits) {
-            totalCost += baseCost - (1 << (largestBits - huffNode[n].nbBits));
-            huffNode[n].nbBits = (BYTE)maxNbBits;
+        while (huffNode[n].nbBits > maxNbBits) { 
+            totalCost += baseCost - (1 << (largestBits - huffNode[n].nbBits)); 
+            huffNode[n].nbBits = (BYTE)maxNbBits; 
             n--;
         }
         /* n stops at huffNode[n].nbBits <= maxNbBits */
         assert(huffNode[n].nbBits <= maxNbBits);
         /* n end at index of smallest symbol using < maxNbBits */
         while (huffNode[n].nbBits == maxNbBits) --n;
-
+ 
         /* renorm totalCost from 2^largestBits to 2^maxNbBits
          * note : totalCost is necessarily a multiple of baseCost */
         assert((totalCost & (baseCost - 1)) == 0);
         totalCost >>= (largestBits - maxNbBits);
         assert(totalCost > 0);
-
-        /* repay normalized cost */
-        {   U32 const noSymbol = 0xF0F0F0F0;
-            U32 rankLast[HUF_TABLELOG_MAX+2];
-
+ 
+        /* repay normalized cost */ 
+        {   U32 const noSymbol = 0xF0F0F0F0; 
+            U32 rankLast[HUF_TABLELOG_MAX+2]; 
+ 
             /* Get pos of last (smallest = lowest cum. count) symbol per rank */
             ZSTD_memset(rankLast, 0xF0, sizeof(rankLast));
-            {   U32 currentNbBits = maxNbBits;
+            {   U32 currentNbBits = maxNbBits; 
                 int pos;
-                for (pos=n ; pos >= 0; pos--) {
-                    if (huffNode[pos].nbBits >= currentNbBits) continue;
-                    currentNbBits = huffNode[pos].nbBits;   /* < maxNbBits */
+                for (pos=n ; pos >= 0; pos--) { 
+                    if (huffNode[pos].nbBits >= currentNbBits) continue; 
+                    currentNbBits = huffNode[pos].nbBits;   /* < maxNbBits */ 
                     rankLast[maxNbBits-currentNbBits] = (U32)pos;
-            }   }
-
-            while (totalCost > 0) {
+            }   } 
+ 
+            while (totalCost > 0) { 
                 /* Try to reduce the next power of 2 above totalCost because we
                  * gain back half the rank.
                  */
                 U32 nBitsToDecrease = BIT_highbit32((U32)totalCost) + 1;
-                for ( ; nBitsToDecrease > 1; nBitsToDecrease--) {
+                for ( ; nBitsToDecrease > 1; nBitsToDecrease--) { 
                     U32 const highPos = rankLast[nBitsToDecrease];
                     U32 const lowPos = rankLast[nBitsToDecrease-1];
-                    if (highPos == noSymbol) continue;
+                    if (highPos == noSymbol) continue; 
                     /* Decrease highPos if no symbols of lowPos or if it is
                      * not cheaper to remove 2 lowPos than highPos.
                      */
-                    if (lowPos == noSymbol) break;
-                    {   U32 const highTotal = huffNode[highPos].count;
-                        U32 const lowTotal = 2 * huffNode[lowPos].count;
-                        if (highTotal <= lowTotal) break;
-                }   }
-                /* only triggered when no more rank 1 symbol left => find closest one (note : there is necessarily at least one !) */
+                    if (lowPos == noSymbol) break; 
+                    {   U32 const highTotal = huffNode[highPos].count; 
+                        U32 const lowTotal = 2 * huffNode[lowPos].count; 
+                        if (highTotal <= lowTotal) break; 
+                }   } 
+                /* only triggered when no more rank 1 symbol left => find closest one (note : there is necessarily at least one !) */ 
                 assert(rankLast[nBitsToDecrease] != noSymbol || nBitsToDecrease == 1);
                 /* HUF_MAX_TABLELOG test just to please gcc 5+; but it should not be necessary */
                 while ((nBitsToDecrease<=HUF_TABLELOG_MAX) && (rankLast[nBitsToDecrease] == noSymbol))
                     nBitsToDecrease++;
                 assert(rankLast[nBitsToDecrease] != noSymbol);
                 /* Increase the number of bits to gain back half the rank cost. */
-                totalCost -= 1 << (nBitsToDecrease-1);
+                totalCost -= 1 << (nBitsToDecrease-1); 
                 huffNode[rankLast[nBitsToDecrease]].nbBits++;
 
                 /* Fix up the new rank.
                  * If the new rank was empty, this symbol is now its smallest.
                  * Otherwise, this symbol will be the largest in the new rank so no adjustment.
                  */
-                if (rankLast[nBitsToDecrease-1] == noSymbol)
+                if (rankLast[nBitsToDecrease-1] == noSymbol) 
                     rankLast[nBitsToDecrease-1] = rankLast[nBitsToDecrease];
                 /* Fix up the old rank.
                  * If the symbol was at position 0, meaning it was the highest weight symbol in the tree,
@@ -390,48 +390,48 @@ static U32 HUF_setMaxHeight(nodeElt* huffNode, U32 lastNonNull, U32 maxNbBits)
                  * the smallest node in the rank. If the previous position belongs to a different rank,
                  * then the rank is now empty.
                  */
-                if (rankLast[nBitsToDecrease] == 0)    /* special case, reached largest symbol */
-                    rankLast[nBitsToDecrease] = noSymbol;
-                else {
-                    rankLast[nBitsToDecrease]--;
-                    if (huffNode[rankLast[nBitsToDecrease]].nbBits != maxNbBits-nBitsToDecrease)
-                        rankLast[nBitsToDecrease] = noSymbol;   /* this rank is now empty */
+                if (rankLast[nBitsToDecrease] == 0)    /* special case, reached largest symbol */ 
+                    rankLast[nBitsToDecrease] = noSymbol; 
+                else { 
+                    rankLast[nBitsToDecrease]--; 
+                    if (huffNode[rankLast[nBitsToDecrease]].nbBits != maxNbBits-nBitsToDecrease) 
+                        rankLast[nBitsToDecrease] = noSymbol;   /* this rank is now empty */ 
                 }
             }   /* while (totalCost > 0) */
-
+ 
             /* If we've removed too much weight, then we have to add it back.
              * To avoid overshooting again, we only adjust the smallest rank.
              * We take the largest nodes from the lowest rank 0 and move them
              * to rank 1. There's guaranteed to be enough rank 0 symbols because
              * TODO.
              */
-            while (totalCost < 0) {  /* Sometimes, cost correction overshoot */
+            while (totalCost < 0) {  /* Sometimes, cost correction overshoot */ 
                 /* special case : no rank 1 symbol (using maxNbBits-1);
                  * let's create one from largest rank 0 (using maxNbBits).
                  */
                 if (rankLast[1] == noSymbol) {
-                    while (huffNode[n].nbBits == maxNbBits) n--;
-                    huffNode[n+1].nbBits--;
+                    while (huffNode[n].nbBits == maxNbBits) n--; 
+                    huffNode[n+1].nbBits--; 
                     assert(n >= 0);
                     rankLast[1] = (U32)(n+1);
-                    totalCost++;
-                    continue;
-                }
-                huffNode[ rankLast[1] + 1 ].nbBits--;
-                rankLast[1]++;
-                totalCost ++;
+                    totalCost++; 
+                    continue; 
+                } 
+                huffNode[ rankLast[1] + 1 ].nbBits--; 
+                rankLast[1]++; 
+                totalCost ++; 
             }
         }   /* repay normalized cost */
     }   /* there are several too large elements (at least >= 2) */
-
-    return maxNbBits;
-}
-
-typedef struct {
+ 
+    return maxNbBits; 
+} 
+ 
+typedef struct { 
     U16 base;
     U16 curr;
-} rankPos;
-
+} rankPos; 
+ 
 typedef nodeElt huffNodeTable[HUF_CTABLE_WORKSPACE_SIZE_U32];
 
 /* Number of buckets available for HUF_sort() */
@@ -550,7 +550,7 @@ static void HUF_simpleQuickSort(nodeElt arr[], int low, int high) {
 static void HUF_sort(nodeElt huffNode[], const unsigned count[], U32 const maxSymbolValue, rankPos rankPosition[]) {
     U32 n;
     U32 const maxSymbolValue1 = maxSymbolValue+1;
-
+ 
     /* Compute base and set curr to base.
      * For symbol s let lowerRank = HUF_getIndex(count[n]) and rank = lowerRank + 1.
      * See HUF_getIndex to see bucketing strategy.
@@ -562,7 +562,7 @@ static void HUF_sort(nodeElt huffNode[], const unsigned count[], U32 const maxSy
         U32 lowerRank = HUF_getIndex(count[n]);
         assert(lowerRank < RANK_POSITION_TABLE_SIZE - 1);
         rankPosition[lowerRank].base++;
-    }
+    } 
 
     assert(rankPosition[RANK_POSITION_TABLE_SIZE - 1].base == 0);
     /* Set up the rankPosition table */
@@ -573,13 +573,13 @@ static void HUF_sort(nodeElt huffNode[], const unsigned count[], U32 const maxSy
 
     /* Insert each symbol into their appropriate bucket, setting up rankPosition table. */
     for (n = 0; n < maxSymbolValue1; ++n) {
-        U32 const c = count[n];
+        U32 const c = count[n]; 
         U32 const r = HUF_getIndex(c) + 1;
         U32 const pos = rankPosition[r].curr++;
         assert(pos < maxSymbolValue1);
-        huffNode[pos].count = c;
-        huffNode[pos].byte  = (BYTE)n;
-    }
+        huffNode[pos].count = c; 
+        huffNode[pos].byte  = (BYTE)n; 
+    } 
 
     /* Sort each bucket. */
     for (n = RANK_POSITION_DISTINCT_COUNT_CUTOFF; n < RANK_POSITION_TABLE_SIZE - 1; ++n) {
@@ -592,13 +592,13 @@ static void HUF_sort(nodeElt huffNode[], const unsigned count[], U32 const maxSy
     }
 
     assert(HUF_isSorted(huffNode, maxSymbolValue1));
-}
-
+} 
+ 
 /** HUF_buildCTable_wksp() :
  *  Same as HUF_buildCTable(), but using externally allocated scratch buffer.
  *  `workSpace` must be aligned on 4-bytes boundaries, and be at least as large as sizeof(HUF_buildCTable_wksp_tables).
  */
-#define STARTNODE (HUF_SYMBOLVALUE_MAX+1)
+#define STARTNODE (HUF_SYMBOLVALUE_MAX+1) 
 
 /* HUF_buildTree():
  * Takes the huffNode array sorted by HUF_sort() and builds an unlimited-depth Huffman tree.
@@ -608,38 +608,38 @@ static void HUF_sort(nodeElt huffNode[], const unsigned count[], U32 const maxSy
  * @return                The smallest node in the Huffman tree (by count).
  */
 static int HUF_buildTree(nodeElt* huffNode, U32 maxSymbolValue)
-{
+{ 
     nodeElt* const huffNode0 = huffNode - 1;
     int nonNullRank;
-    int lowS, lowN;
+    int lowS, lowN; 
     int nodeNb = STARTNODE;
     int n, nodeRoot;
-    /* init for parents */
+    /* init for parents */ 
     nonNullRank = (int)maxSymbolValue;
-    while(huffNode[nonNullRank].count == 0) nonNullRank--;
-    lowS = nonNullRank; nodeRoot = nodeNb + lowS - 1; lowN = nodeNb;
-    huffNode[nodeNb].count = huffNode[lowS].count + huffNode[lowS-1].count;
+    while(huffNode[nonNullRank].count == 0) nonNullRank--; 
+    lowS = nonNullRank; nodeRoot = nodeNb + lowS - 1; lowN = nodeNb; 
+    huffNode[nodeNb].count = huffNode[lowS].count + huffNode[lowS-1].count; 
     huffNode[lowS].parent = huffNode[lowS-1].parent = (U16)nodeNb;
-    nodeNb++; lowS-=2;
-    for (n=nodeNb; n<=nodeRoot; n++) huffNode[n].count = (U32)(1U<<30);
+    nodeNb++; lowS-=2; 
+    for (n=nodeNb; n<=nodeRoot; n++) huffNode[n].count = (U32)(1U<<30); 
     huffNode0[0].count = (U32)(1U<<31);  /* fake entry, strong barrier */
-
-    /* create parents */
-    while (nodeNb <= nodeRoot) {
+ 
+    /* create parents */ 
+    while (nodeNb <= nodeRoot) { 
         int const n1 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++;
         int const n2 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++;
-        huffNode[nodeNb].count = huffNode[n1].count + huffNode[n2].count;
+        huffNode[nodeNb].count = huffNode[n1].count + huffNode[n2].count; 
         huffNode[n1].parent = huffNode[n2].parent = (U16)nodeNb;
-        nodeNb++;
-    }
-
-    /* distribute weights (unlimited tree height) */
-    huffNode[nodeRoot].nbBits = 0;
-    for (n=nodeRoot-1; n>=STARTNODE; n--)
-        huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1;
-    for (n=0; n<=nonNullRank; n++)
-        huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1;
-
+        nodeNb++; 
+    } 
+ 
+    /* distribute weights (unlimited tree height) */ 
+    huffNode[nodeRoot].nbBits = 0; 
+    for (n=nodeRoot-1; n>=STARTNODE; n--) 
+        huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1; 
+    for (n=0; n<=nonNullRank; n++) 
+        huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1; 
+ 
     return nonNullRank;
 }
 
@@ -698,17 +698,17 @@ size_t HUF_buildCTable_wksp (HUF_CElt* CTable, const unsigned* count, U32 maxSym
     /* build tree */
     nonNullRank = HUF_buildTree(huffNode, maxSymbolValue);
 
-    /* enforce maxTableLog */
+    /* enforce maxTableLog */ 
     maxNbBits = HUF_setMaxHeight(huffNode, (U32)nonNullRank, maxNbBits);
     if (maxNbBits > HUF_TABLELOG_MAX) return ERROR(GENERIC);   /* check fit into table */
-
+ 
     HUF_buildCTableFromTree(CTable, huffNode, nonNullRank, maxSymbolValue, maxNbBits);
-
-    return maxNbBits;
-}
-
+ 
+    return maxNbBits; 
+} 
+ 
 size_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue)
-{
+{ 
     HUF_CElt const* ct = CTable + 1;
     size_t nbBits = 0;
     int s;
@@ -716,8 +716,8 @@ size_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count,
         nbBits += HUF_getNbBits(ct[s]) * count[s];
     }
     return nbBits >> 3;
-}
-
+} 
+ 
 int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue) {
   HUF_CElt const* ct = CTable + 1;
   int bad = 0;
@@ -728,8 +728,8 @@ int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned m
   return !bad;
 }
 
-size_t HUF_compressBound(size_t size) { return HUF_COMPRESSBOUND(size); }
-
+size_t HUF_compressBound(size_t size) { return HUF_COMPRESSBOUND(size); } 
+ 
 /** HUF_CStream_t:
  * Huffman uses its own BIT_CStream_t implementation.
  * There are three major differences from BIT_CStream_t:
@@ -896,7 +896,7 @@ HUF_encodeSymbol(HUF_CStream_t* bitCPtr, U32 symbol, const HUF_CElt* CTable, int
 {
     HUF_addBits(bitCPtr, CTable[symbol], idx, fast);
 }
-
+ 
 FORCE_INLINE_TEMPLATE void
 HUF_compress1X_usingCTable_internal_body_loop(HUF_CStream_t* bitC,
                                    const BYTE* ip, size_t srcSize,
@@ -925,7 +925,7 @@ HUF_compress1X_usingCTable_internal_body_loop(HUF_CStream_t* bitC,
         n -= kUnroll;
     }
     assert(n % (2 * kUnroll) == 0);
-
+ 
     for (; n>0; n-= 2 * kUnroll) {
         /* Encode kUnroll symbols into the bitstream @ index 0. */
         int u;
@@ -948,7 +948,7 @@ HUF_compress1X_usingCTable_internal_body_loop(HUF_CStream_t* bitC,
         HUF_flushBits(bitC, kFastFlush);
     }
     assert(n == 0);
-
+ 
 }
 
 /**
@@ -966,20 +966,20 @@ FORCE_INLINE_TEMPLATE size_t
 HUF_compress1X_usingCTable_internal_body(void* dst, size_t dstSize,
                                    const void* src, size_t srcSize,
                                    const HUF_CElt* CTable)
-{
+{ 
     U32 const tableLog = (U32)CTable[0];
     HUF_CElt const* ct = CTable + 1;
-    const BYTE* ip = (const BYTE*) src;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + dstSize;
-    BYTE* op = ostart;
+    const BYTE* ip = (const BYTE*) src; 
+    BYTE* const ostart = (BYTE*)dst; 
+    BYTE* const oend = ostart + dstSize; 
+    BYTE* op = ostart; 
     HUF_CStream_t bitC;
-
-    /* init */
-    if (dstSize < 8) return 0;   /* not enough space to compress */
+ 
+    /* init */ 
+    if (dstSize < 8) return 0;   /* not enough space to compress */ 
     { size_t const initErr = HUF_initCStream(&bitC, op, (size_t)(oend-op));
       if (HUF_isError(initErr)) return 0; }
-
+ 
     if (dstSize < HUF_tightCompressBound(srcSize, (size_t)tableLog) || tableLog > 11)
         HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ MEM_32bits() ? 2 : 4, /* kFast */ 0, /* kLastFast */ 0);
     else {
@@ -1021,19 +1021,19 @@ HUF_compress1X_usingCTable_internal_body(void* dst, size_t dstSize,
                 break;
             }
         }
-    }
+    } 
     assert(bitC.ptr <= bitC.endPtr);
-
+ 
     return HUF_closeCStream(&bitC);
-}
-
+} 
+ 
 #if DYNAMIC_BMI2
-
+ 
 static BMI2_TARGET_ATTRIBUTE size_t
 HUF_compress1X_usingCTable_internal_bmi2(void* dst, size_t dstSize,
                                    const void* src, size_t srcSize,
                                    const HUF_CElt* CTable)
-{
+{ 
     return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);
 }
 
@@ -1084,56 +1084,56 @@ HUF_compress4X_usingCTable_internal(void* dst, size_t dstSize,
                               const void* src, size_t srcSize,
                               const HUF_CElt* CTable, int bmi2)
 {
-    size_t const segmentSize = (srcSize+3)/4;   /* first 3 segments */
-    const BYTE* ip = (const BYTE*) src;
-    const BYTE* const iend = ip + srcSize;
-    BYTE* const ostart = (BYTE*) dst;
-    BYTE* const oend = ostart + dstSize;
-    BYTE* op = ostart;
-
-    if (dstSize < 6 + 1 + 1 + 1 + 8) return 0;   /* minimum space to compress successfully */
-    if (srcSize < 12) return 0;   /* no saving possible : too small input */
-    op += 6;   /* jumpTable */
-
+    size_t const segmentSize = (srcSize+3)/4;   /* first 3 segments */ 
+    const BYTE* ip = (const BYTE*) src; 
+    const BYTE* const iend = ip + srcSize; 
+    BYTE* const ostart = (BYTE*) dst; 
+    BYTE* const oend = ostart + dstSize; 
+    BYTE* op = ostart; 
+ 
+    if (dstSize < 6 + 1 + 1 + 1 + 8) return 0;   /* minimum space to compress successfully */ 
+    if (srcSize < 12) return 0;   /* no saving possible : too small input */ 
+    op += 6;   /* jumpTable */ 
+ 
     assert(op <= oend);
     {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, segmentSize, CTable, bmi2) );
         if (cSize == 0 || cSize > 65535) return 0;
-        MEM_writeLE16(ostart, (U16)cSize);
-        op += cSize;
-    }
-
-    ip += segmentSize;
+        MEM_writeLE16(ostart, (U16)cSize); 
+        op += cSize; 
+    } 
+ 
+    ip += segmentSize; 
     assert(op <= oend);
     {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, segmentSize, CTable, bmi2) );
         if (cSize == 0 || cSize > 65535) return 0;
-        MEM_writeLE16(ostart+2, (U16)cSize);
-        op += cSize;
-    }
-
-    ip += segmentSize;
+        MEM_writeLE16(ostart+2, (U16)cSize); 
+        op += cSize; 
+    } 
+ 
+    ip += segmentSize; 
     assert(op <= oend);
     {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, segmentSize, CTable, bmi2) );
         if (cSize == 0 || cSize > 65535) return 0;
-        MEM_writeLE16(ostart+4, (U16)cSize);
-        op += cSize;
-    }
-
-    ip += segmentSize;
+        MEM_writeLE16(ostart+4, (U16)cSize); 
+        op += cSize; 
+    } 
+ 
+    ip += segmentSize; 
     assert(op <= oend);
     assert(ip <= iend);
     {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, (size_t)(iend-ip), CTable, bmi2) );
         if (cSize == 0 || cSize > 65535) return 0;
-        op += cSize;
-    }
-
+        op += cSize; 
+    } 
+ 
     return (size_t)(op-ostart);
-}
-
+} 
+ 
 size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable)
 {
     return HUF_compress4X_usingCTable_bmi2(dst, dstSize, src, srcSize, CTable, /* bmi2 */ 0);
 }
-
+ 
 size_t HUF_compress4X_usingCTable_bmi2(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int bmi2)
 {
     return HUF_compress4X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, bmi2);
@@ -1182,24 +1182,24 @@ HUF_compress_internal (void* dst, size_t dstSize,
                        void* workSpace, size_t wkspSize,
                        HUF_CElt* oldHufTable, HUF_repeat* repeat, int preferRepeat,
                  const int bmi2, unsigned suspectUncompressible)
-{
+{ 
     HUF_compress_tables_t* const table = (HUF_compress_tables_t*)HUF_alignUpWorkspace(workSpace, &wkspSize, ZSTD_ALIGNOF(size_t));
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + dstSize;
-    BYTE* op = ostart;
-
+    BYTE* const ostart = (BYTE*)dst; 
+    BYTE* const oend = ostart + dstSize; 
+    BYTE* op = ostart; 
+ 
     HUF_STATIC_ASSERT(sizeof(*table) + HUF_WORKSPACE_MAX_ALIGNMENT <= HUF_WORKSPACE_SIZE);
 
-    /* checks & inits */
+    /* checks & inits */ 
     if (wkspSize < sizeof(*table)) return ERROR(workSpace_tooSmall);
     if (!srcSize) return 0;  /* Uncompressed */
     if (!dstSize) return 0;  /* cannot fit anything within dst budget */
-    if (srcSize > HUF_BLOCKSIZE_MAX) return ERROR(srcSize_wrong);   /* current block size limit */
-    if (huffLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
+    if (srcSize > HUF_BLOCKSIZE_MAX) return ERROR(srcSize_wrong);   /* current block size limit */ 
+    if (huffLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge); 
     if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);
-    if (!maxSymbolValue) maxSymbolValue = HUF_SYMBOLVALUE_MAX;
-    if (!huffLog) huffLog = HUF_TABLELOG_DEFAULT;
-
+    if (!maxSymbolValue) maxSymbolValue = HUF_SYMBOLVALUE_MAX; 
+    if (!huffLog) huffLog = HUF_TABLELOG_DEFAULT; 
+ 
     /* Heuristic : If old table is valid, use it for small inputs */
     if (preferRepeat && repeat && *repeat == HUF_repeat_valid) {
         return HUF_compressCTable_internal(ostart, op, oend,
@@ -1222,12 +1222,12 @@ HUF_compress_internal (void* dst, size_t dstSize,
         if (largestTotal <= ((2 * SUSPECT_INCOMPRESSIBLE_SAMPLE_SIZE) >> 7)+4) return 0;   /* heuristic : probably not compressible enough */
     }
 
-    /* Scan input and build symbol stats */
+    /* Scan input and build symbol stats */ 
     {   CHECK_V_F(largest, HIST_count_wksp (table->count, &maxSymbolValue, (const BYTE*)src, srcSize, table->wksps.hist_wksp, sizeof(table->wksps.hist_wksp)) );
         if (largest == srcSize) { *ostart = ((const BYTE*)src)[0]; return 1; }   /* single symbol, rle */
         if (largest <= (srcSize >> 7)+4) return 0;   /* heuristic : probably not compressible enough */
-    }
-
+    } 
+ 
     /* Check validity of previous table */
     if ( repeat
       && *repeat == HUF_repeat_check
@@ -1241,22 +1241,22 @@ HUF_compress_internal (void* dst, size_t dstSize,
                                            nbStreams, oldHufTable, bmi2);
     }
 
-    /* Build Huffman Tree */
-    huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue);
+    /* Build Huffman Tree */ 
+    huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue); 
     {   size_t const maxBits = HUF_buildCTable_wksp(table->CTable, table->count,
                                             maxSymbolValue, huffLog,
                                             &table->wksps.buildCTable_wksp, sizeof(table->wksps.buildCTable_wksp));
         CHECK_F(maxBits);
-        huffLog = (U32)maxBits;
-    }
+        huffLog = (U32)maxBits; 
+    } 
     /* Zero unused symbols in CTable, so we can check it for validity */
     {
         size_t const ctableSize = HUF_CTABLE_SIZE_ST(maxSymbolValue);
         size_t const unusedSize = sizeof(table->CTable) - ctableSize * sizeof(HUF_CElt);
         ZSTD_memset(table->CTable + ctableSize, 0, unusedSize);
     }
-
-    /* Write table description header */
+ 
+    /* Write table description header */ 
     {   CHECK_V_F(hSize, HUF_writeCTable_wksp(op, dstSize, table->CTable, maxSymbolValue, huffLog,
                                               &table->wksps.writeCTable_wksp, sizeof(table->wksps.writeCTable_wksp)) );
         /* Check if using previous huffman table is beneficial */
@@ -1271,17 +1271,17 @@ HUF_compress_internal (void* dst, size_t dstSize,
 
         /* Use the new huffman table */
         if (hSize + 12ul >= srcSize) { return 0; }
-        op += hSize;
+        op += hSize; 
         if (repeat) { *repeat = HUF_repeat_none; }
         if (oldHufTable)
             ZSTD_memcpy(oldHufTable, table->CTable, sizeof(table->CTable));  /* Save new table */
-    }
+    } 
     return HUF_compressCTable_internal(ostart, op, oend,
                                        src, srcSize,
                                        nbStreams, table->CTable, bmi2);
-}
-
-
+} 
+ 
+ 
 size_t HUF_compress1X_wksp (void* dst, size_t dstSize,
                       const void* src, size_t srcSize,
                       unsigned maxSymbolValue, unsigned huffLog,
@@ -1355,16 +1355,16 @@ size_t HUF_compress1X (void* dst, size_t dstSize,
     return HUF_compress1X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace));
 }
 
-size_t HUF_compress2 (void* dst, size_t dstSize,
-                const void* src, size_t srcSize,
-                unsigned maxSymbolValue, unsigned huffLog)
-{
+size_t HUF_compress2 (void* dst, size_t dstSize, 
+                const void* src, size_t srcSize, 
+                unsigned maxSymbolValue, unsigned huffLog) 
+{ 
     U64 workSpace[HUF_WORKSPACE_SIZE_U64];
     return HUF_compress4X_wksp(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, workSpace, sizeof(workSpace));
-}
-
-size_t HUF_compress (void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
+} 
+ 
+size_t HUF_compress (void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
     return HUF_compress2(dst, maxDstSize, src, srcSize, 255, HUF_TABLELOG_DEFAULT);
-}
+} 
 #endif
diff --git a/contrib/libs/zstd/lib/compress/zstd_compress.c b/contrib/libs/zstd/lib/compress/zstd_compress.c
index f06456af92..0e8f184472 100644
--- a/contrib/libs/zstd/lib/compress/zstd_compress.c
+++ b/contrib/libs/zstd/lib/compress/zstd_compress.c
@@ -7,16 +7,16 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-/*-*************************************
-*  Dependencies
-***************************************/
+ 
+/*-************************************* 
+*  Dependencies 
+***************************************/ 
 #include "../common/zstd_deps.h"  /* INT_MAX, ZSTD_memset, ZSTD_memcpy */
 #include "../common/mem.h"
 #include "hist.h"           /* HIST_countFast_wksp */
 #define FSE_STATIC_LINKING_ONLY   /* FSE_encodeSymbol */
 #include "../common/fse.h"
-#define HUF_STATIC_LINKING_ONLY
+#define HUF_STATIC_LINKING_ONLY 
 #include "../common/huf.h"
 #include "zstd_compress_internal.h"
 #include "zstd_compress_sequences.h"
@@ -27,7 +27,7 @@
 #include "zstd_opt.h"
 #include "zstd_ldm.h"
 #include "zstd_compress_superblock.h"
-
+ 
 /* ***************************************************************
 *  Tuning parameters
 *****************************************************************/
@@ -40,7 +40,7 @@
 #ifndef ZSTD_COMPRESS_HEAPMODE
 #  define ZSTD_COMPRESS_HEAPMODE 0
 #endif
-
+ 
 /*!
  * ZSTD_HASHLOG3_MAX :
  * Maximum size of the hash table dedicated to find 3-bytes matches,
@@ -54,9 +54,9 @@
 #  define ZSTD_HASHLOG3_MAX 17
 #endif
 
-/*-*************************************
-*  Helper functions
-***************************************/
+/*-************************************* 
+*  Helper functions 
+***************************************/ 
 /* ZSTD_compressBound()
  * Note that the result from this function is only compatible with the "normal"
  * full-block strategy.
@@ -66,12 +66,12 @@
  */
 size_t ZSTD_compressBound(size_t srcSize) {
     return ZSTD_COMPRESSBOUND(srcSize);
-}
-
-
-/*-*************************************
-*  Context memory management
-***************************************/
+} 
+ 
+ 
+/*-************************************* 
+*  Context memory management 
+***************************************/ 
 struct ZSTD_CDict_s {
     const void* dictContent;
     size_t dictContentSize;
@@ -80,7 +80,7 @@ struct ZSTD_CDict_s {
     ZSTD_cwksp workspace;
     ZSTD_matchState_t matchState;
     ZSTD_compressedBlockState_t cBlockState;
-    ZSTD_customMem customMem;
+    ZSTD_customMem customMem; 
     U32 dictID;
     int compressionLevel; /* 0 indicates that advanced API was used to select CDict params */
     ZSTD_paramSwitch_e useRowMatchFinder; /* Indicates whether the CDict was created with params that would use
@@ -88,12 +88,12 @@ struct ZSTD_CDict_s {
                                            * the same greedy/lazy matchfinder at compression time.
                                            */
 };  /* typedef'd to ZSTD_CDict within "zstd.h" */
-
-ZSTD_CCtx* ZSTD_createCCtx(void)
-{
+ 
+ZSTD_CCtx* ZSTD_createCCtx(void) 
+{ 
     return ZSTD_createCCtx_advanced(ZSTD_defaultCMem);
-}
-
+} 
+ 
 static void ZSTD_initCCtx(ZSTD_CCtx* cctx, ZSTD_customMem memManager)
 {
     assert(cctx != NULL);
@@ -106,8 +106,8 @@ static void ZSTD_initCCtx(ZSTD_CCtx* cctx, ZSTD_customMem memManager)
     }
 }
 
-ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem)
-{
+ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem) 
+{ 
     ZSTD_STATIC_ASSERT(zcss_init==0);
     ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN==(0ULL - 1));
     if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;
@@ -117,7 +117,7 @@ ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem)
         return cctx;
     }
 }
-
+ 
 ZSTD_CCtx* ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize)
 {
     ZSTD_cwksp ws;
@@ -132,21 +132,21 @@ ZSTD_CCtx* ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize)
     ZSTD_memset(cctx, 0, sizeof(ZSTD_CCtx));
     ZSTD_cwksp_move(&cctx->workspace, &ws);
     cctx->staticSize = workspaceSize;
-
+ 
     /* statically sized space. entropyWorkspace never moves (but prev/next block swap places) */
     if (!ZSTD_cwksp_check_available(&cctx->workspace, ENTROPY_WORKSPACE_SIZE + 2 * sizeof(ZSTD_compressedBlockState_t))) return NULL;
     cctx->blockState.prevCBlock = (ZSTD_compressedBlockState_t*)ZSTD_cwksp_reserve_object(&cctx->workspace, sizeof(ZSTD_compressedBlockState_t));
     cctx->blockState.nextCBlock = (ZSTD_compressedBlockState_t*)ZSTD_cwksp_reserve_object(&cctx->workspace, sizeof(ZSTD_compressedBlockState_t));
     cctx->entropyWorkspace = (U32*)ZSTD_cwksp_reserve_object(&cctx->workspace, ENTROPY_WORKSPACE_SIZE);
     cctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid());
-    return cctx;
-}
-
+    return cctx; 
+} 
+ 
 /**
  * Clears and frees all of the dictionaries in the CCtx.
  */
 static void ZSTD_clearAllDicts(ZSTD_CCtx* cctx)
-{
+{ 
     ZSTD_customFree(cctx->localDict.dictBuffer, cctx->customMem);
     ZSTD_freeCDict(cctx->localDict.cdict);
     ZSTD_memset(&cctx->localDict, 0, sizeof(cctx->localDict));
@@ -185,8 +185,8 @@ size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx)
         }
     }
     return 0;
-}
-
+} 
+ 
 
 static size_t ZSTD_sizeof_mtctx(const ZSTD_CCtx* cctx)
 {
@@ -200,20 +200,20 @@ static size_t ZSTD_sizeof_mtctx(const ZSTD_CCtx* cctx)
 
 
 size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx)
-{
+{ 
     if (cctx==NULL) return 0;   /* support sizeof on NULL */
     /* cctx may be in the workspace */
     return (cctx->workspace.workspace == cctx ? 0 : sizeof(*cctx))
            + ZSTD_cwksp_sizeof(&cctx->workspace)
            + ZSTD_sizeof_localDict(cctx->localDict)
            + ZSTD_sizeof_mtctx(cctx);
-}
-
+} 
+ 
 size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs)
-{
+{ 
     return ZSTD_sizeof_CCtx(zcs);  /* same object */
-}
-
+} 
+ 
 /* private API call, for dictBuilder only */
 const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx) { return &(ctx->seqStore); }
 
@@ -297,7 +297,7 @@ static ZSTD_CCtx_params ZSTD_makeCCtxParamsFromCParams(
     assert(!ZSTD_checkCParams(cParams));
     return cctxParams;
 }
-
+ 
 static ZSTD_CCtx_params* ZSTD_createCCtxParams_advanced(
         ZSTD_customMem customMem)
 {
@@ -1228,9 +1228,9 @@ size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset)
 
 /** ZSTD_checkCParams() :
     control CParam 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)
-{
+    @return : 0, or an error code if one value is beyond authorized range */ 
+size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams) 
+{ 
     BOUNDCHECK(ZSTD_c_windowLog, (int)cParams.windowLog);
     BOUNDCHECK(ZSTD_c_chainLog,  (int)cParams.chainLog);
     BOUNDCHECK(ZSTD_c_hashLog,   (int)cParams.hashLog);
@@ -1238,9 +1238,9 @@ size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
     BOUNDCHECK(ZSTD_c_minMatch,  (int)cParams.minMatch);
     BOUNDCHECK(ZSTD_c_targetLength,(int)cParams.targetLength);
     BOUNDCHECK(ZSTD_c_strategy,  cParams.strategy);
-    return 0;
-}
-
+    return 0; 
+} 
+ 
 /** ZSTD_clampCParams() :
  *  make CParam values within valid range.
  *  @return : valid CParams */
@@ -1262,15 +1262,15 @@ ZSTD_clampCParams(ZSTD_compressionParameters cParams)
     CLAMP_TYPE(ZSTD_c_strategy,cParams.strategy, ZSTD_strategy);
     return cParams;
 }
-
+ 
 /** ZSTD_cycleLog() :
  *  condition for correct operation : hashLog > 1 */
 U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat)
-{
+{ 
     U32 const btScale = ((U32)strat >= (U32)ZSTD_btlazy2);
     return hashLog - btScale;
-}
-
+} 
+ 
 /** ZSTD_dictAndWindowLog() :
  * Returns an adjusted window log that is large enough to fit the source and the dictionary.
  * The zstd format says that the entire dictionary is valid if one byte of the dictionary
@@ -1317,11 +1317,11 @@ ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,
                             unsigned long long srcSize,
                             size_t dictSize,
                             ZSTD_cParamMode_e mode)
-{
+{ 
     const U64 minSrcSize = 513; /* (1<<9) + 1 */
     const U64 maxWindowResize = 1ULL << (ZSTD_WINDOWLOG_MAX-1);
     assert(ZSTD_checkCParams(cPar)==0);
-
+ 
     switch (mode) {
     case ZSTD_cpm_unknown:
     case ZSTD_cpm_noAttachDict:
@@ -1365,13 +1365,13 @@ ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,
         if (cycleLog > dictAndWindowLog)
             cPar.chainLog -= (cycleLog - dictAndWindowLog);
     }
-
+ 
     if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN)
         cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* minimum wlog required for valid frame header */
-
-    return cPar;
-}
-
+ 
+    return cPar; 
+} 
+ 
 ZSTD_compressionParameters
 ZSTD_adjustCParams(ZSTD_compressionParameters cPar,
                    unsigned long long srcSize,
@@ -1454,7 +1454,7 @@ ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams,
                 (U32)chainSize, (U32)hSize, (U32)h3Size);
     return tableSpace + optSpace + slackSpace + lazyAdditionalSpace;
 }
-
+ 
 static size_t ZSTD_estimateCCtxSize_usingCCtxParams_internal(
         const ZSTD_compressionParameters* cParams,
         const ldmParams_t* ldmParams,
@@ -1474,7 +1474,7 @@ static size_t ZSTD_estimateCCtxSize_usingCCtxParams_internal(
     size_t const entropySpace = ZSTD_cwksp_alloc_size(ENTROPY_WORKSPACE_SIZE);
     size_t const blockStateSpace = 2 * ZSTD_cwksp_alloc_size(sizeof(ZSTD_compressedBlockState_t));
     size_t const matchStateSize = ZSTD_sizeof_matchState(cParams, useRowMatchFinder, /* enableDedicatedDictSearch */ 0, /* forCCtx */ 1);
-
+ 
     size_t const ldmSpace = ZSTD_ldm_getTableSize(*ldmParams);
     size_t const maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq(*ldmParams, blockSize);
     size_t const ldmSeqSpace = ldmParams->enableLdm == ZSTD_ps_enable ?
@@ -1498,8 +1498,8 @@ static size_t ZSTD_estimateCCtxSize_usingCCtxParams_internal(
 
     DEBUGLOG(5, "estimate workspace : %u", (U32)neededSpace);
     return neededSpace;
-}
-
+} 
+ 
 size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params)
 {
     ZSTD_compressionParameters const cParams =
@@ -1734,7 +1734,7 @@ ZSTD_reset_matchState(ZSTD_matchState_t* ms,
     size_t const hSize = ((size_t)1) << cParams->hashLog;
     U32    const hashLog3 = ((forWho == ZSTD_resetTarget_CCtx) && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
     size_t const h3Size = hashLog3 ? ((size_t)1) << hashLog3 : 0;
-
+ 
     DEBUGLOG(4, "reset indices : %u", forceResetIndex == ZSTDirp_reset);
     assert(useRowMatchFinder != ZSTD_ps_auto);
     if (forceResetIndex == ZSTDirp_reset) {
@@ -1865,7 +1865,7 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
                 ? windowSize + blockSize
                 : 0;
         size_t const maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq(params->ldmParams, blockSize);
-
+ 
         int const indexTooClose = ZSTD_indexTooCloseToMax(zc->blockState.matchState.window);
         int const dictTooBig = ZSTD_dictTooBig(loadedDictSize);
         ZSTD_indexResetPolicy_e needsIndexReset =
@@ -1912,7 +1912,7 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
                 zc->entropyWorkspace = (U32*) ZSTD_cwksp_reserve_object(ws, ENTROPY_WORKSPACE_SIZE);
                 RETURN_ERROR_IF(zc->entropyWorkspace == NULL, memory_allocation, "couldn't allocate entropyWorkspace");
         }   }
-
+ 
         ZSTD_cwksp_clear(ws);
 
         /* init params */
@@ -1930,15 +1930,15 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
         zc->stage = ZSTDcs_init;
         zc->dictID = 0;
         zc->dictContentSize = 0;
-
+ 
         ZSTD_reset_compressedBlockState(zc->blockState.prevCBlock);
-
+ 
         /* ZSTD_wildcopy() is used to copy into the literals buffer,
          * so we have to oversize the buffer by WILDCOPY_OVERLENGTH bytes.
          */
         zc->seqStore.litStart = ZSTD_cwksp_reserve_buffer(ws, blockSize + WILDCOPY_OVERLENGTH);
         zc->seqStore.maxNbLit = blockSize;
-
+ 
         /* buffers */
         zc->bufferedPolicy = zbuff;
         zc->inBuffSize = buffInSize;
@@ -1993,8 +1993,8 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
 
         return 0;
     }
-}
-
+} 
+ 
 /* ZSTD_invalidateRepCodes() :
  * ensures next compression will not use repcodes from previous block.
  * Note : only works with regular variant;
@@ -2004,7 +2004,7 @@ void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx) {
     for (i=0; i<ZSTD_REP_NUM; i++) cctx->blockState.prevCBlock->rep[i] = 0;
     assert(!ZSTD_window_hasExtDict(cctx->blockState.matchState.window));
 }
-
+ 
 /* These are the approximate sizes for each strategy past which copying the
  * dictionary tables into the working context is faster than using them
  * in-place.
@@ -2103,7 +2103,7 @@ static size_t ZSTD_resetCCtx_byCopyingCDict(ZSTD_CCtx* cctx,
                             ZSTD_CCtx_params params,
                             U64 pledgedSrcSize,
                             ZSTD_buffered_policy_e zbuff)
-{
+{ 
     const ZSTD_compressionParameters *cdict_cParams = &cdict->matchState.cParams;
 
     assert(!cdict->matchState.dedicatedDictSearch);
@@ -2235,10 +2235,10 @@ static size_t ZSTD_copyCCtx_internal(ZSTD_CCtx* dstCCtx,
         assert(dstCCtx->appliedParams.cParams.chainLog == srcCCtx->appliedParams.cParams.chainLog);
         assert(dstCCtx->blockState.matchState.hashLog3 == srcCCtx->blockState.matchState.hashLog3);
     }
-
+ 
     ZSTD_cwksp_mark_tables_dirty(&dstCCtx->workspace);
 
-    /* copy tables */
+    /* copy tables */ 
     {   size_t const chainSize = ZSTD_allocateChainTable(srcCCtx->appliedParams.cParams.strategy,
                                                          srcCCtx->appliedParams.useRowMatchFinder,
                                                          0 /* forDDSDict */)
@@ -2257,27 +2257,27 @@ static size_t ZSTD_copyCCtx_internal(ZSTD_CCtx* dstCCtx,
         ZSTD_memcpy(dstCCtx->blockState.matchState.hashTable3,
                srcCCtx->blockState.matchState.hashTable3,
                h3Size * sizeof(U32));
-    }
-
+    } 
+ 
     ZSTD_cwksp_mark_tables_clean(&dstCCtx->workspace);
 
-    /* copy dictionary offsets */
+    /* copy dictionary offsets */ 
     {
         const ZSTD_matchState_t* srcMatchState = &srcCCtx->blockState.matchState;
         ZSTD_matchState_t* dstMatchState = &dstCCtx->blockState.matchState;
         dstMatchState->window       = srcMatchState->window;
         dstMatchState->nextToUpdate = srcMatchState->nextToUpdate;
         dstMatchState->loadedDictEnd= srcMatchState->loadedDictEnd;
-    }
+    } 
     dstCCtx->dictID = srcCCtx->dictID;
     dstCCtx->dictContentSize = srcCCtx->dictContentSize;
-
+ 
     /* copy block state */
     ZSTD_memcpy(dstCCtx->blockState.prevCBlock, srcCCtx->blockState.prevCBlock, sizeof(*srcCCtx->blockState.prevCBlock));
 
-    return 0;
-}
-
+    return 0; 
+} 
+ 
 /*! ZSTD_copyCCtx() :
  *  Duplicate an existing context `srcCCtx` into another one `dstCCtx`.
  *  Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()).
@@ -2290,7 +2290,7 @@ size_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx, unsigned long
     ZSTD_STATIC_ASSERT((U32)ZSTDb_buffered==1);
     if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;
     fParams.contentSizeFlag = (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN);
-
+ 
     return ZSTD_copyCCtx_internal(dstCCtx, srcCCtx,
                                 fParams, pledgedSrcSize,
                                 zbuff);
@@ -2298,7 +2298,7 @@ size_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx, unsigned long
 
 
 #define ZSTD_ROWSIZE 16
-/*! ZSTD_reduceTable() :
+/*! ZSTD_reduceTable() : 
  *  reduce table indexes by `reducerValue`, or squash to zero.
  *  PreserveMark preserves "unsorted mark" for btlazy2 strategy.
  *  It must be set to a clear 0/1 value, to remove branch during inlining.
@@ -2306,7 +2306,7 @@ size_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx, unsigned long
  *  to help auto-vectorization */
 FORCE_INLINE_TEMPLATE void
 ZSTD_reduceTable_internal (U32* const table, U32 const size, U32 const reducerValue, int const preserveMark)
-{
+{ 
     int const nbRows = (int)size / ZSTD_ROWSIZE;
     int cellNb = 0;
     int rowNb;
@@ -2344,8 +2344,8 @@ ZSTD_reduceTable_internal (U32* const table, U32 const size, U32 const reducerVa
             table[cellNb] = newVal;
             cellNb++;
     }   }
-}
-
+} 
+ 
 static void ZSTD_reduceTable(U32* const table, U32 const size, U32 const reducerValue)
 {
     ZSTD_reduceTable_internal(table, size, reducerValue, 0);
@@ -2356,14 +2356,14 @@ static void ZSTD_reduceTable_btlazy2(U32* const table, U32 const size, U32 const
     ZSTD_reduceTable_internal(table, size, reducerValue, 1);
 }
 
-/*! ZSTD_reduceIndex() :
-*   rescale all indexes to avoid future overflow (indexes are U32) */
+/*! ZSTD_reduceIndex() : 
+*   rescale all indexes to avoid future overflow (indexes are U32) */ 
 static void ZSTD_reduceIndex (ZSTD_matchState_t* ms, ZSTD_CCtx_params const* params, const U32 reducerValue)
-{
+{ 
     {   U32 const hSize = (U32)1 << params->cParams.hashLog;
         ZSTD_reduceTable(ms->hashTable, hSize, reducerValue);
     }
-
+ 
     if (ZSTD_allocateChainTable(params->cParams.strategy, params->useRowMatchFinder, (U32)ms->dedicatedDictSearch)) {
         U32 const chainSize = (U32)1 << params->cParams.chainLog;
         if (params->cParams.strategy == ZSTD_btlazy2)
@@ -2371,48 +2371,48 @@ static void ZSTD_reduceIndex (ZSTD_matchState_t* ms, ZSTD_CCtx_params const* par
         else
             ZSTD_reduceTable(ms->chainTable, chainSize, reducerValue);
     }
-
+ 
     if (ms->hashLog3) {
         U32 const h3Size = (U32)1 << ms->hashLog3;
         ZSTD_reduceTable(ms->hashTable3, h3Size, reducerValue);
     }
-}
-
-
-/*-*******************************************************
-*  Block entropic compression
-*********************************************************/
-
+} 
+ 
+ 
+/*-******************************************************* 
+*  Block entropic compression 
+*********************************************************/ 
+ 
 /* See doc/zstd_compression_format.md for detailed format description */
-
-void ZSTD_seqToCodes(const seqStore_t* seqStorePtr)
-{
-    const seqDef* const sequences = seqStorePtr->sequencesStart;
-    BYTE* const llCodeTable = seqStorePtr->llCode;
-    BYTE* const ofCodeTable = seqStorePtr->ofCode;
-    BYTE* const mlCodeTable = seqStorePtr->mlCode;
-    U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-    U32 u;
+ 
+void ZSTD_seqToCodes(const seqStore_t* seqStorePtr) 
+{ 
+    const seqDef* const sequences = seqStorePtr->sequencesStart; 
+    BYTE* const llCodeTable = seqStorePtr->llCode; 
+    BYTE* const ofCodeTable = seqStorePtr->ofCode; 
+    BYTE* const mlCodeTable = seqStorePtr->mlCode; 
+    U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart); 
+    U32 u; 
     assert(nbSeq <= seqStorePtr->maxNbSeq);
-    for (u=0; u<nbSeq; u++) {
-        U32 const llv = sequences[u].litLength;
+    for (u=0; u<nbSeq; u++) { 
+        U32 const llv = sequences[u].litLength; 
         U32 const mlv = sequences[u].mlBase;
         llCodeTable[u] = (BYTE)ZSTD_LLcode(llv);
         ofCodeTable[u] = (BYTE)ZSTD_highbit32(sequences[u].offBase);
         mlCodeTable[u] = (BYTE)ZSTD_MLcode(mlv);
-    }
+    } 
     if (seqStorePtr->longLengthType==ZSTD_llt_literalLength)
-        llCodeTable[seqStorePtr->longLengthPos] = MaxLL;
+        llCodeTable[seqStorePtr->longLengthPos] = MaxLL; 
     if (seqStorePtr->longLengthType==ZSTD_llt_matchLength)
-        mlCodeTable[seqStorePtr->longLengthPos] = MaxML;
-}
-
+        mlCodeTable[seqStorePtr->longLengthPos] = MaxML; 
+} 
+ 
 /* ZSTD_useTargetCBlockSize():
  * Returns if target compressed block size param is being used.
  * If used, compression will do best effort to make a compressed block size to be around targetCBlockSize.
  * Returns 1 if true, 0 otherwise. */
 static int ZSTD_useTargetCBlockSize(const ZSTD_CCtx_params* cctxParams)
-{
+{ 
     DEBUGLOG(5, "ZSTD_useTargetCBlockSize (targetCBlockSize=%zu)", cctxParams->targetCBlockSize);
     return (cctxParams->targetCBlockSize != 0);
 }
@@ -2594,14 +2594,14 @@ ZSTD_entropyCompressSeqStore_internal(seqStore_t* seqStorePtr,
     BYTE* const oend = ostart + dstCapacity;
     BYTE* op = ostart;
     size_t lastCountSize;
-
+ 
     entropyWorkspace = count + (MaxSeq + 1);
     entropyWkspSize -= (MaxSeq + 1) * sizeof(*count);
 
     DEBUGLOG(4, "ZSTD_entropyCompressSeqStore_internal (nbSeq=%zu)", nbSeq);
     ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<<MAX(MLFSELog,LLFSELog)));
     assert(entropyWkspSize >= HUF_WORKSPACE_SIZE);
-
+ 
     /* Compress literals */
     {   const BYTE* const literals = seqStorePtr->litStart;
         size_t const numSequences = seqStorePtr->sequences - seqStorePtr->sequencesStart;
@@ -2621,7 +2621,7 @@ ZSTD_entropyCompressSeqStore_internal(seqStore_t* seqStorePtr,
         assert(cSize <= dstCapacity);
         op += cSize;
     }
-
+ 
     /* Sequences Header */
     RETURN_ERROR_IF((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/,
                     dstSize_tooSmall, "Can't fit seq hdr in output buf!");
@@ -2656,7 +2656,7 @@ ZSTD_entropyCompressSeqStore_internal(seqStore_t* seqStorePtr,
         lastCountSize = stats.lastCountSize;
         op += stats.size;
     }
-
+ 
     {   size_t const bitstreamSize = ZSTD_encodeSequences(
                                         op, (size_t)(oend - op),
                                         CTable_MatchLength, mlCodeTable,
@@ -2716,13 +2716,13 @@ ZSTD_entropyCompressSeqStore(seqStore_t* seqStorePtr,
     }
     DEBUGLOG(4, "ZSTD_entropyCompressSeqStore() cSize: %zu", cSize);
     return cSize;
-}
-
+} 
+ 
 /* ZSTD_selectBlockCompressor() :
  * Not static, but internal use only (used by long distance matcher)
  * assumption : strat is a valid strategy */
 ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_paramSwitch_e useRowMatchFinder, ZSTD_dictMode_e dictMode)
-{
+{ 
     static const ZSTD_blockCompressor blockCompressor[4][ZSTD_STRATEGY_MAX+1] = {
         { ZSTD_compressBlock_fast  /* default for 0 */,
           ZSTD_compressBlock_fast,
@@ -2767,7 +2767,7 @@ ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_paramS
     };
     ZSTD_blockCompressor selectedCompressor;
     ZSTD_STATIC_ASSERT((unsigned)ZSTD_fast == 1);
-
+ 
     assert(ZSTD_cParam_withinBounds(ZSTD_c_strategy, strat));
     DEBUGLOG(4, "Selected block compressor: dictMode=%d strat=%d rowMatchfinder=%d", (int)dictMode, (int)strat, (int)useRowMatchFinder);
     if (ZSTD_rowMatchFinderUsed(strat, useRowMatchFinder)) {
@@ -2794,25 +2794,25 @@ ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_paramS
     assert(selectedCompressor != NULL);
     return selectedCompressor;
 }
-
+ 
 static void ZSTD_storeLastLiterals(seqStore_t* seqStorePtr,
                                    const BYTE* anchor, size_t lastLLSize)
 {
     ZSTD_memcpy(seqStorePtr->lit, anchor, lastLLSize);
     seqStorePtr->lit += lastLLSize;
-}
-
+} 
+ 
 void ZSTD_resetSeqStore(seqStore_t* ssPtr)
-{
+{ 
     ssPtr->lit = ssPtr->litStart;
     ssPtr->sequences = ssPtr->sequencesStart;
     ssPtr->longLengthType = ZSTD_llt_none;
-}
-
+} 
+ 
 typedef enum { ZSTDbss_compress, ZSTDbss_noCompress } ZSTD_buildSeqStore_e;
 
 static size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)
-{
+{ 
     ZSTD_matchState_t* const ms = &zc->blockState.matchState;
     DEBUGLOG(5, "ZSTD_buildSeqStore (srcSize=%zu)", srcSize);
     assert(srcSize <= ZSTD_BLOCKSIZE_MAX);
@@ -2844,7 +2844,7 @@ static size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)
         if (curr > ms->nextToUpdate + 384)
             ms->nextToUpdate = curr - MIN(192, (U32)(curr - ms->nextToUpdate - 384));
     }
-
+ 
     /* select and store sequences */
     {   ZSTD_dictMode_e const dictMode = ZSTD_matchState_dictMode(ms);
         size_t lastLLSize;
@@ -3812,7 +3812,7 @@ ZSTD_compressBlock_internal(ZSTD_CCtx* zc,
 out:
     if (!ZSTD_isError(cSize) && cSize > 1) {
         ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState);
-    }
+    } 
     /* We check that dictionaries have offset codes available for the first
      * block. After the first block, the offcode table might not have large
      * enough codes to represent the offsets in the data.
@@ -3821,8 +3821,8 @@ out:
         zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;
 
     return cSize;
-}
-
+} 
+ 
 static size_t ZSTD_compressBlock_targetCBlockSize_body(ZSTD_CCtx* zc,
                                void* dst, size_t dstCapacity,
                                const void* src, size_t srcSize,
@@ -3870,7 +3870,7 @@ static size_t ZSTD_compressBlock_targetCBlockSize_body(ZSTD_CCtx* zc,
             }
         }
     }
-
+ 
     DEBUGLOG(6, "Resorting to ZSTD_noCompressBlock()");
     /* Superblock compression failed, attempt to emit a single no compress block.
      * The decoder will be able to stream this block since it is uncompressed.
@@ -3923,39 +3923,39 @@ static void ZSTD_overflowCorrectIfNeeded(ZSTD_matchState_t* ms,
 }
 
 /*! ZSTD_compress_frameChunk() :
-*   Compress a chunk of data into one or multiple blocks.
-*   All blocks will be terminated, all input will be consumed.
-*   Function will issue an error if there is not enough `dstCapacity` to hold the compressed content.
-*   Frame is supposed already started (header already produced)
-*   @return : compressed size, or an error code
-*/
+*   Compress a chunk of data into one or multiple blocks. 
+*   All blocks will be terminated, all input will be consumed. 
+*   Function will issue an error if there is not enough `dstCapacity` to hold the compressed content. 
+*   Frame is supposed already started (header already produced) 
+*   @return : compressed size, or an error code 
+*/ 
 static size_t ZSTD_compress_frameChunk(ZSTD_CCtx* cctx,
-                                     void* dst, size_t dstCapacity,
-                               const void* src, size_t srcSize,
-                                     U32 lastFrameChunk)
-{
-    size_t blockSize = cctx->blockSize;
-    size_t remaining = srcSize;
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* op = ostart;
+                                     void* dst, size_t dstCapacity, 
+                               const void* src, size_t srcSize, 
+                                     U32 lastFrameChunk) 
+{ 
+    size_t blockSize = cctx->blockSize; 
+    size_t remaining = srcSize; 
+    const BYTE* ip = (const BYTE*)src; 
+    BYTE* const ostart = (BYTE*)dst; 
+    BYTE* op = ostart; 
     U32 const maxDist = (U32)1 << cctx->appliedParams.cParams.windowLog;
 
     assert(cctx->appliedParams.cParams.windowLog <= ZSTD_WINDOWLOG_MAX);
-
+ 
     DEBUGLOG(4, "ZSTD_compress_frameChunk (blockSize=%u)", (unsigned)blockSize);
     if (cctx->appliedParams.fParams.checksumFlag && srcSize)
-        XXH64_update(&cctx->xxhState, src, srcSize);
-
-    while (remaining) {
+        XXH64_update(&cctx->xxhState, src, srcSize); 
+ 
+    while (remaining) { 
         ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
-        U32 const lastBlock = lastFrameChunk & (blockSize >= remaining);
-
+        U32 const lastBlock = lastFrameChunk & (blockSize >= remaining); 
+ 
         RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE,
                         dstSize_tooSmall,
                         "not enough space to store compressed block");
-        if (remaining < blockSize) blockSize = remaining;
-
+        if (remaining < blockSize) blockSize = remaining; 
+ 
         ZSTD_overflowCorrectIfNeeded(
             ms, &cctx->workspace, &cctx->appliedParams, ip, ip + blockSize);
         ZSTD_checkDictValidity(&ms->window, ip + blockSize, maxDist, &ms->loadedDictEnd, &ms->dictMatchState);
@@ -3991,7 +3991,7 @@ static size_t ZSTD_compress_frameChunk(ZSTD_CCtx* cctx,
                     cSize += ZSTD_blockHeaderSize;
                 }
             }
-
+ 
 
             ip += blockSize;
             assert(remaining >= blockSize);
@@ -4003,15 +4003,15 @@ static size_t ZSTD_compress_frameChunk(ZSTD_CCtx* cctx,
             DEBUGLOG(5, "ZSTD_compress_frameChunk: adding a block of size %u",
                         (unsigned)cSize);
     }   }
-
-    if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending;
+ 
+    if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending; 
     return (size_t)(op-ostart);
-}
-
-
-static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,
+} 
+ 
+ 
+static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity, 
                                     const ZSTD_CCtx_params* params, U64 pledgedSrcSize, U32 dictID)
-{   BYTE* const op = (BYTE*)dst;
+{   BYTE* const op = (BYTE*)dst; 
     U32   const dictIDSizeCodeLength = (dictID>0) + (dictID>=256) + (dictID>=65536);   /* 0-3 */
     U32   const dictIDSizeCode = params->fParams.noDictIDFlag ? 0 : dictIDSizeCodeLength;   /* 0-3 */
     U32   const checksumFlag = params->fParams.checksumFlag>0;
@@ -4022,7 +4022,7 @@ static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,
                      (pledgedSrcSize>=256) + (pledgedSrcSize>=65536+256) + (pledgedSrcSize>=0xFFFFFFFFU) : 0;  /* 0-3 */
     BYTE  const frameHeaderDescriptionByte = (BYTE)(dictIDSizeCode + (checksumFlag<<2) + (singleSegment<<5) + (fcsCode<<6) );
     size_t pos=0;
-
+ 
     assert(!(params->fParams.contentSizeFlag && pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN));
     RETURN_ERROR_IF(dstCapacity < ZSTD_FRAMEHEADERSIZE_MAX, dstSize_tooSmall,
                     "dst buf is too small to fit worst-case frame header size.");
@@ -4033,30 +4033,30 @@ static size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,
         pos = 4;
     }
     op[pos++] = frameHeaderDescriptionByte;
-    if (!singleSegment) op[pos++] = windowLogByte;
-    switch(dictIDSizeCode)
-    {
+    if (!singleSegment) op[pos++] = windowLogByte; 
+    switch(dictIDSizeCode) 
+    { 
         default:
             assert(0); /* impossible */
             ZSTD_FALLTHROUGH;
-        case 0 : break;
-        case 1 : op[pos] = (BYTE)(dictID); pos++; break;
-        case 2 : MEM_writeLE16(op+pos, (U16)dictID); pos+=2; break;
-        case 3 : MEM_writeLE32(op+pos, dictID); pos+=4; break;
-    }
-    switch(fcsCode)
-    {
+        case 0 : break; 
+        case 1 : op[pos] = (BYTE)(dictID); pos++; break; 
+        case 2 : MEM_writeLE16(op+pos, (U16)dictID); pos+=2; break; 
+        case 3 : MEM_writeLE32(op+pos, dictID); pos+=4; break; 
+    } 
+    switch(fcsCode) 
+    { 
         default:
             assert(0); /* impossible */
             ZSTD_FALLTHROUGH;
-        case 0 : if (singleSegment) op[pos++] = (BYTE)(pledgedSrcSize); break;
-        case 1 : MEM_writeLE16(op+pos, (U16)(pledgedSrcSize-256)); pos+=2; break;
-        case 2 : MEM_writeLE32(op+pos, (U32)(pledgedSrcSize)); pos+=4; break;
-        case 3 : MEM_writeLE64(op+pos, (U64)(pledgedSrcSize)); pos+=8; break;
-    }
-    return pos;
-}
-
+        case 0 : if (singleSegment) op[pos++] = (BYTE)(pledgedSrcSize); break; 
+        case 1 : MEM_writeLE16(op+pos, (U16)(pledgedSrcSize-256)); pos+=2; break; 
+        case 2 : MEM_writeLE32(op+pos, (U32)(pledgedSrcSize)); pos+=4; break; 
+        case 3 : MEM_writeLE64(op+pos, (U64)(pledgedSrcSize)); pos+=8; break; 
+    } 
+    return pos; 
+} 
+ 
 /* ZSTD_writeSkippableFrame_advanced() :
  * Writes out a skippable frame with the specified magic number variant (16 are supported),
  * from ZSTD_MAGIC_SKIPPABLE_START to ZSTD_MAGIC_SKIPPABLE_START+15, and the desired source data.
@@ -4091,7 +4091,7 @@ size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity)
         return ZSTD_blockHeaderSize;
     }
 }
-
+ 
 size_t ZSTD_referenceExternalSequences(ZSTD_CCtx* cctx, rawSeq* seq, size_t nbSeq)
 {
     RETURN_ERROR_IF(cctx->stage != ZSTDcs_init, stage_wrong,
@@ -4109,38 +4109,38 @@ size_t ZSTD_referenceExternalSequences(ZSTD_CCtx* cctx, rawSeq* seq, size_t nbSe
 
 
 static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
-                              void* dst, size_t dstCapacity,
-                        const void* src, size_t srcSize,
-                               U32 frame, U32 lastFrameChunk)
-{
+                              void* dst, size_t dstCapacity, 
+                        const void* src, size_t srcSize, 
+                               U32 frame, U32 lastFrameChunk) 
+{ 
     ZSTD_matchState_t* const ms = &cctx->blockState.matchState;
-    size_t fhSize = 0;
-
+    size_t fhSize = 0; 
+ 
     DEBUGLOG(5, "ZSTD_compressContinue_internal, stage: %u, srcSize: %u",
                 cctx->stage, (unsigned)srcSize);
     RETURN_ERROR_IF(cctx->stage==ZSTDcs_created, stage_wrong,
                     "missing init (ZSTD_compressBegin)");
-
+ 
     if (frame && (cctx->stage==ZSTDcs_init)) {
         fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams,
                                        cctx->pledgedSrcSizePlusOne-1, cctx->dictID);
         FORWARD_IF_ERROR(fhSize, "ZSTD_writeFrameHeader failed");
         assert(fhSize <= dstCapacity);
-        dstCapacity -= fhSize;
-        dst = (char*)dst + fhSize;
+        dstCapacity -= fhSize; 
+        dst = (char*)dst + fhSize; 
         cctx->stage = ZSTDcs_ongoing;
-    }
-
+    } 
+ 
     if (!srcSize) return fhSize;  /* do not generate an empty block if no input */
-
+ 
     if (!ZSTD_window_update(&ms->window, src, srcSize, ms->forceNonContiguous)) {
         ms->forceNonContiguous = 0;
         ms->nextToUpdate = ms->window.dictLimit;
-    }
+    } 
     if (cctx->appliedParams.ldmParams.enableLdm == ZSTD_ps_enable) {
         ZSTD_window_update(&cctx->ldmState.window, src, srcSize, /* forceNonContiguous */ 0);
     }
-
+ 
     if (!frame) {
         /* overflow check and correction for block mode */
         ZSTD_overflowCorrectIfNeeded(
@@ -4149,7 +4149,7 @@ static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
     }
 
     DEBUGLOG(5, "ZSTD_compressContinue_internal (blockSize=%u)", (unsigned)cctx->blockSize);
-    {   size_t const cSize = frame ?
+    {   size_t const cSize = frame ? 
                              ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) :
                              ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize, 0 /* frame */);
         FORWARD_IF_ERROR(cSize, "%s", frame ? "ZSTD_compress_frameChunk failed" : "ZSTD_compressBlock_internal failed");
@@ -4165,35 +4165,35 @@ static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
                 (unsigned)cctx->pledgedSrcSizePlusOne-1,
                 (unsigned)cctx->consumedSrcSize);
         }
-        return cSize + fhSize;
-    }
-}
-
-size_t ZSTD_compressContinue (ZSTD_CCtx* cctx,
-                              void* dst, size_t dstCapacity,
-                        const void* src, size_t srcSize)
-{
+        return cSize + fhSize; 
+    } 
+} 
+ 
+size_t ZSTD_compressContinue (ZSTD_CCtx* cctx, 
+                              void* dst, size_t dstCapacity, 
+                        const void* src, size_t srcSize) 
+{ 
     DEBUGLOG(5, "ZSTD_compressContinue (srcSize=%u)", (unsigned)srcSize);
     return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1 /* frame mode */, 0 /* last chunk */);
-}
-
-
+} 
+ 
+ 
 size_t ZSTD_getBlockSize(const ZSTD_CCtx* cctx)
-{
+{ 
     ZSTD_compressionParameters const cParams = cctx->appliedParams.cParams;
     assert(!ZSTD_checkCParams(cParams));
     return MIN (ZSTD_BLOCKSIZE_MAX, (U32)1 << cParams.windowLog);
-}
-
-size_t ZSTD_compressBlock(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
+} 
+ 
+size_t ZSTD_compressBlock(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
     DEBUGLOG(5, "ZSTD_compressBlock: srcSize = %u", (unsigned)srcSize);
     { size_t const blockSizeMax = ZSTD_getBlockSize(cctx);
       RETURN_ERROR_IF(srcSize > blockSizeMax, srcSize_wrong, "input is larger than a block"); }
 
     return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0 /* frame mode */, 0 /* last chunk */);
-}
-
+} 
+ 
 /*! ZSTD_loadDictionaryContent() :
  *  @return : 0, or an error code
  */
@@ -4203,11 +4203,11 @@ static size_t ZSTD_loadDictionaryContent(ZSTD_matchState_t* ms,
                                          ZSTD_CCtx_params const* params,
                                          const void* src, size_t srcSize,
                                          ZSTD_dictTableLoadMethod_e dtlm)
-{
+{ 
     const BYTE* ip = (const BYTE*) src;
-    const BYTE* const iend = ip + srcSize;
+    const BYTE* const iend = ip + srcSize; 
     int const loadLdmDict = params->ldmParams.enableLdm == ZSTD_ps_enable && ls != NULL;
-
+ 
     /* Assert that we the ms params match the params we're being given */
     ZSTD_assertEqualCParams(params->cParams, ms->cParams);
 
@@ -4233,19 +4233,19 @@ static size_t ZSTD_loadDictionaryContent(ZSTD_matchState_t* ms,
     ZSTD_window_update(&ms->window, src, srcSize, /* forceNonContiguous */ 0);
     ms->loadedDictEnd = params->forceWindow ? 0 : (U32)(iend - ms->window.base);
     ms->forceNonContiguous = params->deterministicRefPrefix;
-
+ 
     if (loadLdmDict) {
         ZSTD_window_update(&ls->window, src, srcSize, /* forceNonContiguous */ 0);
         ls->loadedDictEnd = params->forceWindow ? 0 : (U32)(iend - ls->window.base);
     }
 
-    if (srcSize <= HASH_READ_SIZE) return 0;
-
+    if (srcSize <= HASH_READ_SIZE) return 0; 
+ 
     ZSTD_overflowCorrectIfNeeded(ms, ws, params, ip, iend);
-
+ 
     if (loadLdmDict)
         ZSTD_ldm_fillHashTable(ls, ip, iend, &params->ldmParams);
-
+ 
     switch(params->cParams.strategy)
     {
     case ZSTD_fast:
@@ -4286,13 +4286,13 @@ static size_t ZSTD_loadDictionaryContent(ZSTD_matchState_t* ms,
 
     default:
         assert(0);  /* not possible : not a valid strategy id */
-    }
-
+    } 
+ 
     ms->nextToUpdate = (U32)(iend - ms->window.base);
-    return 0;
-}
-
-
+    return 0; 
+} 
+ 
+ 
 /* Dictionaries that assign zero probability to symbols that show up causes problems
  * when FSE encoding. Mark dictionaries with zero probability symbols as FSE_repeat_check
  * and only dictionaries with 100% valid symbols can be assumed valid.
@@ -4313,14 +4313,14 @@ static FSE_repeat ZSTD_dictNCountRepeat(short* normalizedCounter, unsigned dictM
 
 size_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,
                          const void* const dict, size_t dictSize)
-{
+{ 
     short offcodeNCount[MaxOff+1];
     unsigned offcodeMaxValue = MaxOff;
     const BYTE* dictPtr = (const BYTE*)dict;    /* skip magic num and dict ID */
-    const BYTE* const dictEnd = dictPtr + dictSize;
+    const BYTE* const dictEnd = dictPtr + dictSize; 
     dictPtr += 8;
     bs->entropy.huf.repeatMode = HUF_repeat_check;
-
+ 
     {   unsigned maxSymbolValue = 255;
         unsigned hasZeroWeights = 1;
         size_t const hufHeaderSize = HUF_readCTable((HUF_CElt*)bs->entropy.huf.CTable, &maxSymbolValue, dictPtr,
@@ -4333,9 +4333,9 @@ size_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,
 
         RETURN_ERROR_IF(HUF_isError(hufHeaderSize), dictionary_corrupted, "");
         RETURN_ERROR_IF(maxSymbolValue < 255, dictionary_corrupted, "");
-        dictPtr += hufHeaderSize;
-    }
-
+        dictPtr += hufHeaderSize; 
+    } 
+ 
     {   unsigned offcodeLog;
         size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr);
         RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted, "");
@@ -4347,12 +4347,12 @@ size_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,
                 workspace, HUF_WORKSPACE_SIZE)),
             dictionary_corrupted, "");
         /* Defer checking offcodeMaxValue because we need to know the size of the dictionary content */
-        dictPtr += offcodeHeaderSize;
-    }
-
-    {   short matchlengthNCount[MaxML+1];
+        dictPtr += offcodeHeaderSize; 
+    } 
+ 
+    {   short matchlengthNCount[MaxML+1]; 
         unsigned matchlengthMaxValue = MaxML, matchlengthLog;
-        size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr);
+        size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr); 
         RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted, "");
         RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted, "");
         RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
@@ -4361,12 +4361,12 @@ size_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,
                 workspace, HUF_WORKSPACE_SIZE)),
             dictionary_corrupted, "");
         bs->entropy.fse.matchlength_repeatMode = ZSTD_dictNCountRepeat(matchlengthNCount, matchlengthMaxValue, MaxML);
-        dictPtr += matchlengthHeaderSize;
-    }
-
-    {   short litlengthNCount[MaxLL+1];
+        dictPtr += matchlengthHeaderSize; 
+    } 
+ 
+    {   short litlengthNCount[MaxLL+1]; 
         unsigned litlengthMaxValue = MaxLL, litlengthLog;
-        size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr);
+        size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr); 
         RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted, "");
         RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted, "");
         RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(
@@ -4375,15 +4375,15 @@ size_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,
                 workspace, HUF_WORKSPACE_SIZE)),
             dictionary_corrupted, "");
         bs->entropy.fse.litlength_repeatMode = ZSTD_dictNCountRepeat(litlengthNCount, litlengthMaxValue, MaxLL);
-        dictPtr += litlengthHeaderSize;
-    }
-
+        dictPtr += litlengthHeaderSize; 
+    } 
+ 
     RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted, "");
     bs->rep[0] = MEM_readLE32(dictPtr+0);
     bs->rep[1] = MEM_readLE32(dictPtr+4);
     bs->rep[2] = MEM_readLE32(dictPtr+8);
-    dictPtr += 12;
-
+    dictPtr += 12; 
+ 
     {   size_t const dictContentSize = (size_t)(dictEnd - dictPtr);
         U32 offcodeMax = MaxOff;
         if (dictContentSize <= ((U32)-1) - 128 KB) {
@@ -4439,9 +4439,9 @@ static size_t ZSTD_loadZstdDictionary(ZSTD_compressedBlockState_t* bs,
             ms, NULL, ws, params, dictPtr, dictContentSize, dtlm), "");
     }
     return dictID;
-}
-
-/** ZSTD_compress_insertDictionary() :
+} 
+ 
+/** ZSTD_compress_insertDictionary() : 
 *   @return : dictID, or an error code */
 static size_t
 ZSTD_compress_insertDictionary(ZSTD_compressedBlockState_t* bs,
@@ -4453,15 +4453,15 @@ ZSTD_compress_insertDictionary(ZSTD_compressedBlockState_t* bs,
                                ZSTD_dictContentType_e dictContentType,
                                ZSTD_dictTableLoadMethod_e dtlm,
                                void* workspace)
-{
+{ 
     DEBUGLOG(4, "ZSTD_compress_insertDictionary (dictSize=%u)", (U32)dictSize);
     if ((dict==NULL) || (dictSize<8)) {
         RETURN_ERROR_IF(dictContentType == ZSTD_dct_fullDict, dictionary_wrong, "");
         return 0;
     }
-
+ 
     ZSTD_reset_compressedBlockState(bs);
-
+ 
     /* dict restricted modes */
     if (dictContentType == ZSTD_dct_rawContent)
         return ZSTD_loadDictionaryContent(ms, ls, ws, params, dict, dictSize, dtlm);
@@ -4474,17 +4474,17 @@ ZSTD_compress_insertDictionary(ZSTD_compressedBlockState_t* bs,
         }
         RETURN_ERROR_IF(dictContentType == ZSTD_dct_fullDict, dictionary_wrong, "");
         assert(0);   /* impossible */
-    }
+    } 
 
     /* dict as full zstd dictionary */
     return ZSTD_loadZstdDictionary(
         bs, ms, ws, params, dict, dictSize, dtlm, workspace);
-}
-
+} 
+ 
 #define ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF (128 KB)
 #define ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER (6ULL)
 
-/*! ZSTD_compressBegin_internal() :
+/*! ZSTD_compressBegin_internal() : 
  * @return : 0, or an error code */
 static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
                                     const void* dict, size_t dictSize,
@@ -4493,7 +4493,7 @@ static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
                                     const ZSTD_CDict* cdict,
                                     const ZSTD_CCtx_params* params, U64 pledgedSrcSize,
                                     ZSTD_buffered_policy_e zbuff)
-{
+{ 
     size_t const dictContentSize = cdict ? cdict->dictContentSize : dictSize;
 #if ZSTD_TRACE
     cctx->traceCtx = (ZSTD_trace_compress_begin != NULL) ? ZSTD_trace_compress_begin(cctx) : 0;
@@ -4531,8 +4531,8 @@ static size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,
         cctx->dictContentSize = dictContentSize;
     }
     return 0;
-}
-
+} 
+ 
 size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
                                     const void* dict, size_t dictSize,
                                     ZSTD_dictContentType_e dictContentType,
@@ -4550,23 +4550,23 @@ size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
                                        params, pledgedSrcSize,
                                        ZSTDb_not_buffered);
 }
-
-/*! ZSTD_compressBegin_advanced() :
-*   @return : 0, or an error code */
-size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx,
-                             const void* dict, size_t dictSize,
-                                   ZSTD_parameters params, unsigned long long pledgedSrcSize)
-{
+ 
+/*! ZSTD_compressBegin_advanced() : 
+*   @return : 0, or an error code */ 
+size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, 
+                             const void* dict, size_t dictSize, 
+                                   ZSTD_parameters params, unsigned long long pledgedSrcSize) 
+{ 
     ZSTD_CCtx_params cctxParams;
     ZSTD_CCtxParams_init_internal(&cctxParams, &params, ZSTD_NO_CLEVEL);
     return ZSTD_compressBegin_advanced_internal(cctx,
                                             dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast,
                                             NULL /*cdict*/,
                                             &cctxParams, pledgedSrcSize);
-}
-
-size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel)
-{
+} 
+ 
+size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel) 
+{ 
     ZSTD_CCtx_params cctxParams;
     {
         ZSTD_parameters const params = ZSTD_getParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_noAttachDict);
@@ -4575,56 +4575,56 @@ size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t di
     DEBUGLOG(4, "ZSTD_compressBegin_usingDict (dictSize=%u)", (unsigned)dictSize);
     return ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
                                        &cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, ZSTDb_not_buffered);
-}
-
+} 
+ 
 size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel)
-{
+{ 
     return ZSTD_compressBegin_usingDict(cctx, NULL, 0, compressionLevel);
-}
-
-
-/*! ZSTD_writeEpilogue() :
-*   Ends a frame.
-*   @return : nb of bytes written into dst (or an error code) */
-static size_t ZSTD_writeEpilogue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity)
-{
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* op = ostart;
-    size_t fhSize = 0;
-
+} 
+ 
+ 
+/*! ZSTD_writeEpilogue() : 
+*   Ends a frame. 
+*   @return : nb of bytes written into dst (or an error code) */ 
+static size_t ZSTD_writeEpilogue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity) 
+{ 
+    BYTE* const ostart = (BYTE*)dst; 
+    BYTE* op = ostart; 
+    size_t fhSize = 0; 
+ 
     DEBUGLOG(4, "ZSTD_writeEpilogue");
     RETURN_ERROR_IF(cctx->stage == ZSTDcs_created, stage_wrong, "init missing");
-
-    /* special case : empty frame */
-    if (cctx->stage == ZSTDcs_init) {
+ 
+    /* special case : empty frame */ 
+    if (cctx->stage == ZSTDcs_init) { 
         fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams, 0, 0);
         FORWARD_IF_ERROR(fhSize, "ZSTD_writeFrameHeader failed");
-        dstCapacity -= fhSize;
-        op += fhSize;
-        cctx->stage = ZSTDcs_ongoing;
-    }
-
-    if (cctx->stage != ZSTDcs_ending) {
-        /* write one last empty block, make it the "last" block */
-        U32 const cBlockHeader24 = 1 /* last block */ + (((U32)bt_raw)<<1) + 0;
+        dstCapacity -= fhSize; 
+        op += fhSize; 
+        cctx->stage = ZSTDcs_ongoing; 
+    } 
+ 
+    if (cctx->stage != ZSTDcs_ending) { 
+        /* write one last empty block, make it the "last" block */ 
+        U32 const cBlockHeader24 = 1 /* last block */ + (((U32)bt_raw)<<1) + 0; 
         RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, "no room for epilogue");
-        MEM_writeLE32(op, cBlockHeader24);
-        op += ZSTD_blockHeaderSize;
-        dstCapacity -= ZSTD_blockHeaderSize;
-    }
-
+        MEM_writeLE32(op, cBlockHeader24); 
+        op += ZSTD_blockHeaderSize; 
+        dstCapacity -= ZSTD_blockHeaderSize; 
+    } 
+ 
     if (cctx->appliedParams.fParams.checksumFlag) {
-        U32 const checksum = (U32) XXH64_digest(&cctx->xxhState);
+        U32 const checksum = (U32) XXH64_digest(&cctx->xxhState); 
         RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, "no room for checksum");
         DEBUGLOG(4, "ZSTD_writeEpilogue: write checksum : %08X", (unsigned)checksum);
-        MEM_writeLE32(op, checksum);
-        op += 4;
-    }
-
-    cctx->stage = ZSTDcs_created;  /* return to "created but no init" status */
-    return op-ostart;
-}
-
+        MEM_writeLE32(op, checksum); 
+        op += 4; 
+    } 
+ 
+    cctx->stage = ZSTDcs_created;  /* return to "created but no init" status */ 
+    return op-ostart; 
+} 
+ 
 void ZSTD_CCtx_trace(ZSTD_CCtx* cctx, size_t extraCSize)
 {
 #if ZSTD_TRACE
@@ -4649,16 +4649,16 @@ void ZSTD_CCtx_trace(ZSTD_CCtx* cctx, size_t extraCSize)
 #endif
 }
 
-size_t ZSTD_compressEnd (ZSTD_CCtx* cctx,
-                         void* dst, size_t dstCapacity,
-                   const void* src, size_t srcSize)
-{
-    size_t endResult;
+size_t ZSTD_compressEnd (ZSTD_CCtx* cctx, 
+                         void* dst, size_t dstCapacity, 
+                   const void* src, size_t srcSize) 
+{ 
+    size_t endResult; 
     size_t const cSize = ZSTD_compressContinue_internal(cctx,
                                 dst, dstCapacity, src, srcSize,
                                 1 /* frame mode */, 1 /* last chunk */);
     FORWARD_IF_ERROR(cSize, "ZSTD_compressContinue_internal failed");
-    endResult = ZSTD_writeEpilogue(cctx, (char*)dst + cSize, dstCapacity-cSize);
+    endResult = ZSTD_writeEpilogue(cctx, (char*)dst + cSize, dstCapacity-cSize); 
     FORWARD_IF_ERROR(endResult, "ZSTD_writeEpilogue failed");
     assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));
     if (cctx->pledgedSrcSizePlusOne != 0) {  /* control src size */
@@ -4672,15 +4672,15 @@ size_t ZSTD_compressEnd (ZSTD_CCtx* cctx,
             (unsigned)cctx->consumedSrcSize);
     }
     ZSTD_CCtx_trace(cctx, endResult);
-    return cSize + endResult;
-}
-
+    return cSize + endResult; 
+} 
+ 
 size_t ZSTD_compress_advanced (ZSTD_CCtx* cctx,
-                               void* dst, size_t dstCapacity,
-                         const void* src, size_t srcSize,
-                         const void* dict,size_t dictSize,
-                               ZSTD_parameters params)
-{
+                               void* dst, size_t dstCapacity, 
+                         const void* src, size_t srcSize, 
+                         const void* dict,size_t dictSize, 
+                               ZSTD_parameters params) 
+{ 
     DEBUGLOG(4, "ZSTD_compress_advanced");
     FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams), "");
     ZSTD_CCtxParams_init_internal(&cctx->simpleApiParams, &params, ZSTD_NO_CLEVEL);
@@ -4689,8 +4689,8 @@ size_t ZSTD_compress_advanced (ZSTD_CCtx* cctx,
                                            src, srcSize,
                                            dict, dictSize,
                                            &cctx->simpleApiParams);
-}
-
+} 
+ 
 /* Internal */
 size_t ZSTD_compress_advanced_internal(
         ZSTD_CCtx* cctx,
@@ -4698,20 +4698,20 @@ size_t ZSTD_compress_advanced_internal(
         const void* src, size_t srcSize,
         const void* dict,size_t dictSize,
         const ZSTD_CCtx_params* params)
-{
+{ 
     DEBUGLOG(4, "ZSTD_compress_advanced_internal (srcSize:%u)", (unsigned)srcSize);
     FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx,
                          dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
                          params, srcSize, ZSTDb_not_buffered) , "");
     return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
-}
-
+} 
+ 
 size_t ZSTD_compress_usingDict(ZSTD_CCtx* cctx,
                                void* dst, size_t dstCapacity,
                          const void* src, size_t srcSize,
                          const void* dict, size_t dictSize,
                                int compressionLevel)
-{
+{ 
     {
         ZSTD_parameters const params = ZSTD_getParams_internal(compressionLevel, srcSize, dict ? dictSize : 0, ZSTD_cpm_noAttachDict);
         assert(params.fParams.contentSizeFlag == 1);
@@ -4719,8 +4719,8 @@ size_t ZSTD_compress_usingDict(ZSTD_CCtx* cctx,
     }
     DEBUGLOG(4, "ZSTD_compress_usingDict (srcSize=%u)", (unsigned)srcSize);
     return ZSTD_compress_advanced_internal(cctx, dst, dstCapacity, src, srcSize, dict, dictSize, &cctx->simpleApiParams);
-}
-
+} 
+ 
 size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,
                          void* dst, size_t dstCapacity,
                    const void* src, size_t srcSize,
@@ -4734,25 +4734,25 @@ size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,
 size_t ZSTD_compress(void* dst, size_t dstCapacity,
                const void* src, size_t srcSize,
                      int compressionLevel)
-{
-    size_t result;
+{ 
+    size_t result; 
 #if ZSTD_COMPRESS_HEAPMODE
     ZSTD_CCtx* cctx = ZSTD_createCCtx();
     RETURN_ERROR_IF(!cctx, memory_allocation, "ZSTD_createCCtx failed");
     result = ZSTD_compressCCtx(cctx, dst, dstCapacity, src, srcSize, compressionLevel);
     ZSTD_freeCCtx(cctx);
 #else
-    ZSTD_CCtx ctxBody;
+    ZSTD_CCtx ctxBody; 
     ZSTD_initCCtx(&ctxBody, ZSTD_defaultCMem);
-    result = ZSTD_compressCCtx(&ctxBody, dst, dstCapacity, src, srcSize, compressionLevel);
+    result = ZSTD_compressCCtx(&ctxBody, dst, dstCapacity, src, srcSize, compressionLevel); 
     ZSTD_freeCCtxContent(&ctxBody);   /* can't free ctxBody itself, as it's on stack; free only heap content */
 #endif
-    return result;
-}
-
-
-/* =====  Dictionary API  ===== */
-
+    return result; 
+} 
+ 
+ 
+/* =====  Dictionary API  ===== */ 
+ 
 /*! ZSTD_estimateCDictSize_advanced() :
  *  Estimate amount of memory that will be needed to create a dictionary with following arguments */
 size_t ZSTD_estimateCDictSize_advanced(
@@ -4769,7 +4769,7 @@ size_t ZSTD_estimateCDictSize_advanced(
          + (dictLoadMethod == ZSTD_dlm_byRef ? 0
             : ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void *))));
 }
-
+ 
 size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel)
 {
     ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);
@@ -4791,7 +4791,7 @@ static size_t ZSTD_initCDict_internal(
                     ZSTD_dictLoadMethod_e dictLoadMethod,
                     ZSTD_dictContentType_e dictContentType,
                     ZSTD_CCtx_params params)
-{
+{ 
     DEBUGLOG(3, "ZSTD_initCDict_internal (dictContentType:%u)", (unsigned)dictContentType);
     assert(!ZSTD_checkCParams(params.cParams));
     cdict->matchState.cParams = params.cParams;
@@ -4806,7 +4806,7 @@ static size_t ZSTD_initCDict_internal(
     }
     cdict->dictContentSize = dictSize;
     cdict->dictContentType = dictContentType;
-
+ 
     cdict->entropyWorkspace = (U32*)ZSTD_cwksp_reserve_object(&cdict->workspace, HUF_WORKSPACE_SIZE);
 
 
@@ -4834,7 +4834,7 @@ static size_t ZSTD_initCDict_internal(
             cdict->dictID = (U32)dictID;
         }
     }
-
+ 
     return 0;
 }
 
@@ -4859,8 +4859,8 @@ static ZSTD_CDict* ZSTD_createCDict_advanced_internal(size_t dictSize,
 
         if (!workspace) {
             ZSTD_customFree(workspace, customMem);
-            return NULL;
-        }
+            return NULL; 
+        } 
 
         ZSTD_cwksp_init(&ws, workspace, workspaceSize, ZSTD_cwksp_dynamic_alloc);
 
@@ -4870,10 +4870,10 @@ static ZSTD_CDict* ZSTD_createCDict_advanced_internal(size_t dictSize,
         cdict->customMem = customMem;
         cdict->compressionLevel = ZSTD_NO_CLEVEL; /* signals advanced API usage */
         cdict->useRowMatchFinder = useRowMatchFinder;
-        return cdict;
-    }
-}
-
+        return cdict; 
+    } 
+} 
+ 
 ZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize,
                                       ZSTD_dictLoadMethod_e dictLoadMethod,
                                       ZSTD_dictContentType_e dictContentType,
@@ -4941,8 +4941,8 @@ ZSTD_CDict* ZSTD_createCDict_advanced2(
     return cdict;
 }
 
-ZSTD_CDict* ZSTD_createCDict(const void* dict, size_t dictSize, int compressionLevel)
-{
+ZSTD_CDict* ZSTD_createCDict(const void* dict, size_t dictSize, int compressionLevel) 
+{ 
     ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);
     ZSTD_CDict* const cdict = ZSTD_createCDict_advanced(dict, dictSize,
                                                   ZSTD_dlm_byCopy, ZSTD_dct_auto,
@@ -4950,8 +4950,8 @@ ZSTD_CDict* ZSTD_createCDict(const void* dict, size_t dictSize, int compressionL
     if (cdict)
         cdict->compressionLevel = (compressionLevel == 0) ? ZSTD_CLEVEL_DEFAULT : compressionLevel;
     return cdict;
-}
-
+} 
+ 
 ZSTD_CDict* ZSTD_createCDict_byReference(const void* dict, size_t dictSize, int compressionLevel)
 {
     ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);
@@ -4963,8 +4963,8 @@ ZSTD_CDict* ZSTD_createCDict_byReference(const void* dict, size_t dictSize, int
     return cdict;
 }
 
-size_t ZSTD_freeCDict(ZSTD_CDict* cdict)
-{
+size_t ZSTD_freeCDict(ZSTD_CDict* cdict) 
+{ 
     if (cdict==NULL) return 0;   /* support free on NULL */
     {   ZSTD_customMem const cMem = cdict->customMem;
         int cdictInWorkspace = ZSTD_cwksp_owns_buffer(&cdict->workspace, cdict);
@@ -5039,8 +5039,8 @@ ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict)
 {
     assert(cdict != NULL);
     return cdict->matchState.cParams;
-}
-
+} 
+ 
 /*! ZSTD_getDictID_fromCDict() :
  *  Provides the dictID of the dictionary loaded into `cdict`.
  *  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.
@@ -5142,13 +5142,13 @@ size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx,
                                 void* dst, size_t dstCapacity,
                                 const void* src, size_t srcSize,
                                 const ZSTD_CDict* cdict)
-{
+{ 
     ZSTD_frameParameters const fParams = { 1 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };
     return ZSTD_compress_usingCDict_internal(cctx, dst, dstCapacity, src, srcSize, cdict, fParams);
-}
-
-
-
+} 
+ 
+ 
+ 
 /* ******************************************************************
 *  Streaming
 ********************************************************************/
@@ -6180,13 +6180,13 @@ size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
 }
 
 
-/*-=====  Pre-defined compression levels  =====-*/
+/*-=====  Pre-defined compression levels  =====-*/ 
 #include "clevels.h"
-
-int ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
+ 
+int ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; } 
 int ZSTD_minCLevel(void) { return (int)-ZSTD_TARGETLENGTH_MAX; }
 int ZSTD_defaultCLevel(void) { return ZSTD_CLEVEL_DEFAULT; }
-
+ 
 static ZSTD_compressionParameters ZSTD_dedicatedDictSearch_getCParams(int const compressionLevel, size_t const dictSize)
 {
     ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, 0, dictSize, ZSTD_cpm_createCDict);
@@ -6270,7 +6270,7 @@ static U64 ZSTD_getCParamRowSize(U64 srcSizeHint, size_t dictSize, ZSTD_cParamMo
  *        Use dictSize == 0 for unknown or unused.
  *  Note: `mode` controls how we treat the `dictSize`. See docs for `ZSTD_cParamMode_e`. */
 static ZSTD_compressionParameters ZSTD_getCParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode)
-{
+{ 
     U64 const rSize = ZSTD_getCParamRowSize(srcSizeHint, dictSize, mode);
     U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);
     int row;
@@ -6292,8 +6292,8 @@ static ZSTD_compressionParameters ZSTD_getCParams_internal(int compressionLevel,
         /* refine parameters based on srcSize & dictSize */
         return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize, mode);
     }
-}
-
+} 
+ 
 /*! ZSTD_getCParams() :
  * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.
  *  Size values are optional, provide 0 if not known or unused */
@@ -6303,19 +6303,19 @@ ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long l
     return ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize, ZSTD_cpm_unknown);
 }
 
-/*! ZSTD_getParams() :
+/*! ZSTD_getParams() : 
  *  same idea as ZSTD_getCParams()
  * @return a `ZSTD_parameters` structure (instead of `ZSTD_compressionParameters`).
  *  Fields of `ZSTD_frameParameters` are set to default values */
 static ZSTD_parameters ZSTD_getParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode) {
-    ZSTD_parameters params;
+    ZSTD_parameters params; 
     ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize, mode);
     DEBUGLOG(5, "ZSTD_getParams (cLevel=%i)", compressionLevel);
     ZSTD_memset(&params, 0, sizeof(params));
-    params.cParams = cParams;
+    params.cParams = cParams; 
     params.fParams.contentSizeFlag = 1;
-    return params;
-}
+    return params; 
+} 
 
 /*! ZSTD_getParams() :
  *  same idea as ZSTD_getCParams()
diff --git a/contrib/libs/zstd/lib/compress/zstd_opt.h b/contrib/libs/zstd/lib/compress/zstd_opt.h
index 627255f53d..bde0658a01 100644
--- a/contrib/libs/zstd/lib/compress/zstd_opt.h
+++ b/contrib/libs/zstd/lib/compress/zstd_opt.h
@@ -7,19 +7,19 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
+ 
 #ifndef ZSTD_OPT_H
 #define ZSTD_OPT_H
-
+ 
 #if defined (__cplusplus)
 extern "C" {
 #endif
-
+ 
 #include "zstd_compress_internal.h"
-
+ 
 /* used in ZSTD_loadDictionaryContent() */
 void ZSTD_updateTree(ZSTD_matchState_t* ms, const BYTE* ip, const BYTE* iend);
-
+ 
 size_t ZSTD_compressBlock_btopt(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         void const* src, size_t srcSize);
@@ -29,7 +29,7 @@ size_t ZSTD_compressBlock_btultra(
 size_t ZSTD_compressBlock_btultra2(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         void const* src, size_t srcSize);
-
+ 
 
 size_t ZSTD_compressBlock_btopt_dictMatchState(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
@@ -44,13 +44,13 @@ size_t ZSTD_compressBlock_btopt_extDict(
 size_t ZSTD_compressBlock_btultra_extDict(
         ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         void const* src, size_t srcSize);
-
+ 
         /* note : no btultra2 variant for extDict nor dictMatchState,
          * because btultra2 is not meant to work with dictionaries
          * and is only specific for the first block (no prefix) */
 
 #if defined (__cplusplus)
-}
+} 
 #endif
-
+ 
 #endif /* ZSTD_OPT_H */
diff --git a/contrib/libs/zstd/lib/decompress/huf_decompress.c b/contrib/libs/zstd/lib/decompress/huf_decompress.c
index 2027188255..e43e05d581 100644
--- a/contrib/libs/zstd/lib/decompress/huf_decompress.c
+++ b/contrib/libs/zstd/lib/decompress/huf_decompress.c
@@ -1,4 +1,4 @@
-/* ******************************************************************
+/* ****************************************************************** 
  * huff0 huffman decoder,
  * part of Finite State Entropy library
  * Copyright (c) Yann Collet, Facebook, Inc.
@@ -10,20 +10,20 @@
  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
-****************************************************************** */
-
-/* **************************************************************
+****************************************************************** */ 
+ 
+/* ************************************************************** 
 *  Dependencies
-****************************************************************/
+****************************************************************/ 
 #include "../common/zstd_deps.h"  /* ZSTD_memcpy, ZSTD_memset */
 #include "../common/compiler.h"
 #include "../common/bitstream.h"  /* BIT_* */
 #include "../common/fse.h"        /* to compress headers */
-#define HUF_STATIC_LINKING_ONLY
+#define HUF_STATIC_LINKING_ONLY 
 #include "../common/huf.h"
 #include "../common/error_private.h"
 #include "../common/zstd_internal.h"
-
+ 
 /* **************************************************************
 *  Constants
 ****************************************************************/
@@ -33,7 +33,7 @@
 /* **************************************************************
 *  Macros
 ****************************************************************/
-
+ 
 /* These two optional macros force the use one way or another of the two
  * Huffman decompression implementations. You can't force in both directions
  * at the same time.
@@ -68,12 +68,12 @@
 # define HUF_NEED_DEFAULT_FUNCTION 0
 #endif
 
-/* **************************************************************
-*  Error Management
-****************************************************************/
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
 #define HUF_isError ERR_isError
-
-
+ 
+ 
 /* **************************************************************
 *  Byte alignment for workSpace management
 ****************************************************************/
@@ -126,20 +126,20 @@
 #endif
 
 
-/*-***************************/
-/*  generic DTableDesc       */
-/*-***************************/
-typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc;
-
-static DTableDesc HUF_getDTableDesc(const HUF_DTable* table)
-{
-    DTableDesc dtd;
+/*-***************************/ 
+/*  generic DTableDesc       */ 
+/*-***************************/ 
+typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc; 
+ 
+static DTableDesc HUF_getDTableDesc(const HUF_DTable* table) 
+{ 
+    DTableDesc dtd; 
     ZSTD_memcpy(&dtd, table, sizeof(dtd));
-    return dtd;
-}
-
+    return dtd; 
+} 
+ 
 #if ZSTD_ENABLE_ASM_X86_64_BMI2
-
+ 
 static size_t HUF_initDStream(BYTE const* ip) {
     BYTE const lastByte = ip[7];
     size_t const bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
@@ -275,11 +275,11 @@ static size_t HUF_initRemainingDStream(BIT_DStream_t* bit, HUF_DecompressAsmArgs
 
 #ifndef HUF_FORCE_DECOMPRESS_X2
 
-/*-***************************/
-/*  single-symbol decoding   */
-/*-***************************/
+/*-***************************/ 
+/*  single-symbol decoding   */ 
+/*-***************************/ 
 typedef struct { BYTE nbBits; BYTE byte; } HUF_DEltX1;   /* single-symbol decoding */
-
+ 
 /**
  * Packs 4 HUF_DEltX1 structs into a U64. This is used to lay down 4 entries at
  * a time.
@@ -335,40 +335,40 @@ typedef struct {
 
 
 size_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize)
-{
+{ 
     return HUF_readDTableX1_wksp_bmi2(DTable, src, srcSize, workSpace, wkspSize, /* bmi2 */ 0);
 }
 
 size_t HUF_readDTableX1_wksp_bmi2(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize, int bmi2)
 {
-    U32 tableLog = 0;
-    U32 nbSymbols = 0;
-    size_t iSize;
-    void* const dtPtr = DTable + 1;
+    U32 tableLog = 0; 
+    U32 nbSymbols = 0; 
+    size_t iSize; 
+    void* const dtPtr = DTable + 1; 
     HUF_DEltX1* const dt = (HUF_DEltX1*)dtPtr;
     HUF_ReadDTableX1_Workspace* wksp = (HUF_ReadDTableX1_Workspace*)workSpace;
-
+ 
     DEBUG_STATIC_ASSERT(HUF_DECOMPRESS_WORKSPACE_SIZE >= sizeof(*wksp));
     if (sizeof(*wksp) > wkspSize) return ERROR(tableLog_tooLarge);
 
     DEBUG_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUF_DTable));
     /* ZSTD_memset(huffWeight, 0, sizeof(huffWeight)); */   /* is not necessary, even though some analyzer complain ... */
-
+ 
     iSize = HUF_readStats_wksp(wksp->huffWeight, HUF_SYMBOLVALUE_MAX + 1, wksp->rankVal, &nbSymbols, &tableLog, src, srcSize, wksp->statsWksp, sizeof(wksp->statsWksp), bmi2);
-    if (HUF_isError(iSize)) return iSize;
+    if (HUF_isError(iSize)) return iSize; 
+ 
 
-
-    /* Table header */
-    {   DTableDesc dtd = HUF_getDTableDesc(DTable);
+    /* Table header */ 
+    {   DTableDesc dtd = HUF_getDTableDesc(DTable); 
         U32 const maxTableLog = dtd.maxTableLog + 1;
         U32 const targetTableLog = MIN(maxTableLog, HUF_DECODER_FAST_TABLELOG);
         tableLog = HUF_rescaleStats(wksp->huffWeight, wksp->rankVal, nbSymbols, tableLog, targetTableLog);
         if (tableLog > (U32)(dtd.maxTableLog+1)) return ERROR(tableLog_tooLarge);   /* DTable too small, Huffman tree cannot fit in */
-        dtd.tableType = 0;
-        dtd.tableLog = (BYTE)tableLog;
+        dtd.tableType = 0; 
+        dtd.tableLog = (BYTE)tableLog; 
         ZSTD_memcpy(DTable, &dtd, sizeof(dtd));
-    }
-
+    } 
+ 
     /* Compute symbols and rankStart given rankVal:
      *
      * rankVal already contains the number of values of each weight.
@@ -403,7 +403,7 @@ size_t HUF_readDTableX1_wksp_bmi2(HUF_DTable* DTable, const void* src, size_t sr
             wksp->symbols[wksp->rankStart[w]++] = (BYTE)n;
         }
     }
-
+ 
     /* fill DTable
      * We fill all entries of each weight in order.
      * That way length is a constant for each iteration of the outer loop.
@@ -474,35 +474,35 @@ size_t HUF_readDTableX1_wksp_bmi2(HUF_DTable* DTable, const void* src, size_t sr
             rankStart += symbolCount * length;
         }
     }
-    return iSize;
-}
-
+    return iSize; 
+} 
+ 
 FORCE_INLINE_TEMPLATE BYTE
 HUF_decodeSymbolX1(BIT_DStream_t* Dstream, const HUF_DEltX1* dt, const U32 dtLog)
-{
-    size_t const val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
-    BYTE const c = dt[val].byte;
-    BIT_skipBits(Dstream, dt[val].nbBits);
-    return c;
-}
-
+{ 
+    size_t const val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */ 
+    BYTE const c = dt[val].byte; 
+    BIT_skipBits(Dstream, dt[val].nbBits); 
+    return c; 
+} 
+ 
 #define HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr) \
     *ptr++ = HUF_decodeSymbolX1(DStreamPtr, dt, dtLog)
-
+ 
 #define HUF_DECODE_SYMBOLX1_1(ptr, DStreamPtr)  \
-    if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \
+    if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \ 
         HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)
-
+ 
 #define HUF_DECODE_SYMBOLX1_2(ptr, DStreamPtr) \
-    if (MEM_64bits()) \
+    if (MEM_64bits()) \ 
         HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)
-
+ 
 HINT_INLINE size_t
 HUF_decodeStreamX1(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX1* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 4 symbols at a time */
+{ 
+    BYTE* const pStart = p; 
+ 
+    /* up to 4 symbols at a time */ 
     if ((pEnd - p) > 3) {
         while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-3)) {
             HUF_DECODE_SYMBOLX1_2(p, bitDPtr);
@@ -512,91 +512,91 @@ HUF_decodeStreamX1(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, cons
         }
     } else {
         BIT_reloadDStream(bitDPtr);
-    }
-
+    } 
+ 
     /* [0-3] symbols remaining */
     if (MEM_32bits())
         while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd))
             HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
-
+ 
     /* no more data to retrieve from bitstream, no need to reload */
-    while (p < pEnd)
+    while (p < pEnd) 
         HUF_DECODE_SYMBOLX1_0(p, bitDPtr);
-
-    return pEnd-pStart;
-}
-
+ 
+    return pEnd-pStart; 
+} 
+ 
 FORCE_INLINE_TEMPLATE size_t
 HUF_decompress1X1_usingDTable_internal_body(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUF_DTable* DTable)
-{
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + dstSize;
-    const void* dtPtr = DTable + 1;
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const HUF_DTable* DTable) 
+{ 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + dstSize; 
+    const void* dtPtr = DTable + 1; 
     const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;
-    BIT_DStream_t bitD;
-    DTableDesc const dtd = HUF_getDTableDesc(DTable);
-    U32 const dtLog = dtd.tableLog;
-
+    BIT_DStream_t bitD; 
+    DTableDesc const dtd = HUF_getDTableDesc(DTable); 
+    U32 const dtLog = dtd.tableLog; 
+ 
     CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );
-
+ 
     HUF_decodeStreamX1(op, &bitD, oend, dt, dtLog);
-
-    if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
-
-    return dstSize;
-}
-
+ 
+    if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected); 
+ 
+    return dstSize; 
+} 
+ 
 FORCE_INLINE_TEMPLATE size_t
 HUF_decompress4X1_usingDTable_internal_body(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUF_DTable* DTable)
-{
-    /* Check */
-    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;
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const HUF_DTable* DTable) 
+{ 
+    /* Check */ 
+    if (cSrcSize < 10) return ERROR(corruption_detected);  /* strict minimum : jump table + 1 byte per stream */ 
+ 
+    {   const BYTE* const istart = (const BYTE*) cSrc; 
+        BYTE* const ostart = (BYTE*) dst; 
+        BYTE* const oend = ostart + dstSize; 
         BYTE* const olimit = oend - 3;
-        const void* const dtPtr = DTable + 1;
+        const void* const dtPtr = DTable + 1; 
         const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;
-
-        /* Init */
-        BIT_DStream_t bitD1;
-        BIT_DStream_t bitD2;
-        BIT_DStream_t bitD3;
-        BIT_DStream_t bitD4;
-        size_t const length1 = MEM_readLE16(istart);
-        size_t const length2 = MEM_readLE16(istart+2);
-        size_t const length3 = MEM_readLE16(istart+4);
-        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
-        const BYTE* const istart1 = istart + 6;  /* jumpTable */
-        const BYTE* const istart2 = istart1 + length1;
-        const BYTE* const istart3 = istart2 + length2;
-        const BYTE* const istart4 = istart3 + length3;
-        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;
-        DTableDesc const dtd = HUF_getDTableDesc(DTable);
-        U32 const dtLog = dtd.tableLog;
+ 
+        /* Init */ 
+        BIT_DStream_t bitD1; 
+        BIT_DStream_t bitD2; 
+        BIT_DStream_t bitD3; 
+        BIT_DStream_t bitD4; 
+        size_t const length1 = MEM_readLE16(istart); 
+        size_t const length2 = MEM_readLE16(istart+2); 
+        size_t const length3 = MEM_readLE16(istart+4); 
+        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6); 
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */ 
+        const BYTE* const istart2 = istart1 + length1; 
+        const BYTE* const istart3 = istart2 + length2; 
+        const BYTE* const istart4 = istart3 + length3; 
+        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; 
+        DTableDesc const dtd = HUF_getDTableDesc(DTable); 
+        U32 const dtLog = dtd.tableLog; 
         U32 endSignal = 1;
-
-        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
+ 
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */ 
         if (opStart4 > oend) return ERROR(corruption_detected);      /* overflow */
         CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );
         CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );
         CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );
         CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );
-
+ 
         /* up to 16 symbols per loop (4 symbols per stream) in 64-bit mode */
         if ((size_t)(oend - op4) >= sizeof(size_t)) {
             for ( ; (endSignal) & (op4 < olimit) ; ) {
@@ -621,31 +621,31 @@ HUF_decompress4X1_usingDTable_internal_body(
                 endSignal &= BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished;
                 endSignal &= BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished;
             }
-        }
-
-        /* check corruption */
+        } 
+ 
+        /* check corruption */ 
         /* note : should not be necessary : op# advance in lock step, and we control op4.
          *        but curiously, binary generated by gcc 7.2 & 7.3 with -mbmi2 runs faster when >=1 test is present */
-        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 */
+        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_decodeStreamX1(op1, &bitD1, opStart2, dt, dtLog);
         HUF_decodeStreamX1(op2, &bitD2, opStart3, dt, dtLog);
         HUF_decodeStreamX1(op3, &bitD3, opStart4, dt, dtLog);
         HUF_decodeStreamX1(op4, &bitD4, oend,     dt, dtLog);
-
-        /* check */
+ 
+        /* check */ 
         { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
           if (!endCheck) return ERROR(corruption_detected); }
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
+ 
+        /* decoded size */ 
+        return dstSize; 
+    } 
+} 
+ 
 #if HUF_NEED_BMI2_FUNCTION
 static BMI2_TARGET_ATTRIBUTE
 size_t HUF_decompress4X1_usingDTable_internal_bmi2(void* dst, size_t dstSize, void const* cSrc,
@@ -653,7 +653,7 @@ size_t HUF_decompress4X1_usingDTable_internal_bmi2(void* dst, size_t dstSize, vo
     return HUF_decompress4X1_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);
 }
 #endif
-
+ 
 #if HUF_NEED_DEFAULT_FUNCTION
 static
 size_t HUF_decompress4X1_usingDTable_internal_default(void* dst, size_t dstSize, void const* cSrc,
@@ -755,17 +755,17 @@ size_t HUF_decompress1X1_usingDTable(
     const void* cSrc, size_t cSrcSize,
     const HUF_DTable* DTable)
 {
-    DTableDesc dtd = HUF_getDTableDesc(DTable);
-    if (dtd.tableType != 0) return ERROR(GENERIC);
+    DTableDesc dtd = HUF_getDTableDesc(DTable); 
+    if (dtd.tableType != 0) return ERROR(GENERIC); 
     return HUF_decompress1X1_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
-}
-
+} 
+ 
 size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
                                    const void* cSrc, size_t cSrcSize,
                                    void* workSpace, size_t wkspSize)
 {
     const BYTE* ip = (const BYTE*) cSrc;
-
+ 
     size_t const hSize = HUF_readDTableX1_wksp(DCtx, cSrc, cSrcSize, workSpace, wkspSize);
     if (HUF_isError(hSize)) return hSize;
     if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
@@ -789,16 +789,16 @@ static size_t HUF_decompress4X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size
                                    const void* cSrc, size_t cSrcSize,
                                    void* workSpace, size_t wkspSize, int bmi2)
 {
-    const BYTE* ip = (const BYTE*) cSrc;
-
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
     size_t const hSize = HUF_readDTableX1_wksp_bmi2(dctx, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
-    if (HUF_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize; cSrcSize -= hSize;
-
+    if (HUF_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; cSrcSize -= hSize; 
+ 
     return HUF_decompress4X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
-}
-
+} 
+ 
 size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
                                    const void* cSrc, size_t cSrcSize,
                                    void* workSpace, size_t wkspSize)
@@ -808,19 +808,19 @@ size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
 
 
 #endif /* HUF_FORCE_DECOMPRESS_X2 */
-
+ 
 
 #ifndef HUF_FORCE_DECOMPRESS_X1
 
-/* *************************/
-/* double-symbols decoding */
-/* *************************/
+/* *************************/ 
+/* double-symbols decoding */ 
+/* *************************/ 
 
 typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX2;  /* double-symbols decoding */
 typedef struct { BYTE symbol; } sortedSymbol_t;
 typedef U32 rankValCol_t[HUF_TABLELOG_MAX + 1];
 typedef rankValCol_t rankVal_t[HUF_TABLELOG_MAX];
-
+ 
 /**
  * Constructs a HUF_DEltX2 in a U32.
  */
@@ -844,14 +844,14 @@ static U32 HUF_buildDEltX2U32(U32 symbol, U32 nbBits, U32 baseSeq, int level)
  * Constructs a HUF_DEltX2.
  */
 static HUF_DEltX2 HUF_buildDEltX2(U32 symbol, U32 nbBits, U32 baseSeq, int level)
-{
+{ 
     HUF_DEltX2 DElt;
     U32 const val = HUF_buildDEltX2U32(symbol, nbBits, baseSeq, level);
     DEBUG_STATIC_ASSERT(sizeof(DElt) == sizeof(val));
     ZSTD_memcpy(&DElt, &val, sizeof(val));
     return DElt;
 }
-
+ 
 /**
  * Constructs 2 HUF_DEltX2s and packs them into a U64.
  */
@@ -860,7 +860,7 @@ static U64 HUF_buildDEltX2U64(U32 symbol, U32 nbBits, U16 baseSeq, int level)
     U32 DElt = HUF_buildDEltX2U32(symbol, nbBits, baseSeq, level);
     return (U64)DElt + ((U64)DElt << 32);
 }
-
+ 
 /**
  * Fills the DTable rank with all the symbols from [begin, end) that are each
  * nbBits long.
@@ -941,7 +941,7 @@ static void HUF_fillDTableX2Level2(HUF_DEltX2* DTable, U32 targetLog, const U32
      * These are positions only get a single symbol because the combined weight
      * is too large.
      */
-    if (minWeight>1) {
+    if (minWeight>1) { 
         U32 const length = 1U << ((targetLog - consumedBits) & 0x1F /* quiet static-analyzer */);
         U64 const DEltX2 = HUF_buildDEltX2U64(baseSeq, consumedBits, /* baseSeq */ 0, /* level */ 1);
         int const skipSize = rankVal[minWeight];
@@ -968,8 +968,8 @@ static void HUF_fillDTableX2Level2(HUF_DEltX2* DTable, U32 targetLog, const U32
                 }
             }
         }
-    }
-
+    } 
+ 
     /* Fill each of the second level symbols by weight. */
     {
         int w;
@@ -985,32 +985,32 @@ static void HUF_fillDTableX2Level2(HUF_DEltX2* DTable, U32 targetLog, const U32
                 baseSeq, /* level */ 2);
         }
     }
-}
-
+} 
+ 
 static void HUF_fillDTableX2(HUF_DEltX2* DTable, const U32 targetLog,
                            const sortedSymbol_t* sortedList,
-                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,
+                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight, 
                            const U32 nbBitsBaseline)
-{
+{ 
     U32* const rankVal = rankValOrigin[0];
-    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */
-    const U32 minBits  = nbBitsBaseline - maxWeight;
+    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */ 
+    const U32 minBits  = nbBitsBaseline - maxWeight; 
     int w;
     int const wEnd = (int)maxWeight + 1;
-
+ 
     /* Fill DTable in order of weight. */
     for (w = 1; w < wEnd; ++w) {
         int const begin = (int)rankStart[w];
         int const end = (int)rankStart[w+1];
         U32 const nbBits = nbBitsBaseline - w;
-
+ 
         if (targetLog-nbBits >= minBits) {
             /* Enough room for a second symbol. */
             int start = rankVal[w];
             U32 const length = 1U << ((targetLog - nbBits) & 0x1F /* quiet static-analyzer */);
-            int minWeight = nbBits + scaleLog;
+            int minWeight = nbBits + scaleLog; 
             int s;
-            if (minWeight < 1) minWeight = 1;
+            if (minWeight < 1) minWeight = 1; 
             /* Fill the DTable for every symbol of weight w.
              * These symbols get at least 1 second symbol.
              */
@@ -1022,7 +1022,7 @@ static void HUF_fillDTableX2(HUF_DEltX2* DTable, const U32 targetLog,
                     nbBitsBaseline, sortedList[s].symbol);
                 start += length;
             }
-        } else {
+        } else { 
             /* Only a single symbol. */
             HUF_fillDTableX2ForWeight(
                 DTable + rankVal[w],
@@ -1030,9 +1030,9 @@ static void HUF_fillDTableX2(HUF_DEltX2* DTable, const U32 targetLog,
                 nbBits, targetLog,
                 /* baseSeq */ 0, /* level */ 1);
         }
-    }
-}
-
+    } 
+} 
+ 
 typedef struct {
     rankValCol_t rankVal[HUF_TABLELOG_MAX];
     U32 rankStats[HUF_TABLELOG_MAX + 1];
@@ -1045,7 +1045,7 @@ typedef struct {
 size_t HUF_readDTableX2_wksp(HUF_DTable* DTable,
                        const void* src, size_t srcSize,
                              void* workSpace, size_t wkspSize)
-{
+{ 
     return HUF_readDTableX2_wksp_bmi2(DTable, src, srcSize, workSpace, wkspSize, /* bmi2 */ 0);
 }
 
@@ -1054,13 +1054,13 @@ size_t HUF_readDTableX2_wksp_bmi2(HUF_DTable* DTable,
                              void* workSpace, size_t wkspSize, int bmi2)
 {
     U32 tableLog, maxW, nbSymbols;
-    DTableDesc dtd = HUF_getDTableDesc(DTable);
+    DTableDesc dtd = HUF_getDTableDesc(DTable); 
     U32 maxTableLog = dtd.maxTableLog;
-    size_t iSize;
-    void* dtPtr = DTable+1;   /* force compiler to avoid strict-aliasing */
+    size_t iSize; 
+    void* dtPtr = DTable+1;   /* force compiler to avoid strict-aliasing */ 
     HUF_DEltX2* const dt = (HUF_DEltX2*)dtPtr;
     U32 *rankStart;
-
+ 
     HUF_ReadDTableX2_Workspace* const wksp = (HUF_ReadDTableX2_Workspace*)workSpace;
 
     if (sizeof(*wksp) > wkspSize) return ERROR(GENERIC);
@@ -1072,69 +1072,69 @@ size_t HUF_readDTableX2_wksp_bmi2(HUF_DTable* DTable,
     DEBUG_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(HUF_DTable));   /* if compiler fails here, assertion is wrong */
     if (maxTableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);
     /* ZSTD_memset(weightList, 0, sizeof(weightList)); */  /* is not necessary, even though some analyzer complain ... */
-
+ 
     iSize = HUF_readStats_wksp(wksp->weightList, HUF_SYMBOLVALUE_MAX + 1, wksp->rankStats, &nbSymbols, &tableLog, src, srcSize, wksp->calleeWksp, sizeof(wksp->calleeWksp), bmi2);
-    if (HUF_isError(iSize)) return iSize;
-
-    /* check result */
-    if (tableLog > maxTableLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */
+    if (HUF_isError(iSize)) return iSize; 
+ 
+    /* check result */ 
+    if (tableLog > maxTableLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */ 
     if (tableLog <= HUF_DECODER_FAST_TABLELOG && maxTableLog > HUF_DECODER_FAST_TABLELOG) maxTableLog = HUF_DECODER_FAST_TABLELOG;
-
-    /* find maxWeight */
+ 
+    /* find maxWeight */ 
     for (maxW = tableLog; wksp->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+1; w++) {
+ 
+    /* Get start index of each weight */ 
+    {   U32 w, nextRankStart = 0; 
+        for (w=1; w<maxW+1; w++) { 
             U32 curr = nextRankStart;
             nextRankStart += wksp->rankStats[w];
             rankStart[w] = curr;
-        }
-        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/
+        } 
+        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/ 
         rankStart[maxW+1] = nextRankStart;
-    }
-
-    /* sort symbols by weight */
-    {   U32 s;
-        for (s=0; s<nbSymbols; s++) {
+    } 
+ 
+    /* sort symbols by weight */ 
+    {   U32 s; 
+        for (s=0; s<nbSymbols; s++) { 
             U32 const w = wksp->weightList[s];
-            U32 const r = rankStart[w]++;
+            U32 const r = rankStart[w]++; 
             wksp->sortedSymbol[r].symbol = (BYTE)s;
-        }
-        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */
-    }
-
-    /* Build rankVal */
+        } 
+        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */ 
+    } 
+ 
+    /* Build rankVal */ 
     {   U32* const rankVal0 = wksp->rankVal[0];
-        {   int const rescale = (maxTableLog-tableLog) - 1;   /* tableLog <= maxTableLog */
-            U32 nextRankVal = 0;
-            U32 w;
-            for (w=1; w<maxW+1; w++) {
+        {   int const rescale = (maxTableLog-tableLog) - 1;   /* tableLog <= maxTableLog */ 
+            U32 nextRankVal = 0; 
+            U32 w; 
+            for (w=1; w<maxW+1; w++) { 
                 U32 curr = nextRankVal;
                 nextRankVal += wksp->rankStats[w] << (w+rescale);
                 rankVal0[w] = curr;
-        }   }
-        {   U32 const minBits = tableLog+1 - maxW;
-            U32 consumed;
-            for (consumed = minBits; consumed < maxTableLog - minBits + 1; consumed++) {
+        }   } 
+        {   U32 const minBits = tableLog+1 - maxW; 
+            U32 consumed; 
+            for (consumed = minBits; consumed < maxTableLog - minBits + 1; consumed++) { 
                 U32* const rankValPtr = wksp->rankVal[consumed];
-                U32 w;
-                for (w = 1; w < maxW+1; w++) {
-                    rankValPtr[w] = rankVal0[w] >> consumed;
-    }   }   }   }
-
+                U32 w; 
+                for (w = 1; w < maxW+1; w++) { 
+                    rankValPtr[w] = rankVal0[w] >> consumed; 
+    }   }   }   } 
+ 
     HUF_fillDTableX2(dt, maxTableLog,
                    wksp->sortedSymbol,
                    wksp->rankStart0, wksp->rankVal, maxW,
                    tableLog+1);
-
-    dtd.tableLog = (BYTE)maxTableLog;
-    dtd.tableType = 1;
+ 
+    dtd.tableLog = (BYTE)maxTableLog; 
+    dtd.tableType = 1; 
     ZSTD_memcpy(DTable, &dtd, sizeof(dtd));
-    return iSize;
-}
-
-
+    return iSize; 
+} 
+ 
+ 
 FORCE_INLINE_TEMPLATE U32
 HUF_decodeSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
 {
@@ -1220,10 +1220,10 @@ HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd,
 
 FORCE_INLINE_TEMPLATE size_t
 HUF_decompress1X2_usingDTable_internal_body(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUF_DTable* DTable)
-{
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const HUF_DTable* DTable) 
+{ 
     BIT_DStream_t bitD;
 
     /* Init */
@@ -1461,52 +1461,52 @@ size_t HUF_decompress1X2_usingDTable(
     const void* cSrc, size_t cSrcSize,
     const HUF_DTable* DTable)
 {
-    DTableDesc dtd = HUF_getDTableDesc(DTable);
-    if (dtd.tableType != 1) return ERROR(GENERIC);
+    DTableDesc dtd = HUF_getDTableDesc(DTable); 
+    if (dtd.tableType != 1) return ERROR(GENERIC); 
     return HUF_decompress1X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
-}
-
+} 
+ 
 size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
                                    const void* cSrc, size_t cSrcSize,
                                    void* workSpace, size_t wkspSize)
-{
-    const BYTE* ip = (const BYTE*) cSrc;
-
+{ 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
     size_t const hSize = HUF_readDTableX2_wksp(DCtx, cSrc, cSrcSize,
                                                workSpace, wkspSize);
-    if (HUF_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize; cSrcSize -= hSize;
-
+    if (HUF_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; cSrcSize -= hSize; 
+ 
     return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0);
-}
-
+} 
+ 
 
 size_t HUF_decompress4X2_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUF_DTable* DTable)
-{
-    DTableDesc dtd = HUF_getDTableDesc(DTable);
-    if (dtd.tableType != 1) return ERROR(GENERIC);
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const HUF_DTable* DTable) 
+{ 
+    DTableDesc dtd = HUF_getDTableDesc(DTable); 
+    if (dtd.tableType != 1) return ERROR(GENERIC); 
     return HUF_decompress4X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
-}
-
+} 
+ 
 static size_t HUF_decompress4X2_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
                                    const void* cSrc, size_t cSrcSize,
                                    void* workSpace, size_t wkspSize, int bmi2)
-{
-    const BYTE* ip = (const BYTE*) cSrc;
-
+{ 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
     size_t hSize = HUF_readDTableX2_wksp(dctx, cSrc, cSrcSize,
                                          workSpace, wkspSize);
-    if (HUF_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize; cSrcSize -= hSize;
-
+    if (HUF_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; cSrcSize -= hSize; 
+ 
     return HUF_decompress4X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
-}
-
+} 
+ 
 size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
                                    const void* cSrc, size_t cSrcSize,
                                    void* workSpace, size_t wkspSize)
@@ -1516,17 +1516,17 @@ size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
 
 
 #endif /* HUF_FORCE_DECOMPRESS_X1 */
-
-
+ 
+ 
 /* ***********************************/
 /* Universal decompression selectors */
 /* ***********************************/
 
-size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize,
-                                    const void* cSrc, size_t cSrcSize,
-                                    const HUF_DTable* DTable)
-{
-    DTableDesc const dtd = HUF_getDTableDesc(DTable);
+size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, 
+                                    const void* cSrc, size_t cSrcSize, 
+                                    const HUF_DTable* DTable) 
+{ 
+    DTableDesc const dtd = HUF_getDTableDesc(DTable); 
 #if defined(HUF_FORCE_DECOMPRESS_X1)
     (void)dtd;
     assert(dtd.tableType == 0);
@@ -1539,13 +1539,13 @@ size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize,
     return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
                            HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
 #endif
-}
-
-size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize,
-                                    const void* cSrc, size_t cSrcSize,
-                                    const HUF_DTable* DTable)
-{
-    DTableDesc const dtd = HUF_getDTableDesc(DTable);
+} 
+ 
+size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, 
+                                    const void* cSrc, size_t cSrcSize, 
+                                    const HUF_DTable* DTable) 
+{ 
+    DTableDesc const dtd = HUF_getDTableDesc(DTable); 
 #if defined(HUF_FORCE_DECOMPRESS_X1)
     (void)dtd;
     assert(dtd.tableType == 0);
@@ -1558,14 +1558,14 @@ size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize,
     return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
                            HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
 #endif
-}
-
-
+} 
+ 
+ 
 #if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
-typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
+typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t; 
 static const algo_time_t algoTime[16 /* Quantization */][2 /* single, double */] =
-{
-    /* single, double, quad */
+{ 
+    /* single, double, quad */ 
     {{0,0}, {1,1}},  /* Q==0 : impossible */
     {{0,0}, {1,1}},  /* Q==1 : impossible */
     {{ 150,216}, { 381,119}},   /* Q == 2 : 12-18% */
@@ -1582,16 +1582,16 @@ static const algo_time_t algoTime[16 /* Quantization */][2 /* single, double */]
     {{1180,186}, {2070,175}},   /* Q ==13 : 81-87% */
     {{1377,185}, {1731,202}},   /* Q ==14 : 87-93% */
     {{1412,185}, {1695,202}},   /* Q ==15 : 93-99% */
-};
+}; 
 #endif
-
-/** HUF_selectDecoder() :
+ 
+/** HUF_selectDecoder() : 
  *  Tells which decoder is likely to decode faster,
  *  based on a set of pre-computed metrics.
  * @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 .
  *  Assumption : 0 < dstSize <= 128 KB */
-U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)
-{
+U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize) 
+{ 
     assert(dstSize > 0);
     assert(dstSize <= 128*1024);
 #if defined(HUF_FORCE_DECOMPRESS_X1)
@@ -1603,7 +1603,7 @@ U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)
     (void)cSrcSize;
     return 1;
 #else
-    /* decoder timing evaluation */
+    /* decoder timing evaluation */ 
     {   U32 const Q = (cSrcSize >= dstSize) ? 15 : (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 */
         U32 const D256 = (U32)(dstSize >> 8);
         U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256);
@@ -1613,18 +1613,18 @@ U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)
     }
 #endif
 }
-
-
+ 
+ 
 size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst,
                                      size_t dstSize, const void* cSrc,
                                      size_t cSrcSize, void* workSpace,
                                      size_t wkspSize)
 {
-    /* validation checks */
-    if (dstSize == 0) return ERROR(dstSize_tooSmall);
+    /* validation checks */ 
+    if (dstSize == 0) return ERROR(dstSize_tooSmall); 
     if (cSrcSize == 0) return ERROR(corruption_detected);
-
-    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
+ 
+    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize); 
 #if defined(HUF_FORCE_DECOMPRESS_X1)
         (void)algoNb;
         assert(algoNb == 0);
@@ -1638,20 +1638,20 @@ size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst,
                             cSrcSize, workSpace, wkspSize):
                         HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
 #endif
-    }
-}
-
+    } 
+} 
+ 
 size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
                                   const void* cSrc, size_t cSrcSize,
                                   void* workSpace, size_t wkspSize)
-{
-    /* validation checks */
-    if (dstSize == 0) return ERROR(dstSize_tooSmall);
-    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
+{ 
+    /* validation checks */ 
+    if (dstSize == 0) return ERROR(dstSize_tooSmall); 
+    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */ 
     if (cSrcSize == dstSize) { ZSTD_memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
     if (cSrcSize == 1) { ZSTD_memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */
-
-    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
+ 
+    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize); 
 #if defined(HUF_FORCE_DECOMPRESS_X1)
         (void)algoNb;
         assert(algoNb == 0);
@@ -1668,8 +1668,8 @@ size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
                         HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
                                 cSrcSize, workSpace, wkspSize);
 #endif
-    }
-}
+    } 
+} 
 
 
 size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
diff --git a/contrib/libs/zstd/lib/decompress/zstd_decompress.c b/contrib/libs/zstd/lib/decompress/zstd_decompress.c
index b8bbefd538..d94e6e3286 100644
--- a/contrib/libs/zstd/lib/decompress/zstd_decompress.c
+++ b/contrib/libs/zstd/lib/decompress/zstd_decompress.c
@@ -7,29 +7,29 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-
-/* ***************************************************************
-*  Tuning parameters
-*****************************************************************/
-/*!
- * HEAPMODE :
+ 
+ 
+/* *************************************************************** 
+*  Tuning parameters 
+*****************************************************************/ 
+/*! 
+ * HEAPMODE : 
  * Select how default decompression function ZSTD_decompress() allocates its context,
  * on stack (0), or into heap (1, default; requires malloc()).
  * Note that functions with explicit context such as ZSTD_decompressDCtx() are unaffected.
- */
-#ifndef ZSTD_HEAPMODE
-#  define ZSTD_HEAPMODE 1
-#endif
-
-/*!
-*  LEGACY_SUPPORT :
+ */ 
+#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
-
+*/ 
+#ifndef ZSTD_LEGACY_SUPPORT 
+#  define ZSTD_LEGACY_SUPPORT 0 
+#endif 
+ 
 /*!
  *  MAXWINDOWSIZE_DEFAULT :
  *  maximum window size accepted by DStream __by default__.
@@ -39,7 +39,7 @@
 #ifndef ZSTD_MAXWINDOWSIZE_DEFAULT
 #  define ZSTD_MAXWINDOWSIZE_DEFAULT (((U32)1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT) + 1)
 #endif
-
+ 
 /*!
  *  NO_FORWARD_PROGRESS_MAX :
  *  maximum allowed nb of calls to ZSTD_decompressStream()
@@ -52,26 +52,26 @@
 #endif
 
 
-/*-*******************************************************
-*  Dependencies
-*********************************************************/
+/*-******************************************************* 
+*  Dependencies 
+*********************************************************/ 
 #include "../common/zstd_deps.h"   /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */
 #include "../common/mem.h"         /* low level memory routines */
-#define FSE_STATIC_LINKING_ONLY
+#define FSE_STATIC_LINKING_ONLY 
 #include "../common/fse.h"
-#define HUF_STATIC_LINKING_ONLY
+#define HUF_STATIC_LINKING_ONLY 
 #include "../common/huf.h"
 #include <contrib/libs/xxhash/xxhash.h> /* XXH64_reset, XXH64_update, XXH64_digest, XXH64 */
 #include "../common/zstd_internal.h"  /* blockProperties_t */
 #include "zstd_decompress_internal.h"   /* ZSTD_DCtx */
 #include "zstd_ddict.h"  /* ZSTD_DDictDictContent */
 #include "zstd_decompress_block.h"   /* ZSTD_decompressBlock_internal */
-
-#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)
+ 
+#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1) 
 #  include "../legacy/zstd_legacy.h"
-#endif
-
-
+#endif 
+ 
+ 
 
 /*************************************
  * Multiple DDicts Hashset internals *
@@ -213,9 +213,9 @@ static size_t ZSTD_DDictHashSet_addDDict(ZSTD_DDictHashSet* hashSet, const ZSTD_
     return 0;
 }
 
-/*-*************************************************************
-*   Context management
-***************************************************************/
+/*-************************************************************* 
+*   Context management 
+***************************************************************/ 
 size_t ZSTD_sizeof_DCtx (const ZSTD_DCtx* dctx)
 {
     if (dctx==NULL) return 0;   /* support sizeof NULL */
@@ -223,18 +223,18 @@ size_t ZSTD_sizeof_DCtx (const ZSTD_DCtx* dctx)
            + ZSTD_sizeof_DDict(dctx->ddictLocal)
            + dctx->inBuffSize + dctx->outBuffSize;
 }
-
-size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); }
-
+ 
+size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); } 
+ 
 
 static size_t ZSTD_startingInputLength(ZSTD_format_e format)
-{
+{ 
     size_t const startingInputLength = ZSTD_FRAMEHEADERSIZE_PREFIX(format);
     /* only supports formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless */
     assert( (format == ZSTD_f_zstd1) || (format == ZSTD_f_zstd1_magicless) );
     return startingInputLength;
-}
-
+} 
+ 
 static void ZSTD_DCtx_resetParameters(ZSTD_DCtx* dctx)
 {
     assert(dctx->streamStage == zdss_init);
@@ -246,7 +246,7 @@ static void ZSTD_DCtx_resetParameters(ZSTD_DCtx* dctx)
 }
 
 static void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx)
-{
+{ 
     dctx->staticSize  = 0;
     dctx->ddict       = NULL;
     dctx->ddictLocal  = NULL;
@@ -272,20 +272,20 @@ static void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx)
     dctx->dictContentEndForFuzzing = NULL;
 #endif
 }
-
+ 
 ZSTD_DCtx* ZSTD_initStaticDCtx(void *workspace, size_t workspaceSize)
 {
     ZSTD_DCtx* const dctx = (ZSTD_DCtx*) workspace;
-
+ 
     if ((size_t)workspace & 7) return NULL;  /* 8-aligned */
     if (workspaceSize < sizeof(ZSTD_DCtx)) return NULL;  /* minimum size */
 
     ZSTD_initDCtx_internal(dctx);
     dctx->staticSize = workspaceSize;
     dctx->inBuff = (char*)(dctx+1);
-    return dctx;
-}
-
+    return dctx; 
+} 
+ 
 static ZSTD_DCtx* ZSTD_createDCtx_internal(ZSTD_customMem customMem) {
     if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;
 
@@ -302,12 +302,12 @@ ZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem)
     return ZSTD_createDCtx_internal(customMem);
 }
 
-ZSTD_DCtx* ZSTD_createDCtx(void)
-{
+ZSTD_DCtx* ZSTD_createDCtx(void) 
+{ 
     DEBUGLOG(3, "ZSTD_createDCtx");
     return ZSTD_createDCtx_internal(ZSTD_defaultCMem);
-}
-
+} 
+ 
 static void ZSTD_clearDict(ZSTD_DCtx* dctx)
 {
     ZSTD_freeDDict(dctx->ddictLocal);
@@ -316,9 +316,9 @@ static void ZSTD_clearDict(ZSTD_DCtx* dctx)
     dctx->dictUses = ZSTD_dont_use;
 }
 
-size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
-{
-    if (dctx==NULL) return 0;   /* support free on NULL */
+size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx) 
+{ 
+    if (dctx==NULL) return 0;   /* support free on NULL */ 
     RETURN_ERROR_IF(dctx->staticSize, memory_allocation, "not compatible with static DCtx");
     {   ZSTD_customMem const cMem = dctx->customMem;
         ZSTD_clearDict(dctx);
@@ -335,15 +335,15 @@ size_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)
         ZSTD_customFree(dctx, cMem);
         return 0;
     }
-}
-
+} 
+ 
 /* no longer useful */
-void ZSTD_copyDCtx(ZSTD_DCtx* dstDCtx, const ZSTD_DCtx* srcDCtx)
-{
+void ZSTD_copyDCtx(ZSTD_DCtx* dstDCtx, const ZSTD_DCtx* srcDCtx) 
+{ 
     size_t const toCopy = (size_t)((char*)(&dstDCtx->inBuff) - (char*)dstDCtx);
     ZSTD_memcpy(dstDCtx, srcDCtx, toCopy);  /* no need to copy workspace */
-}
-
+} 
+ 
 /* Given a dctx with a digested frame params, re-selects the correct ZSTD_DDict based on
  * the requested dict ID from the frame. If there exists a reference to the correct ZSTD_DDict, then
  * accordingly sets the ddict to be used to decompress the frame.
@@ -366,12 +366,12 @@ static void ZSTD_DCtx_selectFrameDDict(ZSTD_DCtx* dctx) {
         }
     }
 }
+ 
 
-
-/*-*************************************************************
+/*-************************************************************* 
  *   Frame header decoding
  ***************************************************************/
-
+ 
 /*! ZSTD_isFrame() :
  *  Tells if the content of `buffer` starts with a valid Frame Identifier.
  *  Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
@@ -389,7 +389,7 @@ unsigned ZSTD_isFrame(const void* buffer, size_t size)
 #endif
     return 0;
 }
-
+ 
 /*! ZSTD_isSkippableFrame() :
  *  Tells if the content of `buffer` starts with a valid Frame Identifier for a skippable frame.
  *  Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.
@@ -414,15 +414,15 @@ static size_t ZSTD_frameHeaderSize_internal(const void* src, size_t srcSize, ZST
     RETURN_ERROR_IF(srcSize < minInputSize, srcSize_wrong, "");
 
     {   BYTE const fhd = ((const BYTE*)src)[minInputSize-1];
-        U32 const dictID= fhd & 3;
-        U32 const singleSegment = (fhd >> 5) & 1;
-        U32 const fcsId = fhd >> 6;
+        U32 const dictID= fhd & 3; 
+        U32 const singleSegment = (fhd >> 5) & 1; 
+        U32 const fcsId = fhd >> 6; 
         return minInputSize + !singleSegment
              + ZSTD_did_fieldSize[dictID] + ZSTD_fcs_fieldSize[fcsId]
              + (singleSegment && !fcsId);
-    }
-}
-
+    } 
+} 
+ 
 /** ZSTD_frameHeaderSize() :
  *  srcSize must be >= ZSTD_frameHeaderSize_prefix.
  * @return : size of the Frame Header,
@@ -431,7 +431,7 @@ size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize)
 {
     return ZSTD_frameHeaderSize_internal(src, srcSize, ZSTD_f_zstd1);
 }
-
+ 
 
 /** ZSTD_getFrameHeader_advanced() :
  *  decode Frame Header, or require larger `srcSize`.
@@ -440,10 +440,10 @@ size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize)
  *          >0, `srcSize` is too small, value is wanted `srcSize` amount,
  *           or an error code, which can be tested using ZSTD_isError() */
 size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format)
-{
-    const BYTE* ip = (const BYTE*)src;
+{ 
+    const BYTE* ip = (const BYTE*)src; 
     size_t const minInputSize = ZSTD_startingInputLength(format);
-
+ 
     ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr));   /* not strictly necessary, but static analyzer do not understand that zfhPtr is only going to be read only if return value is zero, since they are 2 different signals */
     if (srcSize < minInputSize) return minInputSize;
     RETURN_ERROR_IF(src==NULL, GENERIC, "invalid parameter");
@@ -457,56 +457,56 @@ size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, s
             ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr));
             zfhPtr->frameContentSize = MEM_readLE32((const char *)src + ZSTD_FRAMEIDSIZE);
             zfhPtr->frameType = ZSTD_skippableFrame;
-            return 0;
-        }
+            return 0; 
+        } 
         RETURN_ERROR(prefix_unknown, "");
-    }
-
-    /* ensure there is enough `srcSize` to fully read/decode frame header */
+    } 
+ 
+    /* ensure there is enough `srcSize` to fully read/decode frame header */ 
     {   size_t const fhsize = ZSTD_frameHeaderSize_internal(src, srcSize, format);
         if (srcSize < fhsize) return fhsize;
         zfhPtr->headerSize = (U32)fhsize;
     }
-
+ 
     {   BYTE const fhdByte = ip[minInputSize-1];
         size_t pos = minInputSize;
-        U32 const dictIDSizeCode = fhdByte&3;
-        U32 const checksumFlag = (fhdByte>>2)&1;
-        U32 const singleSegment = (fhdByte>>5)&1;
-        U32 const fcsID = fhdByte>>6;
+        U32 const dictIDSizeCode = fhdByte&3; 
+        U32 const checksumFlag = (fhdByte>>2)&1; 
+        U32 const singleSegment = (fhdByte>>5)&1; 
+        U32 const fcsID = fhdByte>>6; 
         U64 windowSize = 0;
-        U32 dictID = 0;
+        U32 dictID = 0; 
         U64 frameContentSize = ZSTD_CONTENTSIZE_UNKNOWN;
         RETURN_ERROR_IF((fhdByte & 0x08) != 0, frameParameter_unsupported,
                         "reserved bits, must be zero");
 
-        if (!singleSegment) {
-            BYTE const wlByte = ip[pos++];
-            U32 const windowLog = (wlByte >> 3) + ZSTD_WINDOWLOG_ABSOLUTEMIN;
+        if (!singleSegment) { 
+            BYTE const wlByte = ip[pos++]; 
+            U32 const windowLog = (wlByte >> 3) + ZSTD_WINDOWLOG_ABSOLUTEMIN; 
             RETURN_ERROR_IF(windowLog > ZSTD_WINDOWLOG_MAX, frameParameter_windowTooLarge, "");
             windowSize = (1ULL << windowLog);
-            windowSize += (windowSize >> 3) * (wlByte&7);
-        }
-        switch(dictIDSizeCode)
-        {
+            windowSize += (windowSize >> 3) * (wlByte&7); 
+        } 
+        switch(dictIDSizeCode) 
+        { 
             default:
                 assert(0);  /* impossible */
                 ZSTD_FALLTHROUGH;
-            case 0 : break;
-            case 1 : dictID = ip[pos]; pos++; break;
-            case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break;
-            case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break;
-        }
-        switch(fcsID)
-        {
+            case 0 : break; 
+            case 1 : dictID = ip[pos]; pos++; break; 
+            case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break; 
+            case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break; 
+        } 
+        switch(fcsID) 
+        { 
             default:
                 assert(0);  /* impossible */
                 ZSTD_FALLTHROUGH;
-            case 0 : if (singleSegment) frameContentSize = ip[pos]; break;
-            case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break;
-            case 2 : frameContentSize = MEM_readLE32(ip+pos); break;
-            case 3 : frameContentSize = MEM_readLE64(ip+pos); break;
-        }
+            case 0 : if (singleSegment) frameContentSize = ip[pos]; break; 
+            case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break; 
+            case 2 : frameContentSize = MEM_readLE32(ip+pos); break; 
+            case 3 : frameContentSize = MEM_readLE64(ip+pos); break; 
+        } 
         if (singleSegment) windowSize = frameContentSize;
 
         zfhPtr->frameType = ZSTD_frame;
@@ -515,10 +515,10 @@ size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, s
         zfhPtr->blockSizeMax = (unsigned) MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
         zfhPtr->dictID = dictID;
         zfhPtr->checksumFlag = checksumFlag;
-    }
-    return 0;
-}
-
+    } 
+    return 0; 
+} 
+ 
 /** ZSTD_getFrameHeader() :
  *  decode Frame Header, or require larger `srcSize`.
  *  note : this function does not consume input, it only reads it.
@@ -529,7 +529,7 @@ size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t src
 {
     return ZSTD_getFrameHeader_advanced(zfhPtr, src, srcSize, ZSTD_f_zstd1);
 }
-
+ 
 /** ZSTD_getFrameContentSize() :
  *  compatible with legacy mode
  * @return : decompressed size of the single frame pointed to be `src` if known, otherwise
@@ -647,28 +647,28 @@ unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize)
     return totalDstSize;
 }
 
-/** ZSTD_getDecompressedSize() :
+/** ZSTD_getDecompressedSize() : 
  *  compatible with legacy mode
  * @return : decompressed size if known, 0 otherwise
              note : 0 can mean any of the following :
                    - frame content is empty
                    - decompressed size field is not present in frame header
-                   - frame header unknown / not supported
-                   - frame header not complete (`srcSize` too small) */
-unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize)
-{
+                   - frame header unknown / not supported 
+                   - frame header not complete (`srcSize` too small) */ 
+unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize) 
+{ 
     unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize);
     ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_ERROR < ZSTD_CONTENTSIZE_UNKNOWN);
     return (ret >= ZSTD_CONTENTSIZE_ERROR) ? 0 : ret;
-}
-
-
-/** ZSTD_decodeFrameHeader() :
+} 
+ 
+ 
+/** ZSTD_decodeFrameHeader() : 
  * `headerSize` must be the size provided by ZSTD_frameHeaderSize().
  * If multiple DDict references are enabled, also will choose the correct DDict to use.
  * @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */
 static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t headerSize)
-{
+{ 
     size_t const result = ZSTD_getFrameHeader_advanced(&(dctx->fParams), src, headerSize, dctx->format);
     if (ZSTD_isError(result)) return result;    /* invalid header */
     RETURN_ERROR_IF(result>0, srcSize_wrong, "headerSize too small");
@@ -689,26 +689,26 @@ static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t he
     if (dctx->validateChecksum) XXH64_reset(&dctx->xxhState, 0);
     dctx->processedCSize += headerSize;
     return 0;
-}
-
+} 
+ 
 static ZSTD_frameSizeInfo ZSTD_errorFrameSizeInfo(size_t ret)
-{
+{ 
     ZSTD_frameSizeInfo frameSizeInfo;
     frameSizeInfo.compressedSize = ret;
     frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;
     return frameSizeInfo;
-}
-
+} 
+ 
 static ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo(const void* src, size_t srcSize)
-{
+{ 
     ZSTD_frameSizeInfo frameSizeInfo;
     ZSTD_memset(&frameSizeInfo, 0, sizeof(ZSTD_frameSizeInfo));
-
+ 
 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
     if (ZSTD_isLegacy(src, srcSize))
         return ZSTD_findFrameSizeInfoLegacy(src, srcSize);
 #endif
-
+ 
     if ((srcSize >= ZSTD_SKIPPABLEHEADERSIZE)
         && (MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
         frameSizeInfo.compressedSize = readSkippableFrameSize(src, srcSize);
@@ -721,18 +721,18 @@ static ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo(const void* src, size_t srcSize
         size_t remainingSize = srcSize;
         size_t nbBlocks = 0;
         ZSTD_frameHeader zfh;
-
+ 
         /* Extract Frame Header */
         {   size_t const ret = ZSTD_getFrameHeader(&zfh, src, srcSize);
             if (ZSTD_isError(ret))
                 return ZSTD_errorFrameSizeInfo(ret);
             if (ret > 0)
                 return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
-        }
-
+        } 
+ 
         ip += zfh.headerSize;
         remainingSize -= zfh.headerSize;
-
+ 
         /* Iterate over each block */
         while (1) {
             blockProperties_t blockProperties;
@@ -749,22 +749,22 @@ static ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo(const void* src, size_t srcSize
 
             if (blockProperties.lastBlock) break;
         }
-
+ 
         /* Final frame content checksum */
         if (zfh.checksumFlag) {
             if (remainingSize < 4)
                 return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));
             ip += 4;
-        }
-
+        } 
+ 
         frameSizeInfo.compressedSize = (size_t)(ip - ipstart);
         frameSizeInfo.decompressedBound = (zfh.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN)
                                         ? zfh.frameContentSize
                                         : nbBlocks * zfh.blockSizeMax;
         return frameSizeInfo;
     }
-}
-
+} 
+ 
 /** ZSTD_findFrameCompressedSize() :
  *  compatible with legacy mode
  *  `src` must point to the start of a ZSTD frame, ZSTD legacy frame, or skippable frame
@@ -800,25 +800,25 @@ unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize)
     return bound;
 }
 
-
+ 
 /*-*************************************************************
  *   Frame decoding
  ***************************************************************/
-
-/** ZSTD_insertBlock() :
+ 
+/** ZSTD_insertBlock() : 
  *  insert `src` block into `dctx` history. Useful to track uncompressed blocks. */
 size_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize)
-{
+{ 
     DEBUGLOG(5, "ZSTD_insertBlock: %u bytes", (unsigned)blockSize);
     ZSTD_checkContinuity(dctx, blockStart, blockSize);
-    dctx->previousDstEnd = (const char*)blockStart + blockSize;
-    return blockSize;
-}
-
-
+    dctx->previousDstEnd = (const char*)blockStart + blockSize; 
+    return blockSize; 
+} 
+ 
+ 
 static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,
                           const void* src, size_t srcSize)
-{
+{ 
     DEBUGLOG(5, "ZSTD_copyRawBlock");
     RETURN_ERROR_IF(srcSize > dstCapacity, dstSize_tooSmall, "");
     if (dst == NULL) {
@@ -827,8 +827,8 @@ static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,
     }
     ZSTD_memcpy(dst, src, srcSize);
     return srcSize;
-}
-
+} 
+ 
 static size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity,
                                BYTE b,
                                size_t regenSize)
@@ -869,76 +869,76 @@ static void ZSTD_DCtx_trace_end(ZSTD_DCtx const* dctx, U64 uncompressedSize, U64
 }
 
 
-/*! ZSTD_decompressFrame() :
+/*! ZSTD_decompressFrame() : 
  * @dctx must be properly initialized
  *  will update *srcPtr and *srcSizePtr,
  *  to make *srcPtr progress by one frame. */
-static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
+static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx, 
                                    void* dst, size_t dstCapacity,
                              const void** srcPtr, size_t *srcSizePtr)
-{
+{ 
     const BYTE* const istart = (const BYTE*)(*srcPtr);
     const BYTE* ip = istart;
     BYTE* const ostart = (BYTE*)dst;
     BYTE* const oend = dstCapacity != 0 ? ostart + dstCapacity : ostart;
-    BYTE* op = ostart;
+    BYTE* op = ostart; 
     size_t remainingSrcSize = *srcSizePtr;
-
+ 
     DEBUGLOG(4, "ZSTD_decompressFrame (srcSize:%i)", (int)*srcSizePtr);
 
-    /* check */
+    /* check */ 
     RETURN_ERROR_IF(
         remainingSrcSize < ZSTD_FRAMEHEADERSIZE_MIN(dctx->format)+ZSTD_blockHeaderSize,
         srcSize_wrong, "");
-
-    /* Frame Header */
+ 
+    /* Frame Header */ 
     {   size_t const frameHeaderSize = ZSTD_frameHeaderSize_internal(
                 ip, ZSTD_FRAMEHEADERSIZE_PREFIX(dctx->format), dctx->format);
-        if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;
+        if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize; 
         RETURN_ERROR_IF(remainingSrcSize < frameHeaderSize+ZSTD_blockHeaderSize,
                         srcSize_wrong, "");
         FORWARD_IF_ERROR( ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize) , "");
         ip += frameHeaderSize; remainingSrcSize -= frameHeaderSize;
-    }
-
-    /* Loop on each block */
-    while (1) {
-        size_t decodedSize;
-        blockProperties_t blockProperties;
+    } 
+ 
+    /* Loop on each block */ 
+    while (1) { 
+        size_t decodedSize; 
+        blockProperties_t blockProperties; 
         size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSrcSize, &blockProperties);
-        if (ZSTD_isError(cBlockSize)) return cBlockSize;
-
-        ip += ZSTD_blockHeaderSize;
+        if (ZSTD_isError(cBlockSize)) return cBlockSize; 
+ 
+        ip += ZSTD_blockHeaderSize; 
         remainingSrcSize -= ZSTD_blockHeaderSize;
         RETURN_ERROR_IF(cBlockSize > remainingSrcSize, srcSize_wrong, "");
-
-        switch(blockProperties.blockType)
-        {
-        case bt_compressed:
+ 
+        switch(blockProperties.blockType) 
+        { 
+        case bt_compressed: 
             decodedSize = ZSTD_decompressBlock_internal(dctx, op, (size_t)(oend-op), ip, cBlockSize, /* frame */ 1, not_streaming);
-            break;
-        case bt_raw :
+            break; 
+        case bt_raw : 
             decodedSize = ZSTD_copyRawBlock(op, (size_t)(oend-op), ip, cBlockSize);
-            break;
-        case bt_rle :
+            break; 
+        case bt_rle : 
             decodedSize = ZSTD_setRleBlock(op, (size_t)(oend-op), *ip, blockProperties.origSize);
-            break;
-        case bt_reserved :
-        default:
+            break; 
+        case bt_reserved : 
+        default: 
             RETURN_ERROR(corruption_detected, "invalid block type");
-        }
-
-        if (ZSTD_isError(decodedSize)) return decodedSize;
+        } 
+ 
+        if (ZSTD_isError(decodedSize)) return decodedSize; 
         if (dctx->validateChecksum)
             XXH64_update(&dctx->xxhState, op, decodedSize);
         if (decodedSize != 0)
             op += decodedSize;
         assert(ip != NULL);
-        ip += cBlockSize;
+        ip += cBlockSize; 
         remainingSrcSize -= cBlockSize;
-        if (blockProperties.lastBlock) break;
-    }
-
+        if (blockProperties.lastBlock) break; 
+    } 
+ 
     if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) {
         RETURN_ERROR_IF((U64)(op-ostart) != dctx->fParams.frameContentSize,
                         corruption_detected, "");
@@ -953,14 +953,14 @@ static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
         }
         ip += 4;
         remainingSrcSize -= 4;
-    }
+    } 
     ZSTD_DCtx_trace_end(dctx, (U64)(op-ostart), (U64)(ip-istart), /* streaming */ 0);
     /* Allow caller to get size read */
     *srcPtr = ip;
     *srcSizePtr = remainingSrcSize;
     return (size_t)(op-ostart);
-}
-
+} 
+ 
 static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
                                         void* dst, size_t dstCapacity,
                                   const void* src, size_t srcSize,
@@ -1052,15 +1052,15 @@ static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
     return (size_t)((BYTE*)dst - (BYTE*)dststart);
 }
 
-size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
-                                 void* dst, size_t dstCapacity,
+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)
-{
+{ 
     return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL);
-}
-
-
+} 
+ 
+ 
 static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx)
 {
     switch (dctx->dictUses) {
@@ -1078,35 +1078,35 @@ static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx)
     }
 }
 
-size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
+size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
     return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ZSTD_getDDict(dctx));
-}
-
-
-size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
+} 
+ 
+ 
+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;
+    size_t regenSize; 
     ZSTD_DCtx* const dctx =  ZSTD_createDCtx_internal(ZSTD_defaultCMem);
     RETURN_ERROR_IF(dctx==NULL, memory_allocation, "NULL pointer!");
-    regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);
-    ZSTD_freeDCtx(dctx);
-    return regenSize;
-#else   /* stack mode */
-    ZSTD_DCtx dctx;
+    regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize); 
+    ZSTD_freeDCtx(dctx); 
+    return regenSize; 
+#else   /* stack mode */ 
+    ZSTD_DCtx dctx; 
     ZSTD_initDCtx_internal(&dctx);
-    return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
-#endif
-}
-
-
+    return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize); 
+#endif 
+} 
+ 
+ 
 /*-**************************************
 *   Advanced Streaming Decompression API
 *   Bufferless and synchronous
 ****************************************/
-size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) { return dctx->expected; }
-
+size_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) { return dctx->expected; } 
+ 
 /**
  * Similar to ZSTD_nextSrcSizeToDecompress(), but when when a block input can be streamed,
  * we allow taking a partial block as the input. Currently only raw uncompressed blocks can
@@ -1125,49 +1125,49 @@ static size_t ZSTD_nextSrcSizeToDecompressWithInputSize(ZSTD_DCtx* dctx, size_t
     return BOUNDED(1, inputSize, dctx->expected);
 }
 
-ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx) {
-    switch(dctx->stage)
-    {
-    default:   /* should not happen */
+ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx) { 
+    switch(dctx->stage) 
+    { 
+    default:   /* should not happen */ 
         assert(0);
         ZSTD_FALLTHROUGH;
-    case ZSTDds_getFrameHeaderSize:
+    case ZSTDds_getFrameHeaderSize: 
         ZSTD_FALLTHROUGH;
-    case ZSTDds_decodeFrameHeader:
-        return ZSTDnit_frameHeader;
-    case ZSTDds_decodeBlockHeader:
-        return ZSTDnit_blockHeader;
-    case ZSTDds_decompressBlock:
-        return ZSTDnit_block;
-    case ZSTDds_decompressLastBlock:
-        return ZSTDnit_lastBlock;
-    case ZSTDds_checkChecksum:
-        return ZSTDnit_checksum;
-    case ZSTDds_decodeSkippableHeader:
+    case ZSTDds_decodeFrameHeader: 
+        return ZSTDnit_frameHeader; 
+    case ZSTDds_decodeBlockHeader: 
+        return ZSTDnit_blockHeader; 
+    case ZSTDds_decompressBlock: 
+        return ZSTDnit_block; 
+    case ZSTDds_decompressLastBlock: 
+        return ZSTDnit_lastBlock; 
+    case ZSTDds_checkChecksum: 
+        return ZSTDnit_checksum; 
+    case ZSTDds_decodeSkippableHeader: 
         ZSTD_FALLTHROUGH;
-    case ZSTDds_skipFrame:
-        return ZSTDnit_skippableFrame;
-    }
-}
-
+    case ZSTDds_skipFrame: 
+        return ZSTDnit_skippableFrame; 
+    } 
+} 
+ 
 static int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skipFrame; }
-
-/** ZSTD_decompressContinue() :
+ 
+/** ZSTD_decompressContinue() : 
  *  srcSize : must be the exact nb of bytes expected (see ZSTD_nextSrcSizeToDecompress())
  *  @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity)
  *            or an error code, which can be tested using ZSTD_isError() */
-size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
+size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
     DEBUGLOG(5, "ZSTD_decompressContinue (srcSize:%u)", (unsigned)srcSize);
-    /* Sanity check */
+    /* Sanity check */ 
     RETURN_ERROR_IF(srcSize != ZSTD_nextSrcSizeToDecompressWithInputSize(dctx, srcSize), srcSize_wrong, "not allowed");
     ZSTD_checkContinuity(dctx, dst, dstCapacity);
-
+ 
     dctx->processedCSize += srcSize;
 
-    switch (dctx->stage)
-    {
-    case ZSTDds_getFrameHeaderSize :
+    switch (dctx->stage) 
+    { 
+    case ZSTDds_getFrameHeaderSize : 
         assert(src != NULL);
         if (dctx->format == ZSTD_f_zstd1) {  /* allows header */
             assert(srcSize >= ZSTD_FRAMEIDSIZE);  /* to read skippable magic number */
@@ -1178,13 +1178,13 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, c
                 return 0;
         }   }
         dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, dctx->format);
-        if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize;
+        if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize; 
         ZSTD_memcpy(dctx->headerBuffer, src, srcSize);
         dctx->expected = dctx->headerSize - srcSize;
         dctx->stage = ZSTDds_decodeFrameHeader;
         return 0;
-
-    case ZSTDds_decodeFrameHeader:
+ 
+    case ZSTDds_decodeFrameHeader: 
         assert(src != NULL);
         ZSTD_memcpy(dctx->headerBuffer + (dctx->headerSize - srcSize), src, srcSize);
         FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize), "");
@@ -1192,94 +1192,94 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, c
         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;
+    case ZSTDds_decodeBlockHeader: 
+        {   blockProperties_t bp; 
+            size_t const cBlockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp); 
+            if (ZSTD_isError(cBlockSize)) return cBlockSize; 
             RETURN_ERROR_IF(cBlockSize > dctx->fParams.blockSizeMax, corruption_detected, "Block Size Exceeds Maximum");
-            dctx->expected = cBlockSize;
-            dctx->bType = bp.blockType;
-            dctx->rleSize = bp.origSize;
-            if (cBlockSize) {
-                dctx->stage = bp.lastBlock ? ZSTDds_decompressLastBlock : ZSTDds_decompressBlock;
-                return 0;
-            }
-            /* empty block */
-            if (bp.lastBlock) {
-                if (dctx->fParams.checksumFlag) {
-                    dctx->expected = 4;
-                    dctx->stage = ZSTDds_checkChecksum;
-                } else {
-                    dctx->expected = 0; /* end of frame */
-                    dctx->stage = ZSTDds_getFrameHeaderSize;
-                }
-            } else {
+            dctx->expected = cBlockSize; 
+            dctx->bType = bp.blockType; 
+            dctx->rleSize = bp.origSize; 
+            if (cBlockSize) { 
+                dctx->stage = bp.lastBlock ? ZSTDds_decompressLastBlock : ZSTDds_decompressBlock; 
+                return 0; 
+            } 
+            /* empty block */ 
+            if (bp.lastBlock) { 
+                if (dctx->fParams.checksumFlag) { 
+                    dctx->expected = 4; 
+                    dctx->stage = ZSTDds_checkChecksum; 
+                } else { 
+                    dctx->expected = 0; /* end of frame */ 
+                    dctx->stage = ZSTDds_getFrameHeaderSize; 
+                } 
+            } else { 
                 dctx->expected = ZSTD_blockHeaderSize;  /* jump to next header */
-                dctx->stage = ZSTDds_decodeBlockHeader;
-            }
-            return 0;
-        }
+                dctx->stage = ZSTDds_decodeBlockHeader; 
+            } 
+            return 0; 
+        } 
 
-    case ZSTDds_decompressLastBlock:
-    case ZSTDds_decompressBlock:
+    case ZSTDds_decompressLastBlock: 
+    case ZSTDds_decompressBlock: 
         DEBUGLOG(5, "ZSTD_decompressContinue: case ZSTDds_decompressBlock");
-        {   size_t rSize;
-            switch(dctx->bType)
-            {
-            case bt_compressed:
+        {   size_t rSize; 
+            switch(dctx->bType) 
+            { 
+            case bt_compressed: 
                 DEBUGLOG(5, "ZSTD_decompressContinue: case bt_compressed");
                 rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, /* frame */ 1, is_streaming);
                 dctx->expected = 0;  /* Streaming not supported */
-                break;
-            case bt_raw :
+                break; 
+            case bt_raw : 
                 assert(srcSize <= dctx->expected);
-                rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize);
+                rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize); 
                 FORWARD_IF_ERROR(rSize, "ZSTD_copyRawBlock failed");
                 assert(rSize == srcSize);
                 dctx->expected -= rSize;
-                break;
-            case bt_rle :
+                break; 
+            case bt_rle : 
                 rSize = ZSTD_setRleBlock(dst, dstCapacity, *(const BYTE*)src, dctx->rleSize);
                 dctx->expected = 0;  /* Streaming not supported */
-                break;
-            case bt_reserved :   /* should never happen */
-            default:
+                break; 
+            case bt_reserved :   /* should never happen */ 
+            default: 
                 RETURN_ERROR(corruption_detected, "invalid block type");
-            }
+            } 
             FORWARD_IF_ERROR(rSize, "");
             RETURN_ERROR_IF(rSize > dctx->fParams.blockSizeMax, corruption_detected, "Decompressed Block Size Exceeds Maximum");
             DEBUGLOG(5, "ZSTD_decompressContinue: decoded size from block : %u", (unsigned)rSize);
             dctx->decodedSize += rSize;
             if (dctx->validateChecksum) XXH64_update(&dctx->xxhState, dst, rSize);
             dctx->previousDstEnd = (char*)dst + rSize;
-
+ 
             /* Stay on the same stage until we are finished streaming the block. */
             if (dctx->expected > 0) {
                 return rSize;
             }
 
-            if (dctx->stage == ZSTDds_decompressLastBlock) {   /* end of frame */
+            if (dctx->stage == ZSTDds_decompressLastBlock) {   /* end of frame */ 
                 DEBUGLOG(4, "ZSTD_decompressContinue: decoded size from frame : %u", (unsigned)dctx->decodedSize);
                 RETURN_ERROR_IF(
                     dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN
                  && dctx->decodedSize != dctx->fParams.frameContentSize,
                     corruption_detected, "");
-                if (dctx->fParams.checksumFlag) {  /* another round for frame checksum */
-                    dctx->expected = 4;
-                    dctx->stage = ZSTDds_checkChecksum;
-                } else {
+                if (dctx->fParams.checksumFlag) {  /* another round for frame checksum */ 
+                    dctx->expected = 4; 
+                    dctx->stage = ZSTDds_checkChecksum; 
+                } else { 
                     ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1);
-                    dctx->expected = 0;   /* ends here */
-                    dctx->stage = ZSTDds_getFrameHeaderSize;
-                }
-            } else {
-                dctx->stage = ZSTDds_decodeBlockHeader;
-                dctx->expected = ZSTD_blockHeaderSize;
-            }
-            return rSize;
-        }
-
-    case ZSTDds_checkChecksum:
+                    dctx->expected = 0;   /* ends here */ 
+                    dctx->stage = ZSTDds_getFrameHeaderSize; 
+                } 
+            } else { 
+                dctx->stage = ZSTDds_decodeBlockHeader; 
+                dctx->expected = ZSTD_blockHeaderSize; 
+            } 
+            return rSize; 
+        } 
+
+    case ZSTDds_checkChecksum: 
         assert(srcSize == 4);  /* guaranteed by dctx->expected */
         {
             if (dctx->validateChecksum) {
@@ -1289,12 +1289,12 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, c
                 RETURN_ERROR_IF(check32 != h32, checksum_wrong, "");
             }
             ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1);
-            dctx->expected = 0;
-            dctx->stage = ZSTDds_getFrameHeaderSize;
-            return 0;
-        }
+            dctx->expected = 0; 
+            dctx->stage = ZSTDds_getFrameHeaderSize; 
+            return 0; 
+        } 
 
-    case ZSTDds_decodeSkippableHeader:
+    case ZSTDds_decodeSkippableHeader: 
         assert(src != NULL);
         assert(srcSize <= ZSTD_SKIPPABLEHEADERSIZE);
         ZSTD_memcpy(dctx->headerBuffer + (ZSTD_SKIPPABLEHEADERSIZE - srcSize), src, srcSize);   /* complete skippable header */
@@ -1302,41 +1302,41 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, c
         dctx->stage = ZSTDds_skipFrame;
         return 0;
 
-    case ZSTDds_skipFrame:
+    case ZSTDds_skipFrame: 
         dctx->expected = 0;
         dctx->stage = ZSTDds_getFrameHeaderSize;
         return 0;
 
-    default:
+    default: 
         assert(0);   /* impossible */
         RETURN_ERROR(GENERIC, "impossible to reach");   /* some compiler require default to do something */
-    }
-}
-
-
-static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    dctx->dictEnd = dctx->previousDstEnd;
+    } 
+} 
+ 
+ 
+static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
+    dctx->dictEnd = dctx->previousDstEnd; 
     dctx->virtualStart = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));
     dctx->prefixStart = dict;
-    dctx->previousDstEnd = (const char*)dict + dictSize;
+    dctx->previousDstEnd = (const char*)dict + dictSize; 
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     dctx->dictContentBeginForFuzzing = dctx->prefixStart;
     dctx->dictContentEndForFuzzing = dctx->previousDstEnd;
 #endif
-    return 0;
-}
-
+    return 0; 
+} 
+ 
 /*! ZSTD_loadDEntropy() :
  *  dict : must point at beginning of a valid zstd dictionary.
  * @return : size of entropy tables read */
 size_t
 ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
                   const void* const dict, size_t const dictSize)
-{
-    const BYTE* dictPtr = (const BYTE*)dict;
-    const BYTE* const dictEnd = dictPtr + dictSize;
-
+{ 
+    const BYTE* dictPtr = (const BYTE*)dict; 
+    const BYTE* const dictEnd = dictPtr + dictSize; 
+ 
     RETURN_ERROR_IF(dictSize <= 8, dictionary_corrupted, "dict is too small");
     assert(MEM_readLE32(dict) == ZSTD_MAGIC_DICTIONARY);   /* dict must be valid */
     dictPtr += 8;   /* skip header = magic + dictID */
@@ -1357,10 +1357,10 @@ ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
                                                 workspace, workspaceSize);
 #endif
         RETURN_ERROR_IF(HUF_isError(hSize), dictionary_corrupted, "");
-        dictPtr += hSize;
-    }
-
-    {   short offcodeNCount[MaxOff+1];
+        dictPtr += hSize; 
+    } 
+ 
+    {   short offcodeNCount[MaxOff+1]; 
         unsigned offcodeMaxValue = MaxOff, offcodeLog;
         size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, (size_t)(dictEnd-dictPtr));
         RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted, "");
@@ -1372,10 +1372,10 @@ ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
                             offcodeLog,
                             entropy->workspace, sizeof(entropy->workspace),
                             /* bmi2 */0);
-        dictPtr += offcodeHeaderSize;
-    }
-
-    {   short matchlengthNCount[MaxML+1];
+        dictPtr += offcodeHeaderSize; 
+    } 
+ 
+    {   short matchlengthNCount[MaxML+1]; 
         unsigned matchlengthMaxValue = MaxML, matchlengthLog;
         size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, (size_t)(dictEnd-dictPtr));
         RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted, "");
@@ -1387,10 +1387,10 @@ ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
                             matchlengthLog,
                             entropy->workspace, sizeof(entropy->workspace),
                             /* bmi2 */ 0);
-        dictPtr += matchlengthHeaderSize;
-    }
-
-    {   short litlengthNCount[MaxLL+1];
+        dictPtr += matchlengthHeaderSize; 
+    } 
+ 
+    {   short litlengthNCount[MaxLL+1]; 
         unsigned litlengthMaxValue = MaxLL, litlengthLog;
         size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, (size_t)(dictEnd-dictPtr));
         RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted, "");
@@ -1402,9 +1402,9 @@ ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
                             litlengthLog,
                             entropy->workspace, sizeof(entropy->workspace),
                             /* bmi2 */ 0);
-        dictPtr += litlengthHeaderSize;
-    }
-
+        dictPtr += litlengthHeaderSize; 
+    } 
+ 
     RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted, "");
     {   int i;
         size_t const dictContentSize = (size_t)(dictEnd - (dictPtr+12));
@@ -1414,31 +1414,31 @@ ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
                             dictionary_corrupted, "");
             entropy->rep[i] = rep;
     }   }
-
+ 
     return (size_t)(dictPtr - (const BYTE*)dict);
-}
-
-static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize);
-    {   U32 const magic = MEM_readLE32(dict);
+} 
+ 
+static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
+    if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize); 
+    {   U32 const magic = MEM_readLE32(dict); 
         if (magic != ZSTD_MAGIC_DICTIONARY) {
-            return ZSTD_refDictContent(dctx, dict, dictSize);   /* pure content mode */
-    }   }
+            return ZSTD_refDictContent(dctx, dict, dictSize);   /* pure content mode */ 
+    }   } 
     dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);
-
-    /* load entropy tables */
+ 
+    /* load entropy tables */ 
     {   size_t const eSize = ZSTD_loadDEntropy(&dctx->entropy, dict, dictSize);
         RETURN_ERROR_IF(ZSTD_isError(eSize), dictionary_corrupted, "");
-        dict = (const char*)dict + eSize;
-        dictSize -= eSize;
-    }
+        dict = (const char*)dict + eSize; 
+        dictSize -= eSize; 
+    } 
     dctx->litEntropy = dctx->fseEntropy = 1;
-
-    /* reference dictionary content */
-    return ZSTD_refDictContent(dctx, dict, dictSize);
-}
-
+ 
+    /* reference dictionary content */ 
+    return ZSTD_refDictContent(dctx, dict, dictSize); 
+} 
+ 
 size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx)
 {
     assert(dctx != NULL);
@@ -1466,21 +1466,21 @@ size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx)
     return 0;
 }
 
-size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
-{
+size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
     FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , "");
     if (dict && dictSize)
         RETURN_ERROR_IF(
             ZSTD_isError(ZSTD_decompress_insertDictionary(dctx, dict, dictSize)),
             dictionary_corrupted, "");
-    return 0;
-}
-
-
+    return 0; 
+} 
+ 
+ 
 /* ======   ZSTD_DDict   ====== */
 
 size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
-{
+{ 
     DEBUGLOG(4, "ZSTD_decompressBegin_usingDDict");
     assert(dctx != NULL);
     if (ddict) {
@@ -1531,19 +1531,19 @@ unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize)
 }
 
 
-/*! ZSTD_decompress_usingDDict() :
-*   Decompression using a pre-digested Dictionary
-*   Use dictionary without significant overhead. */
+/*! ZSTD_decompress_usingDDict() : 
+*   Decompression using a pre-digested Dictionary 
+*   Use dictionary without significant overhead. */ 
 size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,
                                   void* dst, size_t dstCapacity,
                             const void* src, size_t srcSize,
                             const ZSTD_DDict* ddict)
-{
+{ 
     /* pass content and size in case legacy frames are encountered */
     return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize,
                                      NULL, 0,
                                      ddict);
-}
+} 
 
 
 /*=====================================
diff --git a/contrib/libs/zstd/lib/dictBuilder/divsufsort.c b/contrib/libs/zstd/lib/dictBuilder/divsufsort.c
index a2870fb3ba..86b83095f6 100644
--- a/contrib/libs/zstd/lib/dictBuilder/divsufsort.c
+++ b/contrib/libs/zstd/lib/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);
-
+/* 
+ * 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 type 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);
-          }
+    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); assert(k != NULL);
-          *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);
-          }
+          *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); assert(k != NULL);
-          *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);
-          }
+          *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); assert(k != NULL);
-          *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;
-}
+          *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/zstd/lib/dictBuilder/divsufsort.h b/contrib/libs/zstd/lib/dictBuilder/divsufsort.h
index 5440994af1..cf2a5203cc 100644
--- a/contrib/libs/zstd/lib/dictBuilder/divsufsort.h
+++ b/contrib/libs/zstd/lib/dictBuilder/divsufsort.h
@@ -1,67 +1,67 @@
-/*
- * 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.
+/* 
+ * 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 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 */
+ * @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/zstd/lib/dictBuilder/zdict.c b/contrib/libs/zstd/lib/dictBuilder/zdict.c
index 587df6b861..bbb23bf8b7 100644
--- a/contrib/libs/zstd/lib/dictBuilder/zdict.c
+++ b/contrib/libs/zstd/lib/dictBuilder/zdict.c
@@ -7,40 +7,40 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-
-/*-**************************************
-*  Tuning parameters
-****************************************/
+ 
+ 
+/*-************************************** 
+*  Tuning parameters 
+****************************************/ 
 #define MINRATIO 4   /* minimum nb of apparition to be selected in dictionary */
-#define ZDICT_MAX_SAMPLES_SIZE (2000U << 20)
+#define ZDICT_MAX_SAMPLES_SIZE (2000U << 20) 
 #define ZDICT_MIN_SAMPLES_SIZE (ZDICT_CONTENTSIZE_MIN * MINRATIO)
-
-
-/*-**************************************
-*  Compiler Options
-****************************************/
-/* Unix Large Files support (>4GB) */
-#define _FILE_OFFSET_BITS 64
-#if (defined(__sun__) && (!defined(__LP64__)))   /* Sun Solaris 32-bits requires specific definitions */
+ 
+ 
+/*-************************************** 
+*  Compiler Options 
+****************************************/ 
+/* Unix Large Files support (>4GB) */ 
+#define _FILE_OFFSET_BITS 64 
+#if (defined(__sun__) && (!defined(__LP64__)))   /* Sun Solaris 32-bits requires specific definitions */ 
 #  ifndef _LARGEFILE_SOURCE
-#  define _LARGEFILE_SOURCE
+#  define _LARGEFILE_SOURCE 
 #  endif
-#elif ! defined(__LP64__)                        /* No point defining Large file for 64 bit */
+#elif ! defined(__LP64__)                        /* No point defining Large file for 64 bit */ 
 #  ifndef _LARGEFILE64_SOURCE
-#  define _LARGEFILE64_SOURCE
+#  define _LARGEFILE64_SOURCE 
 #  endif
-#endif
-
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include <stdlib.h>        /* malloc, free */
-#include <string.h>        /* memset */
-#include <stdio.h>         /* fprintf, fopen, ftello64 */
-#include <time.h>          /* clock */
-
+#endif 
+ 
+ 
+/*-************************************* 
+*  Dependencies 
+***************************************/ 
+#include <stdlib.h>        /* malloc, free */ 
+#include <string.h>        /* memset */ 
+#include <stdio.h>         /* fprintf, fopen, ftello64 */ 
+#include <time.h>          /* clock */ 
+ 
 #ifndef ZDICT_STATIC_LINKING_ONLY
 #  define ZDICT_STATIC_LINKING_ONLY
 #endif
@@ -53,59 +53,59 @@
 #include <contrib/libs/xxhash/xxhash.h>        /* XXH64 */
 #include "../compress/zstd_compress_internal.h" /* ZSTD_loadCEntropy() */
 #include "../zdict.h"
-#include "divsufsort.h"
-
-
-/*-*************************************
-*  Constants
-***************************************/
-#define KB *(1 <<10)
-#define MB *(1 <<20)
-#define GB *(1U<<30)
-
+#include "divsufsort.h" 
+ 
+ 
+/*-************************************* 
+*  Constants 
+***************************************/ 
+#define KB *(1 <<10) 
+#define MB *(1 <<20) 
+#define GB *(1U<<30) 
+ 
 #define DICTLISTSIZE_DEFAULT 10000
-
-#define NOISELENGTH 32
-
-static const U32 g_selectivity_default = 9;
-
-
-/*-*************************************
-*  Console display
-***************************************/
+ 
+#define NOISELENGTH 32 
+ 
+static const U32 g_selectivity_default = 9; 
+ 
+ 
+/*-************************************* 
+*  Console display 
+***************************************/ 
 #undef  DISPLAY
-#define DISPLAY(...)         { fprintf(stderr, __VA_ARGS__); fflush( stderr ); }
+#define DISPLAY(...)         { fprintf(stderr, __VA_ARGS__); fflush( stderr ); } 
 #undef  DISPLAYLEVEL
 #define DISPLAYLEVEL(l, ...) if (notificationLevel>=l) { DISPLAY(__VA_ARGS__); }    /* 0 : no display;   1: errors;   2: default;  3: details;  4: debug */
-
-static clock_t ZDICT_clockSpan(clock_t nPrevious) { return clock() - nPrevious; }
-
+ 
+static clock_t ZDICT_clockSpan(clock_t nPrevious) { return clock() - nPrevious; } 
+ 
 static void ZDICT_printHex(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 */
+{ 
+    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 */ 
         DISPLAY("%c", c);
-    }
-}
-
-
-/*-********************************************************
-*  Helper functions
-**********************************************************/
-unsigned ZDICT_isError(size_t errorCode) { return ERR_isError(errorCode); }
-
-const char* ZDICT_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
-
+    } 
+} 
+ 
+ 
+/*-******************************************************** 
+*  Helper functions 
+**********************************************************/ 
+unsigned ZDICT_isError(size_t errorCode) { return ERR_isError(errorCode); } 
+ 
+const char* ZDICT_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); } 
+ 
 unsigned ZDICT_getDictID(const void* dictBuffer, size_t dictSize)
 {
     if (dictSize < 8) return 0;
     if (MEM_readLE32(dictBuffer) != ZSTD_MAGIC_DICTIONARY) return 0;
     return MEM_readLE32((const char*)dictBuffer + 4);
 }
-
+ 
 size_t ZDICT_getDictHeaderSize(const void* dictBuffer, size_t dictSize)
 {
     size_t headerSize;
@@ -127,14 +127,14 @@ size_t ZDICT_getDictHeaderSize(const void* dictBuffer, size_t dictSize)
     return headerSize;
 }
 
-/*-********************************************************
-*  Dictionary training functions
-**********************************************************/
+/*-******************************************************** 
+*  Dictionary training functions 
+**********************************************************/ 
 static unsigned ZDICT_NbCommonBytes (size_t val)
-{
-    if (MEM_isLittleEndian()) {
-        if (MEM_64bits()) {
-#       if defined(_MSC_VER) && defined(_WIN64)
+{ 
+    if (MEM_isLittleEndian()) { 
+        if (MEM_64bits()) { 
+#       if defined(_MSC_VER) && defined(_WIN64) 
             if (val != 0) {
                 unsigned long r;
                 _BitScanForward64(&r, (U64)val);
@@ -143,14 +143,14 @@ static unsigned ZDICT_NbCommonBytes (size_t val)
                 /* Should not reach this code path */
                 __assume(0);
             }
-#       elif defined(__GNUC__) && (__GNUC__ >= 3)
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) 
             return (unsigned)(__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)
+#       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) 
             if (val != 0) {
                 unsigned long r;
                 _BitScanForward(&r, (U32)val);
@@ -159,16 +159,16 @@ static unsigned ZDICT_NbCommonBytes (size_t val)
                 /* Should not reach this code path */
                 __assume(0);
             }
-#       elif defined(__GNUC__) && (__GNUC__ >= 3)
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) 
             return (unsigned)(__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)
+#       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) 
             if (val != 0) {
                 unsigned long r;
                 _BitScanReverse64(&r, val);
@@ -177,18 +177,18 @@ static unsigned ZDICT_NbCommonBytes (size_t val)
                 /* Should not reach this code path */
                 __assume(0);
             }
-#       elif defined(__GNUC__) && (__GNUC__ >= 3)
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) 
             return (unsigned)(__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)
+#       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) 
             if (val != 0) {
                 unsigned long r;
                 _BitScanReverse(&r, (unsigned long)val);
@@ -197,156 +197,156 @@ static unsigned ZDICT_NbCommonBytes (size_t val)
                 /* Should not reach this code path */
                 __assume(0);
             }
-#       elif defined(__GNUC__) && (__GNUC__ >= 3)
+#       elif defined(__GNUC__) && (__GNUC__ >= 3) 
             return (unsigned)(__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 const 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,
+#       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 const 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 notificationLevel)
-{
-    U32 lengthList[LLIMIT] = {0};
-    U32 cumulLength[LLIMIT] = {0};
-    U32 savings[LLIMIT] = {0};
-    const BYTE* b = (const BYTE*)buffer;
-    size_t maxLength = LLIMIT;
+{ 
+    U32 lengthList[LLIMIT] = {0}; 
+    U32 cumulLength[LLIMIT] = {0}; 
+    U32 savings[LLIMIT] = {0}; 
+    const BYTE* b = (const BYTE*)buffer; 
+    size_t maxLength = LLIMIT; 
     size_t pos = (size_t)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 */
+    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 const pattern16 = MEM_read16(b+pos+4);
         U32 u, patternEnd = 6;
         while (MEM_read16(b+pos+patternEnd) == pattern16) patternEnd+=2 ;
         if (b[pos+patternEnd] == b[pos+patternEnd-1]) patternEnd++;
         for (u=1; u<patternEnd; u++)
-            doneMarks[pos+u] = 1;
-        return solution;
-    }
-
-    /* look forward */
+            doneMarks[pos+u] = 1; 
+        return solution; 
+    } 
+ 
+    /* look forward */ 
     {   size_t length;
         do {
             end++;
             length = ZDICT_count(b + pos, b + suffix[end]);
         } while (length >= MINMATCHLENGTH);
     }
-
-    /* look backward */
+ 
+    /* look backward */ 
     {   size_t length;
         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;
+ 
+    /* 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 mml;
-        U32 refinedStart = start;
-        U32 refinedEnd = end;
-
-        DISPLAYLEVEL(4, "\n");
+        U32 refinedStart = start; 
+        U32 refinedEnd = end; 
+ 
+        DISPLAYLEVEL(4, "\n"); 
         DISPLAYLEVEL(4, "found %3u matches of length >= %i at pos %7u  ", (unsigned)(end-start), MINMATCHLENGTH, (unsigned)pos);
-        DISPLAYLEVEL(4, "\n");
-
+        DISPLAYLEVEL(4, "\n"); 
+ 
         for (mml = MINMATCHLENGTH ; ; mml++) {
-            BYTE currentChar = 0;
-            U32 currentCount = 0;
-            U32 currentID = refinedStart;
-            U32 id;
-            U32 selectedCount = 0;
-            U32 selectedID = currentID;
-            for (id =refinedStart; id < refinedEnd; id++) {
+            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] + mml] != currentChar) {
-                    if (currentCount > selectedCount) {
-                        selectedCount = currentCount;
-                        selectedID = currentID;
-                    }
-                    currentID = id;
+                    if (currentCount > selectedCount) { 
+                        selectedCount = currentCount; 
+                        selectedID = currentID; 
+                    } 
+                    currentID = id; 
                     currentChar = b[ suffix[id] + mml];
-                    currentCount = 0;
-                }
-                currentCount ++;
-            }
-            if (currentCount > selectedCount) {  /* for last */
-                selectedCount = currentCount;
-                selectedID = currentID;
-            }
-
-            if (selectedCount < minRatio)
-                break;
-            refinedStart = selectedID;
-            refinedEnd = refinedStart + selectedCount;
-        }
-
+                    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 dict */
-        start = refinedStart;
-        pos = suffix[refinedStart];
-        end = start;
-        memset(lengthList, 0, sizeof(lengthList));
-
-        /* look forward */
+        start = refinedStart; 
+        pos = suffix[refinedStart]; 
+        end = start; 
+        memset(lengthList, 0, sizeof(lengthList)); 
+ 
+        /* look forward */ 
         {   size_t length;
             do {
                 end++;
@@ -355,8 +355,8 @@ static dictItem ZDICT_analyzePos(
                 lengthList[length]++;
             } while (length >=MINMATCHLENGTH);
         }
-
-        /* look backward */
+ 
+        /* look backward */ 
         {   size_t length = MINMATCHLENGTH;
             while ((length >= MINMATCHLENGTH) & (start > 0)) {
                 length = ZDICT_count(b + pos, b + suffix[start - 1]);
@@ -365,56 +365,56 @@ static dictItem ZDICT_analyzePos(
                 if (length >= MINMATCHLENGTH) start--;
             }
         }
-
-        /* 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 const 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));
-
+ 
+        /* 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 const 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 dict at position %u, of length %u : saves %u (ratio: %.2f)  \n",
                      (unsigned)pos, (unsigned)maxLength, (unsigned)savings[maxLength], (double)savings[maxLength] / (double)maxLength);
-
-        solution.pos = (U32)pos;
-        solution.length = (U32)maxLength;
-        solution.savings = savings[maxLength];
-
-        /* mark positions done */
-        {   U32 id;
-            for (id=start; id<end; id++) {
+ 
+        solution.pos = (U32)pos; 
+        solution.length = (U32)maxLength; 
+        solution.savings = savings[maxLength]; 
+ 
+        /* mark positions done */ 
+        {   U32 id; 
+            for (id=start; id<end; id++) { 
                 U32 p, pEnd, length;
                 U32 const testedPos = (U32)suffix[id];
-                if (testedPos == pos)
-                    length = solution.length;
-                else {
+                if (testedPos == pos) 
+                    length = solution.length; 
+                else { 
                     length = (U32)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;
-}
-
-
+                    if (length > solution.length) length = solution.length; 
+                } 
+                pEnd = (U32)(testedPos + length); 
+                for (p=testedPos; p<pEnd; p++) 
+                    doneMarks[p] = 1; 
+    }   }   } 
+ 
+    return solution; 
+} 
+ 
+ 
 static int isIncluded(const void* in, const void* container, size_t length)
 {
     const char* const ip = (const char*) in;
@@ -429,53 +429,53 @@ static int isIncluded(const void* in, const void* container, size_t length)
 }
 
 /*! ZDICT_tryMerge() :
-    check if dictItem can be merged, do it if possible
-    @return : id of destination elt, 0 if not merged
-*/
+    check if dictItem can be merged, do it if possible 
+    @return : id of destination elt, 0 if not merged 
+*/ 
 static U32 ZDICT_tryMerge(dictItem* table, dictItem elt, U32 eltNbToSkip, const void* buffer)
-{
-    const U32 tableSize = table->pos;
+{ 
+    const U32 tableSize = table->pos; 
     const U32 eltEnd = elt.pos + elt.length;
     const char* const buf = (const char*) buffer;
-
-    /* tail overlap */
-    U32 u; for (u=1; u<tableSize; u++) {
-        if (u==eltNbToSkip) continue;
+ 
+    /* tail overlap */ 
+    U32 u; for (u=1; u<tableSize; u++) { 
+        if (u==eltNbToSkip) continue; 
         if ((table[u].pos > elt.pos) && (table[u].pos <= eltEnd)) {  /* overlap, existing > new */
-            /* append */
+            /* append */ 
             U32 const 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].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 bonus */
-            elt = table[u];
+            elt = table[u]; 
             /* sort : improve rank */
-            while ((u>1) && (table[u-1].savings < elt.savings))
+            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;
+            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, existing < new */
-            /* append */
+            /* append */ 
             int const addedLength = (int)eltEnd - (int)(table[u].pos + table[u].length);
             table[u].savings += elt.length / 8;    /* rough approx bonus */
             if (addedLength > 0) {   /* otherwise, elt fully included into existing */
-                table[u].length += addedLength;
-                table[u].savings += elt.savings * addedLength / elt.length;   /* rough approx */
-            }
+                table[u].length += addedLength; 
+                table[u].savings += elt.savings * addedLength / elt.length;   /* rough approx */ 
+            } 
             /* sort : improve rank */
-            elt = table[u];
-            while ((u>1) && (table[u-1].savings < elt.savings))
-                table[u] = table[u-1], u--;
-            table[u] = elt;
-            return u;
+            elt = table[u]; 
+            while ((u>1) && (table[u-1].savings < elt.savings)) 
+                table[u] = table[u-1], u--; 
+            table[u] = elt; 
+            return u; 
         }
-
+ 
         if (MEM_read64(buf + table[u].pos) == MEM_read64(buf + elt.pos + 1)) {
             if (isIncluded(buf + table[u].pos, buf + elt.pos + 1, table[u].length)) {
                 size_t const addedLength = MAX( (int)elt.length - (int)table[u].length , 1 );
@@ -487,234 +487,234 @@ static U32 ZDICT_tryMerge(dictItem* table, dictItem elt, U32 eltNbToSkip, const
         }
     }
 
-    return 0;
-}
-
-
-static void ZDICT_removeDictItem(dictItem* table, U32 id)
-{
+    return 0; 
+} 
+ 
+ 
+static void ZDICT_removeDictItem(dictItem* table, U32 id) 
+{ 
     /* convention : table[0].pos stores nb of elts */
     U32 const max = table[0].pos;
-    U32 u;
-    if (!id) return;   /* protection, should never happen */
-    for (u=id; u<max-1; u++)
-        table[u] = table[u+1];
-    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, const void* buffer)
-{
-    /* merge if possible */
+{ 
+    /* merge if possible */ 
     U32 mergeId = ZDICT_tryMerge(table, elt, 0, buffer);
-    if (mergeId) {
-        U32 newMerge = 1;
-        while (newMerge) {
+    if (mergeId) { 
+        U32 newMerge = 1; 
+        while (newMerge) { 
             newMerge = ZDICT_tryMerge(table, table[mergeId], mergeId, buffer);
-            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;
-}
-
-
+            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_legacy(dictItem* dictList, U32 dictListSize,
-                            const void* const buffer, size_t bufferSize,   /* buffer must end with noisy guard band */
-                            const size_t* fileSizes, unsigned nbFiles,
+                            const void* const buffer, size_t bufferSize,   /* buffer must end with noisy guard band */ 
+                            const size_t* fileSizes, unsigned nbFiles, 
                             unsigned minRatio, U32 notificationLevel)
-{
-    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));
-    size_t result = 0;
+{ 
+    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)); 
+    size_t result = 0; 
     clock_t displayClock = 0;
     clock_t const refreshRate = CLOCKS_PER_SEC * 3 / 10;
-
+ 
 #   undef  DISPLAYUPDATE
 #   define DISPLAYUPDATE(l, ...) if (notificationLevel>=l) { \
             if (ZDICT_clockSpan(displayClock) > refreshRate)  \
             { displayClock = clock(); DISPLAY(__VA_ARGS__); \
             if (notificationLevel>=4) fflush(stderr); } }
 
-    /* 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);
-
-    /* limit sample set size (divsufsort limitation)*/
+    /* 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); 
+ 
+    /* limit sample set size (divsufsort limitation)*/ 
     if (bufferSize > ZDICT_MAX_SAMPLES_SIZE) DISPLAYLEVEL(3, "sample set too large : reduced to %u MB ...\n", (unsigned)(ZDICT_MAX_SAMPLES_SIZE>>20));
-    while (bufferSize > ZDICT_MAX_SAMPLES_SIZE) bufferSize -= fileSizes[--nbFiles];
-
-    /* sort */
+    while (bufferSize > ZDICT_MAX_SAMPLES_SIZE) bufferSize -= fileSizes[--nbFiles]; 
+ 
+    /* sort */ 
     DISPLAYLEVEL(2, "sorting %u files of total size %u MB ...\n", nbFiles, (unsigned)(bufferSize>>20));
-    {   int const 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;
+    {   int const 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; 
         /* note filePos tracks borders between samples.
            It's not used at this stage, but planned to become useful in a later update */
-        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; }
+        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, notificationLevel);
-            if (solution.length==0) { cursor++; continue; }
+            if (solution.length==0) { cursor++; continue; } 
             ZDICT_insertDictItem(dictList, dictListSize, solution, buffer);
-            cursor += solution.length;
-            DISPLAYUPDATE(2, "\r%4.2f %% \r", (double)cursor / bufferSize * 100);
-    }   }
-
-_cleanup:
-    free(suffix0);
-    free(reverseSuffix);
-    free(doneMarks);
-    free(filePos);
-    return result;
-}
-
-
-static void ZDICT_fillNoise(void* buffer, size_t length)
-{
+            cursor += solution.length; 
+            DISPLAYUPDATE(2, "\r%4.2f %% \r", (double)cursor / bufferSize * 100); 
+    }   } 
+ 
+_cleanup: 
+    free(suffix0); 
+    free(reverseSuffix); 
+    free(doneMarks); 
+    free(filePos); 
+    return result; 
+} 
+ 
+ 
+static void ZDICT_fillNoise(void* buffer, size_t length) 
+{ 
     unsigned const prime1 = 2654435761U;
     unsigned const prime2 = 2246822519U;
     unsigned acc = prime1;
     size_t p=0;
-    for (p=0; p<length; p++) {
+    for (p=0; p<length; p++) { 
         acc *= prime2;
-        ((unsigned char*)buffer)[p] = (unsigned char)(acc >> 21);
-    }
-}
-
-
-typedef struct
-{
+        ((unsigned char*)buffer)[p] = (unsigned char)(acc >> 21); 
+    } 
+} 
+ 
+ 
+typedef struct 
+{ 
     ZSTD_CDict* dict;    /* dictionary */
     ZSTD_CCtx* zc;     /* working context */
     void* workPlace;   /* must be ZSTD_BLOCKSIZE_MAX allocated */
-} EStats_ress_t;
-
-#define MAXREPOFFSET 1024
-
+} EStats_ress_t; 
+ 
+#define MAXREPOFFSET 1024 
+ 
 static void ZDICT_countEStats(EStats_ress_t esr, const ZSTD_parameters* params,
                               unsigned* countLit, unsigned* offsetcodeCount, unsigned* matchlengthCount, unsigned* litlengthCount, U32* repOffsets,
                               const void* src, size_t srcSize,
                               U32 notificationLevel)
-{
+{ 
     size_t const blockSizeMax = MIN (ZSTD_BLOCKSIZE_MAX, 1 << params->cParams.windowLog);
-    size_t cSize;
-
-    if (srcSize > blockSizeMax) srcSize = blockSizeMax;   /* protection vs large samples */
+    size_t cSize; 
+ 
+    if (srcSize > blockSizeMax) srcSize = blockSizeMax;   /* protection vs large samples */ 
     {   size_t const errorCode = ZSTD_compressBegin_usingCDict(esr.zc, esr.dict);
         if (ZSTD_isError(errorCode)) { DISPLAYLEVEL(1, "warning : ZSTD_compressBegin_usingCDict failed \n"); return; }
 
     }
     cSize = ZSTD_compressBlock(esr.zc, esr.workPlace, ZSTD_BLOCKSIZE_MAX, src, srcSize);
     if (ZSTD_isError(cSize)) { DISPLAYLEVEL(3, "warning : could not compress sample size %u \n", (unsigned)srcSize); return; }
-
-    if (cSize) {  /* if == 0; block is not compressible */
+ 
+    if (cSize) {  /* if == 0; block is not compressible */ 
         const seqStore_t* const seqStorePtr = ZSTD_getSeqStore(esr.zc);
-
-        /* literals stats */
-        {   const BYTE* bytePtr;
-            for(bytePtr = seqStorePtr->litStart; bytePtr < seqStorePtr->lit; bytePtr++)
-                countLit[*bytePtr]++;
-        }
-
-        /* seqStats */
-        {   U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-            ZSTD_seqToCodes(seqStorePtr);
-
-            {   const BYTE* codePtr = seqStorePtr->ofCode;
-                U32 u;
-                for (u=0; u<nbSeq; u++) offsetcodeCount[codePtr[u]]++;
-            }
-
-            {   const BYTE* codePtr = seqStorePtr->mlCode;
-                U32 u;
-                for (u=0; u<nbSeq; u++) matchlengthCount[codePtr[u]]++;
-            }
-
-            {   const BYTE* codePtr = seqStorePtr->llCode;
-                U32 u;
-                for (u=0; u<nbSeq; u++) litlengthCount[codePtr[u]]++;
-            }
-
-            if (nbSeq >= 2) { /* rep offsets */
-                const seqDef* const seq = seqStorePtr->sequencesStart;
+ 
+        /* literals stats */ 
+        {   const BYTE* bytePtr; 
+            for(bytePtr = seqStorePtr->litStart; bytePtr < seqStorePtr->lit; bytePtr++) 
+                countLit[*bytePtr]++; 
+        } 
+ 
+        /* seqStats */ 
+        {   U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart); 
+            ZSTD_seqToCodes(seqStorePtr); 
+ 
+            {   const BYTE* codePtr = seqStorePtr->ofCode; 
+                U32 u; 
+                for (u=0; u<nbSeq; u++) offsetcodeCount[codePtr[u]]++; 
+            } 
+ 
+            {   const BYTE* codePtr = seqStorePtr->mlCode; 
+                U32 u; 
+                for (u=0; u<nbSeq; u++) matchlengthCount[codePtr[u]]++; 
+            } 
+ 
+            {   const BYTE* codePtr = seqStorePtr->llCode; 
+                U32 u; 
+                for (u=0; u<nbSeq; u++) litlengthCount[codePtr[u]]++; 
+            } 
+ 
+            if (nbSeq >= 2) { /* rep offsets */ 
+                const seqDef* const seq = seqStorePtr->sequencesStart; 
                 U32 offset1 = seq[0].offBase - ZSTD_REP_NUM;
                 U32 offset2 = seq[1].offBase - ZSTD_REP_NUM;
-                if (offset1 >= MAXREPOFFSET) offset1 = 0;
-                if (offset2 >= MAXREPOFFSET) offset2 = 0;
-                repOffsets[offset1] += 3;
-                repOffsets[offset2] += 1;
-    }   }   }
-}
-
-static size_t ZDICT_totalSampleSize(const size_t* fileSizes, unsigned nbFiles)
-{
-    size_t total=0;
-    unsigned u;
-    for (u=0; u<nbFiles; u++) total += fileSizes[u];
-    return total;
-}
-
-typedef struct { U32 offset; U32 count; } offsetCount_t;
-
-static void ZDICT_insertSortCount(offsetCount_t table[ZSTD_REP_NUM+1], U32 val, U32 count)
-{
-    U32 u;
-    table[ZSTD_REP_NUM].offset = val;
-    table[ZSTD_REP_NUM].count = count;
-    for (u=ZSTD_REP_NUM; u>0; u--) {
-        offsetCount_t tmp;
-        if (table[u-1].count >= table[u].count) break;
-        tmp = table[u-1];
-        table[u-1] = table[u];
-        table[u] = tmp;
-    }
-}
-
+                if (offset1 >= MAXREPOFFSET) offset1 = 0; 
+                if (offset2 >= MAXREPOFFSET) offset2 = 0; 
+                repOffsets[offset1] += 3; 
+                repOffsets[offset2] += 1; 
+    }   }   } 
+} 
+ 
+static size_t ZDICT_totalSampleSize(const size_t* fileSizes, unsigned nbFiles) 
+{ 
+    size_t total=0; 
+    unsigned u; 
+    for (u=0; u<nbFiles; u++) total += fileSizes[u]; 
+    return total; 
+} 
+ 
+typedef struct { U32 offset; U32 count; } offsetCount_t; 
+ 
+static void ZDICT_insertSortCount(offsetCount_t table[ZSTD_REP_NUM+1], U32 val, U32 count) 
+{ 
+    U32 u; 
+    table[ZSTD_REP_NUM].offset = val; 
+    table[ZSTD_REP_NUM].count = count; 
+    for (u=ZSTD_REP_NUM; u>0; u--) { 
+        offsetCount_t tmp; 
+        if (table[u-1].count >= table[u].count) break; 
+        tmp = table[u-1]; 
+        table[u-1] = table[u]; 
+        table[u] = tmp; 
+    } 
+} 
+ 
 /* ZDICT_flatLit() :
  * rewrite `countLit` to contain a mostly flat but still compressible distribution of literals.
  * necessary to avoid generating a non-compressible distribution that HUF_writeCTable() cannot encode.
@@ -727,47 +727,47 @@ static void ZDICT_flatLit(unsigned* countLit)
     countLit[253] = 1;
     countLit[254] = 1;
 }
-
-#define OFFCODE_MAX 30  /* only applicable to first block */
-static size_t ZDICT_analyzeEntropy(void*  dstBuffer, size_t maxDstSize,
+ 
+#define OFFCODE_MAX 30  /* only applicable to first block */ 
+static size_t ZDICT_analyzeEntropy(void*  dstBuffer, size_t maxDstSize, 
                                    int compressionLevel,
                              const void*  srcBuffer, const size_t* fileSizes, unsigned nbFiles,
                              const void* dictBuffer, size_t  dictBufferSize,
                                    unsigned notificationLevel)
-{
+{ 
     unsigned countLit[256];
-    HUF_CREATE_STATIC_CTABLE(hufTable, 255);
+    HUF_CREATE_STATIC_CTABLE(hufTable, 255); 
     unsigned offcodeCount[OFFCODE_MAX+1];
-    short offcodeNCount[OFFCODE_MAX+1];
-    U32 offcodeMax = ZSTD_highbit32((U32)(dictBufferSize + 128 KB));
+    short offcodeNCount[OFFCODE_MAX+1]; 
+    U32 offcodeMax = ZSTD_highbit32((U32)(dictBufferSize + 128 KB)); 
     unsigned matchLengthCount[MaxML+1];
-    short matchLengthNCount[MaxML+1];
+    short matchLengthNCount[MaxML+1]; 
     unsigned litLengthCount[MaxLL+1];
-    short litLengthNCount[MaxLL+1];
-    U32 repOffset[MAXREPOFFSET];
-    offsetCount_t bestRepOffset[ZSTD_REP_NUM+1];
+    short litLengthNCount[MaxLL+1]; 
+    U32 repOffset[MAXREPOFFSET]; 
+    offsetCount_t bestRepOffset[ZSTD_REP_NUM+1]; 
     EStats_ress_t esr = { NULL, NULL, NULL };
-    ZSTD_parameters params;
-    U32 u, huffLog = 11, Offlog = OffFSELog, mlLog = MLFSELog, llLog = LLFSELog, total;
-    size_t pos = 0, errorCode;
-    size_t eSize = 0;
-    size_t const totalSrcSize = ZDICT_totalSampleSize(fileSizes, nbFiles);
+    ZSTD_parameters params; 
+    U32 u, huffLog = 11, 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 + !nbFiles);
-    BYTE* dstPtr = (BYTE*)dstBuffer;
-
-    /* init */
+    BYTE* dstPtr = (BYTE*)dstBuffer; 
+ 
+    /* init */ 
     DEBUGLOG(4, "ZDICT_analyzeEntropy");
     if (offcodeMax>OFFCODE_MAX) { eSize = ERROR(dictionaryCreation_failed); goto _cleanup; }   /* too large dictionary */
     for (u=0; u<256; u++) countLit[u] = 1;   /* any character must be described */
     for (u=0; u<=offcodeMax; u++) offcodeCount[u] = 1;
     for (u=0; u<=MaxML; u++) matchLengthCount[u] = 1;
     for (u=0; u<=MaxLL; u++) litLengthCount[u] = 1;
-    memset(repOffset, 0, sizeof(repOffset));
-    repOffset[1] = repOffset[4] = repOffset[8] = 1;
-    memset(bestRepOffset, 0, sizeof(bestRepOffset));
+    memset(repOffset, 0, sizeof(repOffset)); 
+    repOffset[1] = repOffset[4] = repOffset[8] = 1; 
+    memset(bestRepOffset, 0, sizeof(bestRepOffset)); 
     if (compressionLevel==0) compressionLevel = ZSTD_CLEVEL_DEFAULT;
-    params = ZSTD_getParams(compressionLevel, averageSampleSize, dictBufferSize);
-
+    params = ZSTD_getParams(compressionLevel, averageSampleSize, dictBufferSize); 
+ 
     esr.dict = ZSTD_createCDict_advanced(dictBuffer, dictBufferSize, ZSTD_dlm_byRef, ZSTD_dct_rawContent, params.cParams, ZSTD_defaultCMem);
     esr.zc = ZSTD_createCCtx();
     esr.workPlace = malloc(ZSTD_BLOCKSIZE_MAX);
@@ -778,14 +778,14 @@ static size_t ZDICT_analyzeEntropy(void*  dstBuffer, size_t maxDstSize,
     }
 
     /* collect stats on all samples */
-    for (u=0; u<nbFiles; u++) {
+    for (u=0; u<nbFiles; u++) { 
         ZDICT_countEStats(esr, &params,
                           countLit, offcodeCount, matchLengthCount, litLengthCount, repOffset,
                          (const char*)srcBuffer + pos, fileSizes[u],
                           notificationLevel);
-        pos += fileSizes[u];
-    }
-
+        pos += fileSizes[u]; 
+    } 
+ 
     if (notificationLevel >= 4) {
         /* writeStats */
         DISPLAYLEVEL(4, "Offset Code Frequencies : \n");
@@ -807,114 +807,114 @@ static size_t ZDICT_analyzeEntropy(void*  dstBuffer, size_t maxDstSize,
             assert(maxNbBits==9);
         }
         huffLog = (U32)maxNbBits;
-    }
-
-    /* looking for most common first offsets */
-    {   U32 offset;
-        for (offset=1; offset<MAXREPOFFSET; offset++)
-            ZDICT_insertSortCount(bestRepOffset, offset, repOffset[offset]);
-    }
-    /* note : the result of this phase should be used to better appreciate the impact on statistics */
-
-    total=0; for (u=0; u<=offcodeMax; u++) total+=offcodeCount[u];
+    } 
+ 
+    /* looking for most common first offsets */ 
+    {   U32 offset; 
+        for (offset=1; offset<MAXREPOFFSET; offset++) 
+            ZDICT_insertSortCount(bestRepOffset, offset, repOffset[offset]); 
+    } 
+    /* note : the result of this phase should be used to better appreciate the impact on statistics */ 
+ 
+    total=0; for (u=0; u<=offcodeMax; u++) total+=offcodeCount[u]; 
     errorCode = FSE_normalizeCount(offcodeNCount, Offlog, offcodeCount, total, offcodeMax, /* useLowProbCount */ 1);
-    if (FSE_isError(errorCode)) {
+    if (FSE_isError(errorCode)) { 
         eSize = errorCode;
         DISPLAYLEVEL(1, "FSE_normalizeCount error with offcodeCount \n");
-        goto _cleanup;
-    }
-    Offlog = (U32)errorCode;
-
-    total=0; for (u=0; u<=MaxML; u++) total+=matchLengthCount[u];
+        goto _cleanup; 
+    } 
+    Offlog = (U32)errorCode; 
+ 
+    total=0; for (u=0; u<=MaxML; u++) total+=matchLengthCount[u]; 
     errorCode = FSE_normalizeCount(matchLengthNCount, mlLog, matchLengthCount, total, MaxML, /* useLowProbCount */ 1);
-    if (FSE_isError(errorCode)) {
+    if (FSE_isError(errorCode)) { 
         eSize = errorCode;
         DISPLAYLEVEL(1, "FSE_normalizeCount error with matchLengthCount \n");
-        goto _cleanup;
-    }
-    mlLog = (U32)errorCode;
-
-    total=0; for (u=0; u<=MaxLL; u++) total+=litLengthCount[u];
+        goto _cleanup; 
+    } 
+    mlLog = (U32)errorCode; 
+ 
+    total=0; for (u=0; u<=MaxLL; u++) total+=litLengthCount[u]; 
     errorCode = FSE_normalizeCount(litLengthNCount, llLog, litLengthCount, total, MaxLL, /* useLowProbCount */ 1);
-    if (FSE_isError(errorCode)) {
+    if (FSE_isError(errorCode)) { 
         eSize = errorCode;
         DISPLAYLEVEL(1, "FSE_normalizeCount error with litLengthCount \n");
-        goto _cleanup;
-    }
-    llLog = (U32)errorCode;
-
-    /* write result to buffer */
-    {   size_t const hhSize = HUF_writeCTable(dstPtr, maxDstSize, hufTable, 255, huffLog);
-        if (HUF_isError(hhSize)) {
+        goto _cleanup; 
+    } 
+    llLog = (U32)errorCode; 
+ 
+    /* write result to buffer */ 
+    {   size_t const hhSize = HUF_writeCTable(dstPtr, maxDstSize, hufTable, 255, huffLog); 
+        if (HUF_isError(hhSize)) { 
             eSize = hhSize;
             DISPLAYLEVEL(1, "HUF_writeCTable error \n");
-            goto _cleanup;
-        }
-        dstPtr += hhSize;
-        maxDstSize -= hhSize;
-        eSize += hhSize;
-    }
-
-    {   size_t const ohSize = FSE_writeNCount(dstPtr, maxDstSize, offcodeNCount, OFFCODE_MAX, Offlog);
-        if (FSE_isError(ohSize)) {
+            goto _cleanup; 
+        } 
+        dstPtr += hhSize; 
+        maxDstSize -= hhSize; 
+        eSize += hhSize; 
+    } 
+ 
+    {   size_t const ohSize = FSE_writeNCount(dstPtr, maxDstSize, offcodeNCount, OFFCODE_MAX, Offlog); 
+        if (FSE_isError(ohSize)) { 
             eSize = ohSize;
             DISPLAYLEVEL(1, "FSE_writeNCount error with offcodeNCount \n");
-            goto _cleanup;
-        }
-        dstPtr += ohSize;
-        maxDstSize -= ohSize;
-        eSize += ohSize;
-    }
-
-    {   size_t const mhSize = FSE_writeNCount(dstPtr, maxDstSize, matchLengthNCount, MaxML, mlLog);
-        if (FSE_isError(mhSize)) {
+            goto _cleanup; 
+        } 
+        dstPtr += ohSize; 
+        maxDstSize -= ohSize; 
+        eSize += ohSize; 
+    } 
+ 
+    {   size_t const mhSize = FSE_writeNCount(dstPtr, maxDstSize, matchLengthNCount, MaxML, mlLog); 
+        if (FSE_isError(mhSize)) { 
             eSize = mhSize;
             DISPLAYLEVEL(1, "FSE_writeNCount error with matchLengthNCount \n");
-            goto _cleanup;
-        }
-        dstPtr += mhSize;
-        maxDstSize -= mhSize;
-        eSize += mhSize;
-    }
-
-    {   size_t const lhSize = FSE_writeNCount(dstPtr, maxDstSize, litLengthNCount, MaxLL, llLog);
-        if (FSE_isError(lhSize)) {
+            goto _cleanup; 
+        } 
+        dstPtr += mhSize; 
+        maxDstSize -= mhSize; 
+        eSize += mhSize; 
+    } 
+ 
+    {   size_t const lhSize = FSE_writeNCount(dstPtr, maxDstSize, litLengthNCount, MaxLL, llLog); 
+        if (FSE_isError(lhSize)) { 
             eSize = lhSize;
             DISPLAYLEVEL(1, "FSE_writeNCount error with litlengthNCount \n");
-            goto _cleanup;
-        }
-        dstPtr += lhSize;
-        maxDstSize -= lhSize;
-        eSize += lhSize;
-    }
-
-    if (maxDstSize<12) {
+            goto _cleanup; 
+        } 
+        dstPtr += lhSize; 
+        maxDstSize -= lhSize; 
+        eSize += lhSize; 
+    } 
+ 
+    if (maxDstSize<12) { 
         eSize = ERROR(dstSize_tooSmall);
         DISPLAYLEVEL(1, "not enough space to write RepOffsets \n");
-        goto _cleanup;
-    }
-# if 0
-    MEM_writeLE32(dstPtr+0, bestRepOffset[0].offset);
-    MEM_writeLE32(dstPtr+4, bestRepOffset[1].offset);
-    MEM_writeLE32(dstPtr+8, bestRepOffset[2].offset);
-#else
-    /* at this stage, we don't use the result of "most common first offset",
+        goto _cleanup; 
+    } 
+# if 0 
+    MEM_writeLE32(dstPtr+0, bestRepOffset[0].offset); 
+    MEM_writeLE32(dstPtr+4, bestRepOffset[1].offset); 
+    MEM_writeLE32(dstPtr+8, bestRepOffset[2].offset); 
+#else 
+    /* at this stage, we don't use the result of "most common first offset", 
      * as the impact of statistics is not properly evaluated */
-    MEM_writeLE32(dstPtr+0, repStartValue[0]);
-    MEM_writeLE32(dstPtr+4, repStartValue[1]);
-    MEM_writeLE32(dstPtr+8, repStartValue[2]);
-#endif
-    eSize += 12;
-
-_cleanup:
+    MEM_writeLE32(dstPtr+0, repStartValue[0]); 
+    MEM_writeLE32(dstPtr+4, repStartValue[1]); 
+    MEM_writeLE32(dstPtr+8, repStartValue[2]); 
+#endif 
+    eSize += 12; 
+ 
+_cleanup: 
     ZSTD_freeCDict(esr.dict);
-    ZSTD_freeCCtx(esr.zc);
-    free(esr.workPlace);
-
-    return eSize;
-}
-
-
+    ZSTD_freeCCtx(esr.zc); 
+    free(esr.workPlace); 
+ 
+    return eSize; 
+} 
+ 
+ 
 /**
  * @returns the maximum repcode value
  */
@@ -931,8 +931,8 @@ size_t ZDICT_finalizeDictionary(void* dictBuffer, size_t dictBufferCapacity,
                           const void* customDictContent, size_t dictContentSize,
                           const void* samplesBuffer, const size_t* samplesSizes,
                           unsigned nbSamples, ZDICT_params_t params)
-{
-    size_t hSize;
+{ 
+    size_t hSize; 
 #define HBUFFSIZE 256   /* should prove large enough for all entropy headers */
     BYTE header[HBUFFSIZE];
     int const compressionLevel = (params.compressionLevel == 0) ? ZSTD_CLEVEL_DEFAULT : params.compressionLevel;
@@ -940,24 +940,24 @@ size_t ZDICT_finalizeDictionary(void* dictBuffer, size_t dictBufferCapacity,
     /* The final dictionary content must be at least as large as the largest repcode */
     size_t const minContentSize = (size_t)ZDICT_maxRep(repStartValue);
     size_t paddingSize;
-
+ 
     /* check conditions */
     DEBUGLOG(4, "ZDICT_finalizeDictionary");
     if (dictBufferCapacity < dictContentSize) return ERROR(dstSize_tooSmall);
     if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) return ERROR(dstSize_tooSmall);
 
-    /* dictionary header */
+    /* dictionary header */ 
     MEM_writeLE32(header, ZSTD_MAGIC_DICTIONARY);
     {   U64 const randomID = XXH64(customDictContent, dictContentSize, 0);
-        U32 const compliantID = (randomID % ((1U<<31)-32768)) + 32768;
-        U32 const dictID = params.dictID ? params.dictID : compliantID;
+        U32 const compliantID = (randomID % ((1U<<31)-32768)) + 32768; 
+        U32 const dictID = params.dictID ? params.dictID : compliantID; 
         MEM_writeLE32(header+4, dictID);
-    }
-    hSize = 8;
-
-    /* entropy tables */
-    DISPLAYLEVEL(2, "\r%70s\r", "");   /* clean display line */
-    DISPLAYLEVEL(2, "statistics ... \n");
+    } 
+    hSize = 8; 
+ 
+    /* entropy tables */ 
+    DISPLAYLEVEL(2, "\r%70s\r", "");   /* clean display line */ 
+    DISPLAYLEVEL(2, "statistics ... \n"); 
     {   size_t const eSize = ZDICT_analyzeEntropy(header+hSize, HBUFFSIZE-hSize,
                                   compressionLevel,
                                   samplesBuffer, samplesSizes, nbSamples,
@@ -1022,14 +1022,14 @@ static size_t ZDICT_addEntropyTablesFromBuffer_advanced(
     DISPLAYLEVEL(2, "\r%70s\r", "");   /* clean display line */
     DISPLAYLEVEL(2, "statistics ... \n");
     {   size_t const eSize = ZDICT_analyzeEntropy((char*)dictBuffer+hSize, dictBufferCapacity-hSize,
-                                  compressionLevel,
-                                  samplesBuffer, samplesSizes, nbSamples,
+                                  compressionLevel, 
+                                  samplesBuffer, samplesSizes, nbSamples, 
                                   (char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize,
                                   notificationLevel);
         if (ZDICT_isError(eSize)) return eSize;
         hSize += eSize;
     }
-
+ 
     /* add dictionary header (after entropy tables) */
     MEM_writeLE32(dictBuffer, ZSTD_MAGIC_DICTIONARY);
     {   U64 const randomID = XXH64((char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize, 0);
@@ -1038,44 +1038,44 @@ static size_t ZDICT_addEntropyTablesFromBuffer_advanced(
         MEM_writeLE32((char*)dictBuffer+4, dictID);
     }
 
-    if (hSize + dictContentSize < dictBufferCapacity)
-        memmove((char*)dictBuffer + hSize, (char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize);
-    return MIN(dictBufferCapacity, hSize+dictContentSize);
-}
-
+    if (hSize + dictContentSize < dictBufferCapacity) 
+        memmove((char*)dictBuffer + hSize, (char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize); 
+    return MIN(dictBufferCapacity, hSize+dictContentSize); 
+} 
+ 
 /*! ZDICT_trainFromBuffer_unsafe_legacy() :
 *   Warning : `samplesBuffer` must be followed by noisy guard band !!!
-*   @return : size of dictionary, or an error code which can be tested with ZDICT_isError()
-*/
+*   @return : size of dictionary, or an error code which can be tested with ZDICT_isError() 
+*/ 
 static size_t ZDICT_trainFromBuffer_unsafe_legacy(
-                            void* dictBuffer, size_t maxDictSize,
-                            const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
+                            void* dictBuffer, size_t maxDictSize, 
+                            const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples, 
                             ZDICT_legacy_params_t params)
-{
+{ 
     U32 const dictListSize = MAX(MAX(DICTLISTSIZE_DEFAULT, nbSamples), (U32)(maxDictSize/16));
-    dictItem* const dictList = (dictItem*)malloc(dictListSize * sizeof(*dictList));
-    unsigned const selectivity = params.selectivityLevel == 0 ? g_selectivity_default : params.selectivityLevel;
-    unsigned const minRep = (selectivity > 30) ? MINRATIO : nbSamples >> selectivity;
-    size_t const targetDictSize = maxDictSize;
-    size_t const samplesBuffSize = ZDICT_totalSampleSize(samplesSizes, nbSamples);
-    size_t dictSize = 0;
+    dictItem* const dictList = (dictItem*)malloc(dictListSize * sizeof(*dictList)); 
+    unsigned const selectivity = params.selectivityLevel == 0 ? g_selectivity_default : params.selectivityLevel; 
+    unsigned const minRep = (selectivity > 30) ? MINRATIO : nbSamples >> selectivity; 
+    size_t const targetDictSize = maxDictSize; 
+    size_t const samplesBuffSize = ZDICT_totalSampleSize(samplesSizes, nbSamples); 
+    size_t dictSize = 0; 
     U32 const notificationLevel = params.zParams.notificationLevel;
-
-    /* checks */
-    if (!dictList) return ERROR(memory_allocation);
+ 
+    /* checks */ 
+    if (!dictList) return ERROR(memory_allocation); 
     if (maxDictSize < ZDICT_DICTSIZE_MIN) { free(dictList); return ERROR(dstSize_tooSmall); }   /* requested dictionary size is too small */
     if (samplesBuffSize < ZDICT_MIN_SAMPLES_SIZE) { free(dictList); return ERROR(dictionaryCreation_failed); }   /* not enough source to create dictionary */
-
-    /* init */
-    ZDICT_initDictItem(dictList);
-
-    /* build dictionary */
+ 
+    /* init */ 
+    ZDICT_initDictItem(dictList); 
+ 
+    /* build dictionary */ 
     ZDICT_trainBuffer_legacy(dictList, dictListSize,
                        samplesBuffer, samplesBuffSize,
                        samplesSizes, nbSamples,
                        minRep, notificationLevel);
-
-    /* display best matches */
+ 
+    /* display best matches */ 
     if (params.zParams.notificationLevel>= 3) {
         unsigned const nb = MIN(25, dictList[0].pos);
         unsigned const dictContentSize = ZDICT_dictSize(dictList);
@@ -1090,98 +1090,98 @@ static size_t ZDICT_trainFromBuffer_unsafe_legacy(
                 free(dictList);
                 return ERROR(GENERIC);   /* should never happen */
             }
-            DISPLAYLEVEL(3, "%3u:%3u bytes at pos %8u, savings %7u bytes |",
+            DISPLAYLEVEL(3, "%3u:%3u bytes at pos %8u, savings %7u bytes |", 
                          u, length, pos, (unsigned)dictList[u].savings);
             ZDICT_printHex((const char*)samplesBuffer+pos, printedLength);
-            DISPLAYLEVEL(3, "| \n");
-    }   }
-
-
-    /* create dictionary */
+            DISPLAYLEVEL(3, "| \n"); 
+    }   } 
+ 
+ 
+    /* create dictionary */ 
     {   unsigned dictContentSize = ZDICT_dictSize(dictList);
         if (dictContentSize < ZDICT_CONTENTSIZE_MIN) { free(dictList); return ERROR(dictionaryCreation_failed); }   /* dictionary content too small */
         if (dictContentSize < targetDictSize/4) {
             DISPLAYLEVEL(2, "!  warning : selected content significantly smaller than requested (%u < %u) \n", dictContentSize, (unsigned)maxDictSize);
             if (samplesBuffSize < 10 * targetDictSize)
                 DISPLAYLEVEL(2, "!  consider increasing the number of samples (total size : %u MB)\n", (unsigned)(samplesBuffSize>>20));
-            if (minRep > MINRATIO) {
-                DISPLAYLEVEL(2, "!  consider increasing selectivity to produce larger dictionary (-s%u) \n", selectivity+1);
-                DISPLAYLEVEL(2, "!  note : larger dictionaries are not necessarily better, test its efficiency on samples \n");
-            }
-        }
-
+            if (minRep > MINRATIO) { 
+                DISPLAYLEVEL(2, "!  consider increasing selectivity to produce larger dictionary (-s%u) \n", selectivity+1); 
+                DISPLAYLEVEL(2, "!  note : larger dictionaries are not necessarily better, test its efficiency on samples \n"); 
+            } 
+        } 
+ 
         if ((dictContentSize > targetDictSize*3) && (nbSamples > 2*MINRATIO) && (selectivity>1)) {
             unsigned proposedSelectivity = selectivity-1;
-            while ((nbSamples >> proposedSelectivity) <= MINRATIO) { proposedSelectivity--; }
+            while ((nbSamples >> proposedSelectivity) <= MINRATIO) { proposedSelectivity--; } 
             DISPLAYLEVEL(2, "!  note : calculated dictionary significantly larger than requested (%u > %u) \n", dictContentSize, (unsigned)maxDictSize);
             DISPLAYLEVEL(2, "!  consider increasing dictionary size, or produce denser dictionary (-s%u) \n", proposedSelectivity);
             DISPLAYLEVEL(2, "!  always test dictionary efficiency on real samples \n");
-        }
-
-        /* limit dictionary size */
-        {   U32 const 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 > targetDictSize) { currentSize -= dictList[n].length; break; }
-            }
-            dictList->pos = n;
-            dictContentSize = currentSize;
-        }
-
-        /* build dict content */
-        {   U32 u;
-            BYTE* ptr = (BYTE*)dictBuffer + maxDictSize;
-            for (u=1; u<dictList->pos; u++) {
-                U32 l = dictList[u].length;
-                ptr -= l;
-                if (ptr<(BYTE*)dictBuffer) { free(dictList); return ERROR(GENERIC); }   /* should not happen */
-                memcpy(ptr, (const char*)samplesBuffer+dictList[u].pos, l);
-        }   }
-
-        dictSize = ZDICT_addEntropyTablesFromBuffer_advanced(dictBuffer, dictContentSize, maxDictSize,
-                                                             samplesBuffer, samplesSizes, nbSamples,
+        } 
+ 
+        /* limit dictionary size */ 
+        {   U32 const 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 > targetDictSize) { currentSize -= dictList[n].length; break; } 
+            } 
+            dictList->pos = n; 
+            dictContentSize = currentSize; 
+        } 
+ 
+        /* build dict content */ 
+        {   U32 u; 
+            BYTE* ptr = (BYTE*)dictBuffer + maxDictSize; 
+            for (u=1; u<dictList->pos; u++) { 
+                U32 l = dictList[u].length; 
+                ptr -= l; 
+                if (ptr<(BYTE*)dictBuffer) { free(dictList); return ERROR(GENERIC); }   /* should not happen */ 
+                memcpy(ptr, (const char*)samplesBuffer+dictList[u].pos, l); 
+        }   } 
+ 
+        dictSize = ZDICT_addEntropyTablesFromBuffer_advanced(dictBuffer, dictContentSize, maxDictSize, 
+                                                             samplesBuffer, samplesSizes, nbSamples, 
                                                              params.zParams);
-    }
-
-    /* clean up */
-    free(dictList);
-    return dictSize;
-}
-
-
+    } 
+ 
+    /* clean up */ 
+    free(dictList); 
+    return dictSize; 
+} 
+ 
+ 
 /* ZDICT_trainFromBuffer_legacy() :
  * issue : samplesBuffer need to be followed by a noisy guard band.
  * work around : duplicate the buffer, and add the noise */
 size_t ZDICT_trainFromBuffer_legacy(void* dictBuffer, size_t dictBufferCapacity,
                               const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
                               ZDICT_legacy_params_t params)
-{
-    size_t result;
-    void* newBuff;
-    size_t const sBuffSize = ZDICT_totalSampleSize(samplesSizes, nbSamples);
+{ 
+    size_t result; 
+    void* newBuff; 
+    size_t const sBuffSize = ZDICT_totalSampleSize(samplesSizes, nbSamples); 
     if (sBuffSize < ZDICT_MIN_SAMPLES_SIZE) return 0;   /* not enough 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 */
-
+ 
+    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 */ 
+ 
     result =
         ZDICT_trainFromBuffer_unsafe_legacy(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)
-{
+    free(newBuff); 
+    return result; 
+} 
+ 
+ 
+size_t ZDICT_trainFromBuffer(void* dictBuffer, size_t dictBufferCapacity, 
+                             const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples) 
+{ 
     ZDICT_fastCover_params_t params;
     DEBUGLOG(3, "ZDICT_trainFromBuffer");
-    memset(&params, 0, sizeof(params));
+    memset(&params, 0, sizeof(params)); 
     params.d = 8;
     params.steps = 4;
     /* Use default level since no compression level information is available */
@@ -1192,14 +1192,14 @@ size_t ZDICT_trainFromBuffer(void* dictBuffer, size_t dictBufferCapacity,
     return ZDICT_optimizeTrainFromBuffer_fastCover(dictBuffer, dictBufferCapacity,
                                                samplesBuffer, samplesSizes, nbSamples,
                                                &params);
-}
-
-size_t ZDICT_addEntropyTablesFromBuffer(void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity,
+} 
+ 
+size_t ZDICT_addEntropyTablesFromBuffer(void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity, 
                                   const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples)
-{
-    ZDICT_params_t params;
-    memset(&params, 0, sizeof(params));
-    return ZDICT_addEntropyTablesFromBuffer_advanced(dictBuffer, dictContentSize, dictBufferCapacity,
-                                                     samplesBuffer, samplesSizes, nbSamples,
-                                                     params);
-}
+{ 
+    ZDICT_params_t params; 
+    memset(&params, 0, sizeof(params)); 
+    return ZDICT_addEntropyTablesFromBuffer_advanced(dictBuffer, dictContentSize, dictBufferCapacity, 
+                                                     samplesBuffer, samplesSizes, nbSamples, 
+                                                     params); 
+} 
diff --git a/contrib/libs/zstd/lib/legacy/zstd_legacy.h b/contrib/libs/zstd/lib/legacy/zstd_legacy.h
index a6f1174b82..4e82338cf5 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_legacy.h
+++ b/contrib/libs/zstd/lib/legacy/zstd_legacy.h
@@ -7,26 +7,26 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-#ifndef ZSTD_LEGACY_H
-#define ZSTD_LEGACY_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* *************************************
-*  Includes
-***************************************/
+ 
+#ifndef ZSTD_LEGACY_H 
+#define ZSTD_LEGACY_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/* ************************************* 
+*  Includes 
+***************************************/ 
 #include "../common/mem.h"            /* MEM_STATIC */
 #include "../common/error_private.h"  /* ERROR */
 #include "../common/zstd_internal.h"  /* ZSTD_inBuffer, ZSTD_outBuffer, ZSTD_frameSizeInfo */
-
+ 
 #if !defined (ZSTD_LEGACY_SUPPORT) || (ZSTD_LEGACY_SUPPORT == 0)
 #  undef ZSTD_LEGACY_SUPPORT
 #  define ZSTD_LEGACY_SUPPORT 8
 #endif
-
+ 
 #if (ZSTD_LEGACY_SUPPORT <= 1)
 #  include "zstd_v01.h"
 #endif
@@ -49,45 +49,45 @@ extern "C" {
 #  include "zstd_v07.h"
 #endif
 
-/** ZSTD_isLegacy() :
-    @return : > 0 if supported by legacy decoder. 0 otherwise.
-              return value is the version.
-*/
-MEM_STATIC unsigned ZSTD_isLegacy(const void* src, size_t srcSize)
-{
-    U32 magicNumberLE;
-    if (srcSize<4) return 0;
-    magicNumberLE = MEM_readLE32(src);
-    switch(magicNumberLE)
-    {
+/** ZSTD_isLegacy() : 
+    @return : > 0 if supported by legacy decoder. 0 otherwise. 
+              return value is the version. 
+*/ 
+MEM_STATIC unsigned ZSTD_isLegacy(const void* src, size_t srcSize) 
+{ 
+    U32 magicNumberLE; 
+    if (srcSize<4) return 0; 
+    magicNumberLE = MEM_readLE32(src); 
+    switch(magicNumberLE) 
+    { 
 #if (ZSTD_LEGACY_SUPPORT <= 1)
-        case ZSTDv01_magicNumberLE:return 1;
+        case ZSTDv01_magicNumberLE:return 1; 
 #endif
 #if (ZSTD_LEGACY_SUPPORT <= 2)
-        case ZSTDv02_magicNumber : return 2;
+        case ZSTDv02_magicNumber : return 2; 
 #endif
 #if (ZSTD_LEGACY_SUPPORT <= 3)
-        case ZSTDv03_magicNumber : return 3;
+        case ZSTDv03_magicNumber : return 3; 
 #endif
 #if (ZSTD_LEGACY_SUPPORT <= 4)
-        case ZSTDv04_magicNumber : return 4;
+        case ZSTDv04_magicNumber : return 4; 
 #endif
 #if (ZSTD_LEGACY_SUPPORT <= 5)
-        case ZSTDv05_MAGICNUMBER : return 5;
+        case ZSTDv05_MAGICNUMBER : return 5; 
 #endif
 #if (ZSTD_LEGACY_SUPPORT <= 6)
-        case ZSTDv06_MAGICNUMBER : return 6;
+        case ZSTDv06_MAGICNUMBER : return 6; 
 #endif
 #if (ZSTD_LEGACY_SUPPORT <= 7)
-        case ZSTDv07_MAGICNUMBER : return 7;
-#endif
-        default : return 0;
-    }
-}
-
-
-MEM_STATIC unsigned long long ZSTD_getDecompressedSize_legacy(const void* src, size_t srcSize)
-{
+        case ZSTDv07_MAGICNUMBER : return 7; 
+#endif
+        default : return 0; 
+    } 
+} 
+ 
+ 
+MEM_STATIC unsigned long long ZSTD_getDecompressedSize_legacy(const void* src, size_t srcSize) 
+{ 
     U32 const version = ZSTD_isLegacy(src, srcSize);
     if (version < 5) return 0;  /* no decompressed size in frame header, or not a legacy format */
 #if (ZSTD_LEGACY_SUPPORT <= 5)
@@ -96,7 +96,7 @@ MEM_STATIC unsigned long long ZSTD_getDecompressedSize_legacy(const void* src, s
         size_t const frResult = ZSTDv05_getFrameParams(&fParams, src, srcSize);
         if (frResult != 0) return 0;
         return fParams.srcSize;
-    }
+    } 
 #endif
 #if (ZSTD_LEGACY_SUPPORT <= 6)
     if (version==6) {
@@ -115,69 +115,69 @@ MEM_STATIC unsigned long long ZSTD_getDecompressedSize_legacy(const void* src, s
     }
 #endif
     return 0;   /* should not be possible */
-}
-
+} 
+ 
 
-MEM_STATIC size_t ZSTD_decompressLegacy(
-                     void* dst, size_t dstCapacity,
-               const void* src, size_t compressedSize,
-               const void* dict,size_t dictSize)
-{
-    U32 const version = ZSTD_isLegacy(src, compressedSize);
+MEM_STATIC size_t ZSTD_decompressLegacy( 
+                     void* dst, size_t dstCapacity, 
+               const void* src, size_t compressedSize, 
+               const void* dict,size_t dictSize) 
+{ 
+    U32 const version = ZSTD_isLegacy(src, compressedSize); 
     (void)dst; (void)dstCapacity; (void)dict; (void)dictSize;  /* unused when ZSTD_LEGACY_SUPPORT >= 8 */
-    switch(version)
-    {
+    switch(version) 
+    { 
 #if (ZSTD_LEGACY_SUPPORT <= 1)
-        case 1 :
-            return ZSTDv01_decompress(dst, dstCapacity, src, compressedSize);
+        case 1 : 
+            return ZSTDv01_decompress(dst, dstCapacity, src, compressedSize); 
 #endif
 #if (ZSTD_LEGACY_SUPPORT <= 2)
-        case 2 :
-            return ZSTDv02_decompress(dst, dstCapacity, src, compressedSize);
+        case 2 : 
+            return ZSTDv02_decompress(dst, dstCapacity, src, compressedSize); 
 #endif
 #if (ZSTD_LEGACY_SUPPORT <= 3)
-        case 3 :
-            return ZSTDv03_decompress(dst, dstCapacity, src, compressedSize);
+        case 3 : 
+            return ZSTDv03_decompress(dst, dstCapacity, src, compressedSize); 
 #endif
 #if (ZSTD_LEGACY_SUPPORT <= 4)
-        case 4 :
-            return ZSTDv04_decompress(dst, dstCapacity, src, compressedSize);
+        case 4 : 
+            return ZSTDv04_decompress(dst, dstCapacity, src, compressedSize); 
 #endif
 #if (ZSTD_LEGACY_SUPPORT <= 5)
-        case 5 :
-            {   size_t result;
-                ZSTDv05_DCtx* const zd = ZSTDv05_createDCtx();
-                if (zd==NULL) return ERROR(memory_allocation);
-                result = ZSTDv05_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);
-                ZSTDv05_freeDCtx(zd);
-                return result;
-            }
+        case 5 : 
+            {   size_t result; 
+                ZSTDv05_DCtx* const zd = ZSTDv05_createDCtx(); 
+                if (zd==NULL) return ERROR(memory_allocation); 
+                result = ZSTDv05_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize); 
+                ZSTDv05_freeDCtx(zd); 
+                return result; 
+            } 
 #endif
 #if (ZSTD_LEGACY_SUPPORT <= 6)
-        case 6 :
-            {   size_t result;
-                ZSTDv06_DCtx* const zd = ZSTDv06_createDCtx();
-                if (zd==NULL) return ERROR(memory_allocation);
-                result = ZSTDv06_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);
-                ZSTDv06_freeDCtx(zd);
-                return result;
-            }
+        case 6 : 
+            {   size_t result; 
+                ZSTDv06_DCtx* const zd = ZSTDv06_createDCtx(); 
+                if (zd==NULL) return ERROR(memory_allocation); 
+                result = ZSTDv06_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize); 
+                ZSTDv06_freeDCtx(zd); 
+                return result; 
+            } 
 #endif
 #if (ZSTD_LEGACY_SUPPORT <= 7)
-        case 7 :
-            {   size_t result;
-                ZSTDv07_DCtx* const zd = ZSTDv07_createDCtx();
-                if (zd==NULL) return ERROR(memory_allocation);
-                result = ZSTDv07_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);
-                ZSTDv07_freeDCtx(zd);
-                return result;
-            }
-#endif
-        default :
-            return ERROR(prefix_unknown);
-    }
-}
-
+        case 7 : 
+            {   size_t result; 
+                ZSTDv07_DCtx* const zd = ZSTDv07_createDCtx(); 
+                if (zd==NULL) return ERROR(memory_allocation); 
+                result = ZSTDv07_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize); 
+                ZSTDv07_freeDCtx(zd); 
+                return result; 
+            } 
+#endif
+        default : 
+            return ERROR(prefix_unknown); 
+    } 
+} 
+ 
 MEM_STATIC ZSTD_frameSizeInfo ZSTD_findFrameSizeInfoLegacy(const void *src, size_t srcSize)
 {
     ZSTD_frameSizeInfo frameSizeInfo;
@@ -244,7 +244,7 @@ MEM_STATIC ZSTD_frameSizeInfo ZSTD_findFrameSizeInfoLegacy(const void *src, size
     }
     return frameSizeInfo;
 }
-
+ 
 MEM_STATIC size_t ZSTD_findFrameCompressedSizeLegacy(const void *src, size_t srcSize)
 {
     ZSTD_frameSizeInfo frameSizeInfo = ZSTD_findFrameSizeInfoLegacy(src, srcSize);
@@ -275,7 +275,7 @@ MEM_STATIC size_t ZSTD_freeLegacyStreamContext(void* legacyContext, U32 version)
 #endif
     }
 }
-
+ 
 
 MEM_STATIC size_t ZSTD_initLegacyStream(void** legacyContext, U32 prevVersion, U32 newVersion,
                                         const void* dict, size_t dictSize)
@@ -408,8 +408,8 @@ MEM_STATIC size_t ZSTD_decompressLegacyStream(void* legacyContext, U32 version,
 }
 
 
-#if defined (__cplusplus)
-}
-#endif
-
-#endif   /* ZSTD_LEGACY_H */
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif   /* ZSTD_LEGACY_H */ 
diff --git a/contrib/libs/zstd/lib/legacy/zstd_v01.c b/contrib/libs/zstd/lib/legacy/zstd_v01.c
index 23caaef564..71e2ac44d2 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_v01.c
+++ b/contrib/libs/zstd/lib/legacy/zstd_v01.c
@@ -7,1083 +7,1083 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-
-/******************************************
-*  Includes
-******************************************/
-#include <stddef.h>    /* size_t, ptrdiff_t */
-#include "zstd_v01.h"
+ 
+ 
+/****************************************** 
+*  Includes 
+******************************************/ 
+#include <stddef.h>    /* size_t, ptrdiff_t */ 
+#include "zstd_v01.h" 
 #include "../common/error_private.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__)
+ 
+ 
+/****************************************** 
+*  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__) 
 #  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
 #    ifdef __GNUC__
 #      define FORCE_INLINE static inline __attribute__((always_inline))
 #    else
 #      define FORCE_INLINE static inline
 #    endif
-#  else
+#  else 
 #    define FORCE_INLINE static
 #  endif /* __STDC_VERSION__ */
-#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 */
+#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(__INTEL_COMPILER) || defined(__GNUC__) || defined(__ICCARM__)
-#    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;
-}
-
+#    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
-****************************************************************/
+ 
+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 (U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
-    unsigned long r;
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
+    unsigned long r; 
     return _BitScanReverse(&r, val) ? (unsigned)r : 0;
-#   elif defined(__GNUC__) && (GCC_VERSION >= 304)   /* GCC Intrinsic */
+#   elif defined(__GNUC__) && (GCC_VERSION >= 304)   /* GCC Intrinsic */ 
     return __builtin_clz (val) ^ 31;
-#   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 */
-
-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);
+#   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 */ 
+ 
+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); 
                     /* fallthrough */
-            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24); 
                     /* fallthrough */
-            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32); 
                     /* fallthrough */
-            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; 
                     /* fallthrough */
-            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; 
                     /* fallthrough */
-            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8;
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8; 
                     /* fallthrough */
-            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;
+            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;
-    size_t oSize;
-    U32 n;
-    U32 nextRankStart;
-    void* ptr = DTable+1;
-    HUF_DElt* const dt = (HUF_DElt*)ptr;
-
+    size_t oSize; 
+    U32 n; 
+    U32 nextRankStart; 
+    void* ptr = DTable+1; 
+    HUF_DElt* const dt = (HUF_DElt*)ptr; 
+ 
     if (!srcSize) return (size_t)-FSE_ERROR_srcSize_wrong;
     iSize = ip[0];
 
-    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;
-    }
+    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; 
+    } 
     if (weightTotal == 0) return (size_t)-FSE_ERROR_corruptionDetected;
-
-    /* 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)
-{
+ 
+    /* 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) 
+{ 
     if (cSrcSize < 6) return (size_t)-FSE_ERROR_srcSize_wrong;
     {
         BYTE* const ostart = (BYTE*) dst;
         BYTE* op = ostart;
         BYTE* const omax = op + maxDstSize;
         BYTE* const olimit = maxDstSize < 15 ? op : 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);
@@ -1094,9 +1094,9 @@ static size_t HUF_decompress_usingDTable(   /* -3% slower when non static */
         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);
@@ -1105,24 +1105,24 @@ static size_t HUF_decompress_usingDTable(   /* -3% slower when non static */
         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);
@@ -1140,12 +1140,12 @@ static size_t HUF_decompress_usingDTable(   /* -3% slower when non static */
             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;
@@ -1159,469 +1159,469 @@ static size_t HUF_decompress_usingDTable(   /* -3% slower when non static */
 
             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
-    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 */
-#  include <intrin.h>                    /* For Visual 2005 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
-#endif
-
-
-#ifndef MEM_ACCESS_MODULE
-#define MEM_ACCESS_MODULE
-/********************************************************
-*  Basic Types
-*********************************************************/
-#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+    } 
+} 
+ 
+ 
+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 
+    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 */ 
+#  include <intrin.h>                    /* For Visual 2005 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */ 
+#endif 
+ 
+ 
+#ifndef MEM_ACCESS_MODULE 
+#define MEM_ACCESS_MODULE 
+/******************************************************** 
+*  Basic Types 
+*********************************************************/ 
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */ 
 # if defined(_AIX)
 #  include <inttypes.h>
 # else
 #  include <stdint.h> /* intptr_t */
 # endif
-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 */
-
+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 */ 
+ 
 #define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
 
-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 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 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 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, ptrdiff_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));
-    }
-}
-
+{ 
+    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_readLE24(const void* memPtr)
-{
+{ 
     return ZSTD_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);
-}
-
-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
+} 
+ 
+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
-**************************************/
-/* published entry point */
+} cctxi_t; 
+ 
+ 
+ 
+ 
+/************************************** 
+*  Error Management 
+**************************************/ 
+/* published entry point */ 
 unsigned ZSTDv01_isError(size_t code) { return ERR_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
-**************************************************************/
-
+ 
+ 
+/************************************** 
+*  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 ZSTDv01_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
-{
-    const BYTE* const in = (const BYTE* const)src;
-    BYTE headerFlags;
-    U32 cSize;
-
+{ 
+    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)
-{
+ 
+    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);
     if (srcSize > 0) {
         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 */
+    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 ERROR(corruption_detected);
-
-    litSize = ip[1] + (ip[0]<<8);
+ 
+    litSize = ip[1] + (ip[0]<<8); 
     litSize += ((ip[-3] >> 3) & 7) << 16;   /* mmmmh.... */
-    op = oend - litSize;
-
-    (void)ctx;
+    op = oend - litSize; 
+ 
+    (void)ctx; 
     if (litSize > maxDstSize) return ERROR(dstSize_tooSmall);
-    errorCode = HUF_decompress(op, litSize, ip+2, srcSize-2);
+    errorCode = HUF_decompress(op, litSize, ip+2, srcSize-2); 
     if (FSE_isError(errorCode)) return ERROR(GENERIC);
-    return litSize;
-}
-
-
+    return litSize; 
+} 
+ 
+ 
 static size_t ZSTDv01_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;
-
+                                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 = ZSTDv01_getcBlockSize(src, srcSize, &litbp);
     if (ZSTDv01_isError(litcSize)) return litcSize;
     if (litcSize > srcSize - ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
-    ip += ZSTD_blockHeaderSize;
-
-    switch(litbp.blockType)
-    {
-    case bt_raw:
-        *litStart = ip;
-        ip += litcSize;
-        *litSize = litcSize;
-        break;
-    case bt_rle:
-        {
-            size_t rleSize = litbp.origSize;
+    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 ERROR(dstSize_tooSmall);
             if (!srcSize) return ERROR(srcSize_wrong);
             if (rleSize > 0) {
                 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);
+            *litStart = oend - rleSize; 
+            *litSize = rleSize; 
+            ip++; 
+            break; 
+        } 
+    case bt_compressed: 
+        { 
+            size_t decodedLitSize = ZSTD_decompressLiterals(ctx, dst, maxDstSize, ip, litcSize); 
             if (ZSTDv01_isError(decodedLitSize)) return decodedLitSize;
-            *litStart = oend - decodedLitSize;
-            *litSize = decodedLitSize;
-            ip += litcSize;
-            break;
-        }
-    case bt_end:
-    default:
+            *litStart = oend - decodedLitSize; 
+            *litSize = decodedLitSize; 
+            ip += litcSize; 
+            break; 
+        } 
+    case bt_end: 
+    default: 
         return ERROR(GENERIC);
-    }
-
-    return ip-istart;
-}
-
-
+    } 
+ 
+    return ip-istart; 
+} 
+ 
+ 
 static size_t ZSTDv01_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 */
+                         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 = 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 */
+ 
+    /* 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 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)
-        {
-        case bt_rle :
-            LLlog = 0;
-            FSE_buildDTable_rle(DTableLL, *ip++); break;
-        case bt_raw :
-            LLlog = LLbits;
-            FSE_buildDTable_raw(DTableLL, LLbits); break;
-        default :
+ 
+    /* sequences */ 
+    { 
+        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL and MaxOff */ 
+        size_t headerSize; 
+ 
+        /* Build DTables */ 
+        switch(LLtype) 
+        { 
+        case bt_rle : 
+            LLlog = 0; 
+            FSE_buildDTable_rle(DTableLL, *ip++); break; 
+        case bt_raw : 
+            LLlog = LLbits; 
+            FSE_buildDTable_raw(DTableLL, LLbits); break; 
+        default : 
             {   U32 max = MaxLL;
                 headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);
                 if (FSE_isError(headerSize)) return ERROR(GENERIC);
@@ -1629,17 +1629,17 @@ static size_t ZSTDv01_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t
                 ip += headerSize;
                 FSE_buildDTable(DTableLL, norm, max, LLlog);
         }   }
-
-        switch(Offtype)
-        {
-        case bt_rle :
-            Offlog = 0;
+ 
+        switch(Offtype) 
+        { 
+        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++); break;
-        case bt_raw :
-            Offlog = Offbits;
-            FSE_buildDTable_raw(DTableOffb, Offbits); break;
-        default :
+            FSE_buildDTable_rle(DTableOffb, *ip++); break; 
+        case bt_raw : 
+            Offlog = Offbits; 
+            FSE_buildDTable_raw(DTableOffb, Offbits); break; 
+        default : 
             {   U32 max = MaxOff;
                 headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);
                 if (FSE_isError(headerSize)) return ERROR(GENERIC);
@@ -1647,17 +1647,17 @@ static size_t ZSTDv01_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t
                 ip += headerSize;
                 FSE_buildDTable(DTableOffb, norm, max, Offlog);
         }   }
-
-        switch(MLtype)
-        {
-        case bt_rle :
-            MLlog = 0;
+ 
+        switch(MLtype) 
+        { 
+        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 :
+            FSE_buildDTable_rle(DTableML, *ip++); break; 
+        case bt_raw : 
+            MLlog = MLbits; 
+            FSE_buildDTable_raw(DTableML, MLbits); break; 
+        default : 
             {   U32 max = MaxML;
                 headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);
                 if (FSE_isError(headerSize)) return ERROR(GENERIC);
@@ -1665,342 +1665,342 @@ static size_t ZSTDv01_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t
                 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)
-    {
+ 
+    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) 
+    { 
         const U32 add = dumps<de ? *dumps++ : 0;
-        if (add < 255) litLength += add;
-        else
-        {
-            if (dumps<=(de-3))
-            {
+        if (add < 255) litLength += add; 
+        else 
+        { 
+            if (dumps<=(de-3)) 
+            { 
                 litLength = ZSTD_readLE24(dumps);
-                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)
-    {
+                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) 
+    { 
         const U32 add = dumps<de ? *dumps++ : 0;
-        if (add < 255) matchLength += add;
-        else
-        {
-            if (dumps<=(de-3))
-            {
+        if (add < 255) matchLength += add; 
+        else 
+        { 
+            if (dumps<=(de-3)) 
+            { 
                 matchLength = ZSTD_readLE24(dumps);
-                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 */
+                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};   /* subtracted */
-    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 */
+    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 ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */
     if (litEnd > litLimit) return ERROR(corruption_detected);
     if (sequence.matchLength > (size_t)(*litPtr-op))  return ERROR(dstSize_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 */
+ 
+    /* 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 ERROR(dstSize_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 */
+ 
+    /* 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 ERROR(corruption_detected);
         if (sequence.offset > (size_t)base) return ERROR(corruption_detected);
-
-        /* 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;
-
+ 
+        /* 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-(16-MINMATCH))
-        {
-            if (op < oend-8)
-            {
-                ZSTD_wildcopy(op, match, (oend-8) - op);
-                match += (oend-8) - op;
-                op = oend-8;
-            }
-            while (op<endMatch) *op++ = *match++;
-        }
-        else
+        { 
+            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, (ptrdiff_t)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 */
+ 
+        /* 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 = ZSTDv01_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,
-                                      DTableLL, DTableML, DTableOffb,
-                                      ip, iend-ip);
+                                      DTableLL, DTableML, DTableOffb, 
+                                      ip, iend-ip); 
     if (ZSTDv01_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);
+    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 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 ( ; (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);
+        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 (ZSTDv01_isError(oneSeqSize)) return oneSeqSize;
-            op += oneSeqSize;
-        }
-
-        /* check if reached exact end */
+            op += oneSeqSize; 
+        } 
+ 
+        /* check if reached exact end */ 
         if ( !FSE_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;
+ 
+        /* last literal segment */ 
+        { 
+            size_t lastLLSize = litEnd - litPtr; 
             if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);
             if (lastLLSize > 0) {
                 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 */
+        } 
+    } 
+ 
+    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 = ZSTDv01_decodeLiteralsBlock(ctx, dst, maxDstSize, &litPtr, &litSize, src, srcSize);
     if (ZSTDv01_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 */
+    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 ERROR(srcSize_wrong);
-    magicNumber = ZSTD_readBE32(src);
+    magicNumber = ZSTD_readBE32(src); 
     if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);
-    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize;
-
-    /* Loop on each block */
-    while (1)
-    {
+    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize; 
+ 
+    /* Loop on each block */ 
+    while (1) 
+    { 
         size_t blockSize = ZSTDv01_getcBlockSize(ip, iend-ip, &blockProperties);
         if (ZSTDv01_isError(blockSize)) return blockSize;
-
-        ip += ZSTD_blockHeaderSize;
-        remainingSize -= ZSTD_blockHeaderSize;
+ 
+        ip += ZSTD_blockHeaderSize; 
+        remainingSize -= ZSTD_blockHeaderSize; 
         if (blockSize > remainingSize) return ERROR(srcSize_wrong);
-
-        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 :
+ 
+        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 ERROR(GENERIC);   /* not yet supported */
-            break;
-        case bt_end :
-            /* end of frame */
+            break; 
+        case bt_end : 
+            /* end of frame */ 
             if (remainingSize) return ERROR(srcSize_wrong);
-            break;
-        default:
+            break; 
+        default: 
             return ERROR(GENERIC);
-        }
-        if (blockSize == 0) break;   /* bt_end */
-
+        } 
+        if (blockSize == 0) break;   /* bt_end */ 
+ 
         if (ZSTDv01_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);
-}
-
+        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); 
+} 
+ 
 /* ZSTD_errorFrameSizeInfoLegacy() :
    assumes `cSize` and `dBound` are _not_ NULL */
 static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)
@@ -2016,7 +2016,7 @@ void ZSTDv01_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cS
     size_t nbBlocks = 0;
     U32 magicNumber;
     blockProperties_t blockProperties;
-
+ 
     /* Frame Header */
     if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) {
         ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
@@ -2056,103 +2056,103 @@ void ZSTDv01_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cS
     *dBound = nbBlocks * BLOCKSIZE;
 }
 
-/*******************************
-*  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 */
+/******************************* 
+*  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 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 = ZSTD_readBE32(src);
+    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 ERROR(prefix_unknown);
-        ctx->phase = 1;
-        ctx->expected = ZSTD_blockHeaderSize;
-        return 0;
-    }
-
-    /* Decompress : block header */
-    if (ctx->phase == 1)
-    {
-        blockProperties_t bp;
+        ctx->phase = 1; 
+        ctx->expected = ZSTD_blockHeaderSize; 
+        return 0; 
+    } 
+ 
+    /* Decompress : block header */ 
+    if (ctx->phase == 1) 
+    { 
+        blockProperties_t bp; 
         size_t blockSize = ZSTDv01_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);
         if (ZSTDv01_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 :
+        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:
+            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;
-    }
-
-}
+        } 
+        ctx->phase = 1; 
+        ctx->expected = ZSTD_blockHeaderSize; 
+        ctx->previousDstEnd = (void*)( ((char*)dst) + rSize); 
+        return rSize; 
+    } 
+ 
+} 
diff --git a/contrib/libs/zstd/lib/legacy/zstd_v01.h b/contrib/libs/zstd/lib/legacy/zstd_v01.h
index f777eb6e4c..6108b439a5 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_v01.h
+++ b/contrib/libs/zstd/lib/legacy/zstd_v01.h
@@ -7,34 +7,34 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
+ 
 #ifndef ZSTD_V01_H_28739879432
 #define ZSTD_V01_H_28739879432
-
-#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);
-
+ 
+#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_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.1.x format
      srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
@@ -49,46 +49,46 @@ void ZSTDv01_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
                                      size_t* cSize, unsigned long long* dBound);
 
 /**
-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
+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 
 
 #endif /* ZSTD_V01_H_28739879432 */
diff --git a/contrib/libs/zstd/lib/legacy/zstd_v02.c b/contrib/libs/zstd/lib/legacy/zstd_v02.c
index 2f473a7573..e7c93858e7 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_v02.c
+++ b/contrib/libs/zstd/lib/legacy/zstd_v02.c
@@ -7,2890 +7,2890 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-
-#include <stddef.h>    /* size_t, ptrdiff_t */
-#include "zstd_v02.h"
+ 
+ 
+#include <stddef.h>    /* size_t, ptrdiff_t */ 
+#include "zstd_v02.h" 
 #include "../common/error_private.h"
+ 
 
-
-/******************************************
-*  Compiler-specific
-******************************************/
+/****************************************** 
+*  Compiler-specific 
+******************************************/ 
 #if defined(_MSC_VER)   /* Visual Studio */
 #   include <stdlib.h>  /* _byteswap_ulong */
 #   include <intrin.h>  /* _byteswap_* */
-#endif
-
-
-/* ******************************************************************
-   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 */)
+#endif 
+ 
+ 
+/* ****************************************************************** 
+   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 */) 
 # if defined(_AIX)
 #  include <inttypes.h>
 # else
 #  include <stdint.h> /* intptr_t */
 # endif
-  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 */
+  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(__INTEL_COMPILER) || defined(__GNUC__) || defined(__ICCARM__)
-#    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; }
-
-#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; }
-
-#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));
-}
-
+#    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; } 
+ 
+#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; } 
+ 
+#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)); 
+} 
+ 
 #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 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);
 }
 
-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 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 size_t MEM_readLEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readLE32(memPtr);
-    else
-        return (size_t)MEM_readLE64(memPtr);
-}
-
-#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);
-
-
-/******************************************
-*  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 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 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 size_t MEM_readLEST(const void* memPtr) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_readLE32(memPtr); 
+    else 
+        return (size_t)MEM_readLE64(memPtr); 
+} 
+ 
+#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); 
+ 
+ 
+/****************************************** 
+*  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 (U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
     unsigned long r;
     return _BitScanReverse(&r, val) ? (unsigned)r : 0;
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */ 
     return __builtin_clz (val) ^ 31;
-#   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);
+#   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); 
                     /* fallthrough */
-            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24); 
                     /* fallthrough */
-            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32); 
                     /* fallthrough */
-            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; 
                     /* fallthrough */
-            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; 
                     /* fallthrough */
-            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8;
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8; 
                     /* fallthrough */
-            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;
-}
-
-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;
-}
-
-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)
-{
+            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; 
+} 
+ 
+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; 
+} 
+ 
+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);
-
-
-/******************************************
-*  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
+ 
+    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); 
+ 
+ 
+/****************************************** 
+*  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 
 #  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
 #    ifdef __GNUC__
 #      define FORCE_INLINE static inline __attribute__((always_inline))
 #    else
 #      define FORCE_INLINE static inline
 #    endif
-#  else
+#  else 
 #    define FORCE_INLINE static
 #  endif /* __STDC_VERSION__ */
-#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 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)
-{
-    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));
+#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 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) 
+{ 
+    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 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#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;
+                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 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#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;
-    size_t oSize;
-    U32 n;
-
+    size_t oSize; 
+    U32 n; 
+ 
     if (!srcSize) return ERROR(srcSize_wrong);
     iSize = ip[0];
-    //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;
-    }
+    //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; 
+    } 
     if (weightTotal == 0) return ERROR(corruption_detected);
-
-    /* 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) */
-    }
-
+ 
+    /* 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) */
-    }
-
+    { 
+        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 */
-#  include <intrin.h>                    /* For Visual 2005 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
-#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 */
-
+    { 
+        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 */ 
+#  include <intrin.h>                    /* For Visual 2005 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */ 
+#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 */ 
+ 
 #define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
 
-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 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, ptrdiff_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); }
-
-
-
-/* *************************************************************
-*   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 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);
+{ 
+    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); } 
+ 
+ 
+ 
+/* ************************************************************* 
+*   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 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); 
     if (srcSize > 0) {
         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->litSize = litSize;
+    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->litSize = litSize; 
             memset(dctx->litBuffer + dctx->litSize, 0, 8);
-            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 */
-            {
+            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 > BLOCKSIZE) return ERROR(corruption_detected);
                 if (litSize > srcSize-3) return ERROR(corruption_detected);
                 memcpy(dctx->litBuffer, istart, litSize);
@@ -2900,76 +2900,76 @@ static size_t ZSTD_decodeLiteralsBlock(void* ctx,
                 return litSize+3;
             }
             /* direct reference into compressed stream */
-            dctx->litPtr = istart+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);
+            dctx->litPtr = istart+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 + 8);
-            dctx->litPtr = dctx->litBuffer;
-            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)
-        {
-        case bt_rle :
-            LLlog = 0;
-            FSE_buildDTable_rle(DTableLL, *ip++); break;
-        case bt_raw :
-            LLlog = LLbits;
-            FSE_buildDTable_raw(DTableLL, LLbits); break;
-        default :
+            dctx->litPtr = dctx->litBuffer; 
+            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) 
+        { 
+        case bt_rle : 
+            LLlog = 0; 
+            FSE_buildDTable_rle(DTableLL, *ip++); break; 
+        case bt_raw : 
+            LLlog = LLbits; 
+            FSE_buildDTable_raw(DTableLL, LLbits); break; 
+        default : 
             {   U32 max = MaxLL;
                 headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);
                 if (FSE_isError(headerSize)) return ERROR(GENERIC);
@@ -2977,18 +2977,18 @@ static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* d
                 ip += headerSize;
                 FSE_buildDTable(DTableLL, norm, max, LLlog);
         }   }
-
-        switch(Offtype)
-        {
-        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 :
+ 
+        switch(Offtype) 
+        { 
+        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 : 
             {   U32 max = MaxOff;
                 headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);
                 if (FSE_isError(headerSize)) return ERROR(GENERIC);
@@ -2996,17 +2996,17 @@ static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* d
                 ip += headerSize;
                 FSE_buildDTable(DTableOffb, norm, max, Offlog);
         }   }
-
-        switch(MLtype)
-        {
-        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 :
+ 
+        switch(MLtype) 
+        { 
+        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 : 
             {   U32 max = MaxML;
                 headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);
                 if (FSE_isError(headerSize)) return ERROR(GENERIC);
@@ -3014,316 +3014,316 @@ static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* d
                 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)
-    {
+ 
+    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) 
+    { 
         const U32 add = dumps<de ? *dumps++ : 0;
-        if (add < 255) litLength += add;
+        if (add < 255) litLength += add; 
         else if (dumps + 3 <= de)
-        {
+        { 
             litLength = MEM_readLE24(dumps);
-            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)
-    {
+            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) 
+    { 
         const U32 add = dumps<de ? *dumps++ : 0;
-        if (add < 255) matchLength += add;
+        if (add < 255) matchLength += add; 
         else if (dumps + 3 <= de)
-        {
+        { 
             matchLength = MEM_readLE24(dumps);
-            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 */
+            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};   /* subtracted */
-    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 */
+    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) 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;
-
+ 
+    /* 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-(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
-        {
+        { 
+            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, (ptrdiff_t)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 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);
+        } 
+    } 
+ 
+    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 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, litEnd, 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 (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 (lastLLSize > 0) {
                 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);
-}
-
+        } 
+    } 
+ 
+    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); 
+} 
+ 
 /* ZSTD_errorFrameSizeInfoLegacy() :
    assumes `cSize` and `dBound` are _not_ NULL */
 static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)
@@ -3331,7 +3331,7 @@ static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBo
     *cSize = ret;
     *dBound = ZSTD_CONTENTSIZE_ERROR;
 }
-
+ 
 void ZSTDv02_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound)
 {
     const BYTE* ip = (const BYTE*)src;
@@ -3379,140 +3379,140 @@ void ZSTDv02_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cS
     *dBound = nbBlocks * BLOCKSIZE;
 }
 
-/*******************************
-*  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)
-{
+/******************************* 
+*  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)
-{
+} 
+ 
+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)
-{
+} 
+ 
+ZSTDv02_Dctx* ZSTDv02_createDCtx(void) 
+{ 
     return (ZSTDv02_Dctx*)ZSTD_createDCtx();
-}
-
-size_t ZSTDv02_freeDCtx(ZSTDv02_Dctx* dctx)
-{
+} 
+ 
+size_t ZSTDv02_freeDCtx(ZSTDv02_Dctx* dctx) 
+{ 
     return ZSTD_freeDCtx((ZSTD_DCtx*)dctx);
-}
-
-size_t ZSTDv02_resetDCtx(ZSTDv02_Dctx* dctx)
-{
+} 
+ 
+size_t ZSTDv02_resetDCtx(ZSTDv02_Dctx* dctx) 
+{ 
     return ZSTD_resetDCtx((ZSTD_DCtx*)dctx);
-}
-
-size_t ZSTDv02_nextSrcSizeToDecompress(ZSTDv02_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)
-{
+} 
+ 
+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/zstd/lib/legacy/zstd_v02.h b/contrib/libs/zstd/lib/legacy/zstd_v02.h
index 1b371953b7..d52d1d8b01 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_v02.h
+++ b/contrib/libs/zstd/lib/legacy/zstd_v02.h
@@ -7,34 +7,34 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
+ 
 #ifndef ZSTD_V02_H_4174539423
 #define ZSTD_V02_H_4174539423
-
-#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);
-
+ 
+#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_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.2.x format
      srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
@@ -49,45 +49,45 @@ void ZSTDv02_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
                                      size_t* cSize, unsigned long long* dBound);
 
 /**
-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
+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 
 
 #endif /* ZSTD_V02_H_4174539423 */
diff --git a/contrib/libs/zstd/lib/legacy/zstd_v03.c b/contrib/libs/zstd/lib/legacy/zstd_v03.c
index 6625f4df1c..a7a7584939 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_v03.c
+++ b/contrib/libs/zstd/lib/legacy/zstd_v03.c
@@ -7,2531 +7,2531 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-
-#include <stddef.h>    /* size_t, ptrdiff_t */
-#include "zstd_v03.h"
+ 
+ 
+#include <stddef.h>    /* size_t, ptrdiff_t */ 
+#include "zstd_v03.h" 
 #include "../common/error_private.h"
+ 
 
-
-/******************************************
-*  Compiler-specific
-******************************************/
+/****************************************** 
+*  Compiler-specific 
+******************************************/ 
 #if defined(_MSC_VER)   /* Visual Studio */
 #   include <stdlib.h>  /* _byteswap_ulong */
 #   include <intrin.h>  /* _byteswap_* */
-#endif
-
-
-
-/* ******************************************************************
-   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 */)
+#endif 
+ 
+ 
+ 
+/* ****************************************************************** 
+   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 */) 
 # if defined(_AIX)
 #  include <inttypes.h>
 # else
 #  include <stdint.h> /* intptr_t */
 # endif
-  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 */
+  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(__INTEL_COMPILER) || defined(__GNUC__) || defined(__ICCARM__)
-#    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; }
-
-#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; }
-
-#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));
-}
-
-
+#    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; } 
+ 
+#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; } 
+ 
+#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)); 
+} 
+ 
+ 
 #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 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);
 }
 
-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 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 size_t MEM_readLEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readLE32(memPtr);
-    else
-        return (size_t)MEM_readLE64(memPtr);
-}
-
-
-#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);
-
-
-
-/******************************************
-*  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 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 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 size_t MEM_readLEST(const void* memPtr) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_readLE32(memPtr); 
+    else 
+        return (size_t)MEM_readLE64(memPtr); 
+} 
+ 
+ 
+#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); 
+ 
+ 
+ 
+/****************************************** 
+*  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 (U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
     unsigned long r;
     return _BitScanReverse(&r, val) ? (unsigned)r : 0;
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */ 
     return __builtin_clz (val) ^ 31;
-#   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);
+#   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); 
                     /* fallthrough */
-            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);
+            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24); 
                     /* fallthrough */
-            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);
+            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32); 
                     /* fallthrough */
-            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;
+            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24; 
                     /* fallthrough */
-            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;
+            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; 
                     /* fallthrough */
-            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8;
+            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8; 
                     /* fallthrough */
-            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;
-}
-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;
-}
-
-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)
-{
+            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; 
+} 
+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; 
+} 
+ 
+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);
-
-
-/******************************************
-*  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
+ 
+    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); 
+ 
+ 
+/****************************************** 
+*  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 
 #  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
 #    ifdef __GNUC__
 #      define FORCE_INLINE static inline __attribute__((always_inline))
 #    else
 #      define FORCE_INLINE static inline
 #    endif
-#  else
+#  else 
 #    define FORCE_INLINE static
 #  endif /* __STDC_VERSION__ */
-#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 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));
+#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 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)
+                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) 
 #  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  define inline __inline
-#else
-#  define inline /* disable inline */
-#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;
+#  define inline __inline 
+#else 
+#  define inline /* disable inline */ 
+#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;
-    size_t oSize;
-    U32 n;
-
+    size_t oSize; 
+    U32 n; 
+ 
     if (!srcSize) return ERROR(srcSize_wrong);
     iSize = ip[0];
-    //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;
-    }
+    //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; 
+    } 
     if (weightTotal == 0) return ERROR(corruption_detected);
-
-    /* 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) */
-    }
-
+ 
+    /* 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 */
-#  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__)
-#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 */
-
+    { 
+        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 */ 
+#  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__) 
+#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 */ 
+ 
 #define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
 
-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 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, ptrdiff_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); }
-
-
-
-/* *************************************************************
-*   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 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);
+{ 
+    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); } 
+ 
+ 
+ 
+/* ************************************************************* 
+*   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 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); 
     if (srcSize > 0) {
         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->litSize = litSize;
+    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->litSize = litSize; 
             memset(dctx->litBuffer + dctx->litSize, 0, 8);
-            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 */
-            {
+            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 > BLOCKSIZE) return ERROR(corruption_detected);
                 if (litSize > srcSize-3) return ERROR(corruption_detected);
                 memcpy(dctx->litBuffer, istart, litSize);
@@ -2541,76 +2541,76 @@ static size_t ZSTD_decodeLiteralsBlock(void* ctx,
                 return litSize+3;
             }
             /* direct reference into compressed stream */
-            dctx->litPtr = istart+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);
+            dctx->litPtr = istart+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 + 8);
-            dctx->litPtr = dctx->litBuffer;
-            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)
-        {
-        case bt_rle :
-            LLlog = 0;
-            FSE_buildDTable_rle(DTableLL, *ip++); break;
-        case bt_raw :
-            LLlog = LLbits;
-            FSE_buildDTable_raw(DTableLL, LLbits); break;
-        default :
+            dctx->litPtr = dctx->litBuffer; 
+            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) 
+        { 
+        case bt_rle : 
+            LLlog = 0; 
+            FSE_buildDTable_rle(DTableLL, *ip++); break; 
+        case bt_raw : 
+            LLlog = LLbits; 
+            FSE_buildDTable_raw(DTableLL, LLbits); break; 
+        default : 
             {   U32 max = MaxLL;
                 headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);
                 if (FSE_isError(headerSize)) return ERROR(GENERIC);
@@ -2618,18 +2618,18 @@ static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* d
                 ip += headerSize;
                 FSE_buildDTable(DTableLL, norm, max, LLlog);
         }   }
-
-        switch(Offtype)
-        {
-        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 :
+ 
+        switch(Offtype) 
+        { 
+        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 : 
             {   U32 max = MaxOff;
                 headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);
                 if (FSE_isError(headerSize)) return ERROR(GENERIC);
@@ -2637,17 +2637,17 @@ static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* d
                 ip += headerSize;
                 FSE_buildDTable(DTableOffb, norm, max, Offlog);
         }   }
-
-        switch(MLtype)
-        {
-        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 :
+ 
+        switch(MLtype) 
+        { 
+        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 : 
             {   U32 max = MaxML;
                 headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);
                 if (FSE_isError(headerSize)) return ERROR(GENERIC);
@@ -2655,316 +2655,316 @@ static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* d
                 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)
-    {
+ 
+    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) 
+    { 
         const U32 add = dumps<de ? *dumps++ : 0;
-        if (add < 255) litLength += add;
+        if (add < 255) litLength += add; 
         else if (dumps + 3 <= de)
-        {
+        { 
             litLength = MEM_readLE24(dumps);
-            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)
-    {
+            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) 
+    { 
         const U32 add = dumps<de ? *dumps++ : 0;
-        if (add < 255) matchLength += add;
+        if (add < 255) matchLength += add; 
         else if (dumps + 3 <= de)
-        {
+        { 
             matchLength = MEM_readLE24(dumps);
-            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 */
+            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};   /* subtracted */
-    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 */
+    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) 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;
-
+ 
+    /* 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-(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
-        {
+        { 
+            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, (ptrdiff_t)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 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);
+        } 
+    } 
+ 
+    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 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, litEnd, 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 (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 (lastLLSize > 0) {
                 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);
-}
-
+        } 
+    } 
+ 
+    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); 
+} 
+ 
 /* ZSTD_errorFrameSizeInfoLegacy() :
    assumes `cSize` and `dBound` are _not_ NULL */
 MEM_STATIC void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)
@@ -2980,7 +2980,7 @@ void ZSTDv03_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cS
     size_t nbBlocks = 0;
     U32 magicNumber;
     blockProperties_t blockProperties;
-
+ 
     /* Frame Header */
     if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) {
         ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
@@ -3021,140 +3021,140 @@ void ZSTDv03_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cS
 }
 
 
-/*******************************
-*  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)
-{
+/******************************* 
+*  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)
-{
+} 
+ 
+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)
-{
+} 
+ 
+ZSTDv03_Dctx* ZSTDv03_createDCtx(void) 
+{ 
     return (ZSTDv03_Dctx*)ZSTD_createDCtx();
-}
-
-size_t ZSTDv03_freeDCtx(ZSTDv03_Dctx* dctx)
-{
+} 
+ 
+size_t ZSTDv03_freeDCtx(ZSTDv03_Dctx* dctx) 
+{ 
     return ZSTD_freeDCtx((ZSTD_DCtx*)dctx);
-}
-
-size_t ZSTDv03_resetDCtx(ZSTDv03_Dctx* dctx)
-{
+} 
+ 
+size_t ZSTDv03_resetDCtx(ZSTDv03_Dctx* dctx) 
+{ 
     return ZSTD_resetDCtx((ZSTD_DCtx*)dctx);
-}
-
-size_t ZSTDv03_nextSrcSizeToDecompress(ZSTDv03_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)
-{
+} 
+ 
+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/zstd/lib/legacy/zstd_v03.h b/contrib/libs/zstd/lib/legacy/zstd_v03.h
index 7a00d4304b..ffe72f0db2 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_v03.h
+++ b/contrib/libs/zstd/lib/legacy/zstd_v03.h
@@ -7,34 +7,34 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
+ 
 #ifndef ZSTD_V03_H_298734209782
 #define ZSTD_V03_H_298734209782
-
-#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);
-
+ 
+#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_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.3.x format
      srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
@@ -49,45 +49,45 @@ size_t ZSTDv03_decompress( void* dst, size_t maxOriginalSize,
                                       size_t* cSize, unsigned long long* dBound);
 
     /**
-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
+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 
 
 #endif /* ZSTD_V03_H_298734209782 */
diff --git a/contrib/libs/zstd/lib/legacy/zstd_v04.c b/contrib/libs/zstd/lib/legacy/zstd_v04.c
index 8d305c7eae..8b6a2a471b 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_v04.c
+++ b/contrib/libs/zstd/lib/legacy/zstd_v04.c
@@ -7,74 +7,74 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-
+ 
+ 
  /******************************************
  *  Includes
  ******************************************/
 #include <stddef.h>    /* size_t, ptrdiff_t */
 #include <string.h>    /* memcpy */
 
-#include "zstd_v04.h"
+#include "zstd_v04.h" 
 #include "../common/error_private.h"
-
-
-/* ******************************************************************
+ 
+ 
+/* ****************************************************************** 
  *   mem.h
  *******************************************************************/
-#ifndef MEM_H_MODULE
-#define MEM_H_MODULE
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/******************************************
-*  Compiler-specific
-******************************************/
+#ifndef MEM_H_MODULE 
+#define MEM_H_MODULE 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/****************************************** 
+*  Compiler-specific 
+******************************************/ 
 #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
-
-
-/****************************************************************
-*  Basic Types
-*****************************************************************/
-#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#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 */) 
 # if defined(_AIX)
 #  include <inttypes.h>
 # else
 #  include <stdint.h> /* intptr_t */
 # endif
-  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
-
-
+  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 
+ 
+ 
 /*-*************************************
 *  Debug
 ***************************************/
@@ -84,598 +84,598 @@ extern "C" {
 #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 */
+/**************************************************************** 
+*  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(__INTEL_COMPILER) || defined(__GNUC__) || defined(__ICCARM__)
-#    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; }
-
-#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; }
-
-#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));
-}
-
+#    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; } 
+ 
+#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; } 
+ 
+#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)); 
+} 
+ 
 #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 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);
 }
 
-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 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 size_t MEM_readLEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readLE32(memPtr);
-    else
-        return (size_t)MEM_readLE64(memPtr);
-}
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* MEM_H_MODULE */
-
-/*
-    zstd - standard compression library
-    Header File for static linking only
-*/
-#ifndef ZSTD_STATIC_H
-#define ZSTD_STATIC_H
-
-
-/* *************************************
-*  Types
-***************************************/
-#define ZSTD_WINDOWLOG_ABSOLUTEMIN 11
-
-/** 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.
-*/
-
-
-
-
-#endif  /* ZSTD_STATIC_H */
-
-
-/*
-    zstd_internal - common functions to include
-    Header File for include
-*/
-#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 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)
-
+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 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 size_t MEM_readLEST(const void* memPtr) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_readLE32(memPtr); 
+    else 
+        return (size_t)MEM_readLE64(memPtr); 
+} 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* MEM_H_MODULE */ 
+ 
+/* 
+    zstd - standard compression library 
+    Header File for static linking only 
+*/ 
+#ifndef ZSTD_STATIC_H 
+#define ZSTD_STATIC_H 
+ 
+ 
+/* ************************************* 
+*  Types 
+***************************************/ 
+#define ZSTD_WINDOWLOG_ABSOLUTEMIN 11 
+ 
+/** 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. 
+*/ 
+ 
+ 
+ 
+ 
+#endif  /* ZSTD_STATIC_H */ 
+ 
+ 
+/* 
+    zstd_internal - common functions to include 
+    Header File for include 
+*/ 
+#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 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) 
+ 
 #define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
 
-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 */
+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, ptrdiff_t length)
-{
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + length;
-    do
-        COPY8(op, ip)
-    while (op < oend);
-}
-
-
-
-/* ******************************************************************
-   FSE : Finite State Entropy coder
-   header file
-****************************************************************** */
-#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);
-
-
-
-
-/******************************************
-*  unsafe API
-******************************************/
-MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
-/* faster, but works only if nbBits >= 1 */
-
-
-
-/****************************************************************
-*  Helper functions
-****************************************************************/
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + length; 
+    do 
+        COPY8(op, ip) 
+    while (op < oend); 
+} 
+ 
+ 
+ 
+/* ****************************************************************** 
+   FSE : Finite State Entropy coder 
+   header file 
+****************************************************************** */ 
+#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); 
+ 
+ 
+ 
+ 
+/****************************************** 
+*  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 (U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
     unsigned long r;
     return _BitScanReverse(&r, val) ? (unsigned)r : 0;
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */ 
     return __builtin_clz (val) ^ 31;
-#   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)
-        {
+#   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);/* fall-through */
             case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);/* fall-through */
             case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);/* fall-through */
@@ -683,2060 +683,2060 @@ MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, si
             case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; /* fall-through */
             case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8; /* fall-through */
             default: break;
-        }
-        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;
-}
-
-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;
-}
-
-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)
-{
+        } 
+        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; 
+} 
+ 
+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; 
+} 
+ 
+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);
-
-
-/* *****************************************
-*  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
+ 
+    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); 
+ 
+ 
+/* ***************************************** 
+*  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 
 #  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
 #    ifdef __GNUC__
 #      define FORCE_INLINE static inline __attribute__((always_inline))
 #    else
 #      define FORCE_INLINE static inline
 #    endif
-#  else
+#  else 
 #    define FORCE_INLINE static
 #  endif /* __STDC_VERSION__ */
-#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 */
+#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 */ 
     memset(tableDecode, 0, sizeof(FSE_DECODE_TYPE) * (maxSymbolValue+1) );   /* useless init, but keep static analyzer happy, and we don't need to performance optimize legacy decoders */
-    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));
+    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 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#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;
+                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 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#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;
-    size_t oSize;
-    U32 n;
-
+    size_t oSize; 
+    U32 n; 
+ 
     if (!srcSize) return ERROR(srcSize_wrong);
     iSize = ip[0];
-    //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;
-    }
+    //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; 
+    } 
     if (weightTotal == 0) return ERROR(corruption_detected);
-
-    /* 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 */
-#  include <intrin.h>                    /* For Visual 2005 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
-#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 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);
+ 
+    /* 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 */ 
+#  include <intrin.h>                    /* For Visual 2005 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */ 
+#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 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_unsupported);
-    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);
+    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); 
     if (srcSize > 0) {
         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->litSize = litSize;
+    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->litSize = litSize; 
             memset(dctx->litBuffer + dctx->litSize, 0, 8);
-            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 */
-            {
+            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 > BLOCKSIZE) return ERROR(corruption_detected);
-                if (litSize > srcSize-3) return ERROR(corruption_detected);
-                memcpy(dctx->litBuffer, istart, litSize);
-                dctx->litPtr = dctx->litBuffer;
-                dctx->litSize = litSize;
+                if (litSize > srcSize-3) return ERROR(corruption_detected); 
+                memcpy(dctx->litBuffer, istart, litSize); 
+                dctx->litPtr = dctx->litBuffer; 
+                dctx->litSize = litSize; 
                 memset(dctx->litBuffer + dctx->litSize, 0, 8);
-                return litSize+3;
-            }
-            /* direct reference into compressed stream */
-            dctx->litPtr = istart+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);
+                return litSize+3; 
+            } 
+            /* direct reference into compressed stream */ 
+            dctx->litPtr = istart+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 + 8);
-            dctx->litPtr = dctx->litBuffer;
-            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)
-        {
-        case bt_rle :
-            LLlog = 0;
-            FSE_buildDTable_rle(DTableLL, *ip++); break;
-        case bt_raw :
-            LLlog = LLbits;
-            FSE_buildDTable_raw(DTableLL, LLbits); break;
-        default :
+            dctx->litPtr = dctx->litBuffer; 
+            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) 
+        { 
+        case bt_rle : 
+            LLlog = 0; 
+            FSE_buildDTable_rle(DTableLL, *ip++); break; 
+        case bt_raw : 
+            LLlog = LLbits; 
+            FSE_buildDTable_raw(DTableLL, LLbits); break; 
+        default : 
             {   U32 max = MaxLL;
                 headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);
                 if (FSE_isError(headerSize)) return ERROR(GENERIC);
@@ -2744,18 +2744,18 @@ static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* d
                 ip += headerSize;
                 FSE_buildDTable(DTableLL, norm, max, LLlog);
         }   }
-
-        switch(Offtype)
-        {
-        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 :
+ 
+        switch(Offtype) 
+        { 
+        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 : 
             {   U32 max = MaxOff;
                 headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);
                 if (FSE_isError(headerSize)) return ERROR(GENERIC);
@@ -2763,17 +2763,17 @@ static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* d
                 ip += headerSize;
                 FSE_buildDTable(DTableOffb, norm, max, Offlog);
         }   }
-
-        switch(MLtype)
-        {
-        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 :
+ 
+        switch(MLtype) 
+        { 
+        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 : 
             {   U32 max = MaxML;
                 headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);
                 if (FSE_isError(headerSize)) return ERROR(GENERIC);
@@ -2781,357 +2781,357 @@ static size_t ZSTD_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* d
                 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;
+ 
+    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) {
         const U32 add = dumps<de ? *dumps++ : 0;
-        if (add < 255) litLength += add;
+        if (add < 255) litLength += add; 
         else if (dumps + 3 <= de) {
             litLength = MEM_readLE24(dumps);
-            dumps += 3;
-        }
+            dumps += 3; 
+        } 
         if (dumps >= de) { dumps = de-1; }  /* late correction, to avoid read overflow (data is now corrupted anyway) */
-    }
-
-    /* Offset */
+    } 
+ 
+    /* 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));
+                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) {
         const U32 add = dumps<de ? *dumps++ : 0;
-        if (add < 255) matchLength += add;
+        if (add < 255) matchLength += add; 
         else if (dumps + 3 <= de){
             matchLength = MEM_readLE24(dumps);
-            dumps += 3;
-        }
+            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,
+    } 
+    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,
-                                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 */
+                                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 };   /* subtracted */
-    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 */
+    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) 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;
+ 
+    /* 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; 
             if (op > oend_8 || sequence.matchLength < MINMATCH) {
               while (op < oMatchEnd) *op++ = *match++;
               return sequenceLength;
             }
-        }
-    }
+        } 
+    } 
     /* Requirement: op <= oend_8 */
-
-    /* match within prefix */
+ 
+    /* 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;
+        /* 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;
-
+        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
-    {
+    { 
+        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, (ptrdiff_t)sequence.matchLength-8);   /* works even if matchLength < 8, but must be signed */
-    }
-    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 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);
+    } 
+    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 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, litEnd, 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 (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 (lastLLSize > 0) {
                 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;
+        } 
+    } 
+ 
+    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; 
     size_t litCSize;
-
+ 
     if (srcSize > BLOCKSIZE) return ERROR(corruption_detected);
 
-    /* Decode literals sub-block */
+    /* Decode literals sub-block */ 
     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;
-}
-
+    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; 
+} 
+ 
 /* ZSTD_errorFrameSizeInfoLegacy() :
    assumes `cSize` and `dBound` are _not_ NULL */
 static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)
@@ -3146,7 +3146,7 @@ void ZSTDv04_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cS
     size_t remainingSize = srcSize;
     size_t nbBlocks = 0;
     blockProperties_t blockProperties;
-
+ 
     /* Frame Header */
     if (srcSize < ZSTD_frameHeaderSize_min) {
         ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
@@ -3185,463 +3185,463 @@ void ZSTDv04_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cS
     *dBound = nbBlocks * BLOCKSIZE;
 }
 
-/* ******************************
-*  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);
-        if (ZSTD_isError(ctx->headerSize)) return ctx->headerSize;
-        memcpy(ctx->headerBuffer, src, ZSTD_frameHeaderSize_min);
-        if (ctx->headerSize > ZSTD_frameHeaderSize_min) return ERROR(GENERIC);   /* impossible */
-        ctx->expected = 0;   /* not necessary to copy more */
-        /* fallthrough */
-    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:
-        /* 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 .
+/* ****************************** 
+*  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); 
+        if (ZSTD_isError(ctx->headerSize)) return ctx->headerSize; 
+        memcpy(ctx->headerBuffer, src, ZSTD_frameHeaderSize_min); 
+        if (ctx->headerSize > ZSTD_frameHeaderSize_min) return ERROR(GENERIC);   /* impossible */ 
+        ctx->expected = 0;   /* not necessary to copy more */ 
+        /* fallthrough */ 
+    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: 
+        /* 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);
+*            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); 
     if (length > 0) {
         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;
-
+    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; 
+ 
     DEBUGLOG(5, "ZBUFF_decompressContinue");
-    while (notDone)
-    {
-        switch(zbc->stage)
-        {
-
-        case ZBUFFds_init :
+    while (notDone) 
+    { 
+        switch(zbc->stage) 
+        { 
+ 
+        case ZBUFFds_init : 
             DEBUGLOG(5, "ZBUFF_decompressContinue: stage==ZBUFFds_init => ERROR(init_missing)");
-            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 (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 */
-            {   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;
-            }   }
-            /* intentional fallthrough */
-
-        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;
+            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 (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 */ 
+            {   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; 
+            }   } 
+            /* intentional fallthrough */ 
+ 
+        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; 
 		/* fall-through */
-        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_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; 
+            } 
 	    /* fall-through */
-        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;
+        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; 
                     /* ZBUFFds_flush follows */
-                }
-            }
+                } 
+            } 
 	    /* fall-through */
-        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(); }
+        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)
-{
+ 
+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) 
+{ 
     DEBUGLOG(5, "ZBUFFv04_decompressContinue");
-    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); }
+    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/zstd/lib/legacy/zstd_v04.h b/contrib/libs/zstd/lib/legacy/zstd_v04.h
index 66b97ab8e6..8d86069a3e 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_v04.h
+++ b/contrib/libs/zstd/lib/legacy/zstd_v04.h
@@ -7,34 +7,34 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
+ 
 #ifndef ZSTD_V04_H_91868324769238
 #define ZSTD_V04_H_91868324769238
-
-#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);
-
+ 
+#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_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.4.x format
      srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
@@ -49,94 +49,94 @@ size_t ZSTDv04_decompress( void* dst, size_t maxOriginalSize,
                                       size_t* cSize, unsigned long long* dBound);
 
 /**
-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
+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 
 
 #endif /* ZSTD_V04_H_91868324769238 */
diff --git a/contrib/libs/zstd/lib/legacy/zstd_v05.c b/contrib/libs/zstd/lib/legacy/zstd_v05.c
index 795dfb410c..202b65114a 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_v05.c
+++ b/contrib/libs/zstd/lib/legacy/zstd_v05.c
@@ -7,801 +7,801 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-
-/*- Dependencies -*/
-#include "zstd_v05.h"
+ 
+ 
+/*- Dependencies -*/ 
+#include "zstd_v05.h" 
 #include "../common/error_private.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 */)
+ 
+ 
+/* ****************************************************************** 
+   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 */) 
 # if defined(_AIX)
 #  include <inttypes.h>
 # else
 #  include <stdint.h> /* intptr_t */
 # endif
-  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 */
+  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(__INTEL_COMPILER) || defined(__GNUC__) || defined(__ICCARM__)
-#    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 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 size_t MEM_readLEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readLE32(memPtr);
-    else
-        return (size_t)MEM_readLE64(memPtr);
-}
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* MEM_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);
-
-/*
-  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 */
-
-
-/*
-    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
-
+#    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 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 size_t MEM_readLEST(const void* memPtr) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_readLE32(memPtr); 
+    else 
+        return (size_t)MEM_readLE64(memPtr); 
+} 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* MEM_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); 
+ 
+/* 
+  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 */ 
+ 
+ 
+/* 
+    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 
+ 
 #define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
 
-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) */
+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, ptrdiff_t length)
-{
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + length;
-    do
-        COPY8(op, ip)
-    while (op < oend);
-}
-
-
-/*-*******************************************
-*  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()
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + length; 
+    do 
+        COPY8(op, ip) 
+    while (op < oend); 
+} 
+ 
+ 
+/*-******************************************* 
+*  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():
+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);
-
-
-/*-****************************************
-*  unsafe API
-******************************************/
-MEM_STATIC size_t BITv05_readBitsFast(BITv05_DStream_t* bitD, unsigned nbBits);
-/* faster, but works only if nbBits >= 1 */
-
-
-
-/*-**************************************************************
-*  Helper functions
-****************************************************************/
+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); 
+ 
+ 
+/*-**************************************** 
+*  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 (U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
     unsigned long r;
     return _BitScanReverse(&r, val) ? (unsigned)r : 0;
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */ 
     return __builtin_clz (val) ^ 31;
-#   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)
-        {
+#   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);/* fall-through */
             case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);/* fall-through */
             case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);/* fall-through */
@@ -809,1197 +809,1197 @@ MEM_STATIC size_t BITv05_initDStream(BITv05_DStream_t* bitD, const void* srcBuff
             case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16; /* fall-through */
             case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8; /* fall-through */
             default: break;
-        }
-        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;
-}
-
-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;
-}
-
+        } 
+        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; 
+} 
+ 
+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; 
+} 
+ 
 MEM_STATIC size_t BITv05_readBits(BITv05_DStream_t* bitD, unsigned nbBits)
-{
-    size_t value = BITv05_lookBits(bitD, nbBits);
-    BITv05_skipBits(bitD, nbBits);
-    return value;
-}
-
-/*!BITv05_readBitsFast :
-*  unsafe version; only works only if nbBits >= 1 */
+{ 
+    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, unsigned 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)
-{
+{ 
+    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);
-
-
-
-/* *****************************************
-*  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 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
+ 
+    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); 
+ 
+ 
+ 
+/* ***************************************** 
+*  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 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 
 #  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
 #    ifdef __GNUC__
 #      define FORCE_INLINE static inline __attribute__((always_inline))
 #    else
 #      define FORCE_INLINE static inline
 #    endif
-#  else
+#  else 
 #    define FORCE_INLINE static
 #  endif /* __STDC_VERSION__ */
-#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
-****************************************************************/
+#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 unsigned 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 */
+ 
+ 
+/* ************************************************************** 
+*  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 */ 
     memset(tableDecode, 0, sizeof(FSEv05_FUNCTION_TYPE) * (maxSymbolValue+1) );   /* useless init, but keep static analyzer happy, and we don't need to performance optimize legacy decoders */
-    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 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#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;
+    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 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#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;
-    size_t oSize;
-    U32 n;
-
+    size_t oSize; 
+    U32 n; 
+ 
     if (!srcSize) return ERROR(srcSize_wrong);
     iSize = ip[0];
     /* 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;
-    }
+ 
+    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; 
+    } 
     if (weightTotal == 0) return ERROR(corruption_detected);
-
-    /* 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 */
+ 
+    /* 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;
-    const U32 dtLog = DTable[0];
-    const void* dtPtr = DTable;
-    const HUFv05_DEltX2* const dt = ((const HUFv05_DEltX2*)dtPtr)+1;
-    BITv05_DStream_t bitD;
-
+ 
+    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; 
+    const U32 dtLog = DTable[0]; 
+    const void* dtPtr = DTable; 
+    const HUFv05_DEltX2* const dt = ((const HUFv05_DEltX2*)dtPtr)+1; 
+    BITv05_DStream_t bitD; 
+ 
     if (dstSize <= cSrcSize) return ERROR(dstSize_tooSmall);
     { size_t const 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)
-{
-    /* Check */
-    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
+    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) 
+{ 
+    /* Check */ 
+    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;
@@ -2008,7 +2008,7 @@ size_t HUFv05_decompress4X2_usingDTable(
         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;
@@ -2031,7 +2031,7 @@ size_t HUFv05_decompress4X2_usingDTable(
         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);
@@ -2044,7 +2044,7 @@ size_t HUFv05_decompress4X2_usingDTable(
         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);
+        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);
@@ -2064,1002 +2064,1002 @@ size_t HUFv05_decompress4X2_usingDTable(
             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_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 (unsigned* 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;
-
+{ 
+    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(unsigned));   /* if compilation fails here, assertion is false */
-    if (memLog > HUFv05_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);
+    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,
+ 
+    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 unsigned* 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 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 unsigned* 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);
-    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);
-
+{ 
+    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); 
+    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 */
-#  include <intrin.h>                    /* For Visual 2005 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
-#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_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 litSize;
-    BYTE litBuffer[BLOCKSIZE + WILDCOPY_OVERLENGTH];
-    BYTE headerBuffer[ZSTDv05_frameHeaderSize_max];
-};  /* typedef'd to ZSTDv05_DCtx within "zstd_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 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 */ 
+#  include <intrin.h>                    /* For Visual 2005 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */ 
+#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_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 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); /* Hidden declaration */
-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);
+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_unsupported);
-    return result;
-}
-
-
+    return result; 
+} 
+ 
+ 
 static size_t ZSTDv05_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
-{
+{ 
     const BYTE* const in = (const BYTE*)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)
-{
+    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 (dst==NULL) return ERROR(dstSize_tooSmall);
-    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall);
-    memcpy(dst, src, srcSize);
-    return srcSize;
-}
-
-
-/*! ZSTDv05_decodeLiteralsBlock() :
-    @return : nb of bytes read from src (< srcSize ) */
+    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall); 
+    memcpy(dst, src, srcSize); 
+    return srcSize; 
+} 
+ 
+ 
+/*! ZSTDv05_decodeLiteralsBlock() : 
+    @return : nb of bytes read from src (< srcSize ) */ 
 static 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;
+{ 
+    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; 
             if (srcSize < 5) return ERROR(corruption_detected);   /* srcSize >= MIN_CBLOCK_SIZE == 3; here we need up to 5 for case 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);
+            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 (litCSize + lhSize > srcSize) 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->litSize = litSize;
+ 
+            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->litSize = litSize; 
             memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
-            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];
+            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]; 
             if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
-
-            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->litSize = litSize;
+ 
+            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->litSize = litSize; 
             memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
-            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->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->litSize = litSize; 
                 memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
-                return lhSize+litSize;
-            }
-            /* direct reference into compressed stream */
-            dctx->litPtr = istart+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];
+                return lhSize+litSize; 
+            } 
+            /* direct reference into compressed stream */ 
+            dctx->litPtr = istart+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 > BLOCKSIZE) return ERROR(corruption_detected);
+                break; 
+            } 
+            if (litSize > BLOCKSIZE) return ERROR(corruption_detected); 
             memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litSize = litSize;
-            return lhSize+1;
-        }
-    default:
-        return ERROR(corruption_detected);   /* impossible */
-    }
-}
-
-
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litSize = litSize; 
+            return lhSize+1; 
+        } 
+    default: 
+        return ERROR(corruption_detected);   /* impossible */ 
+    } 
+} 
+ 
+ 
 static size_t ZSTDv05_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,
-                         FSEv05_DTable* DTableLL, FSEv05_DTable* DTableML, FSEv05_DTable* DTableOffb,
+                         FSEv05_DTable* DTableLL, FSEv05_DTable* DTableML, FSEv05_DTable* DTableOffb, 
                          const void* src, size_t srcSize, U32 flagStaticTable)
-{
+{ 
     const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* const iend = istart + srcSize;
-    U32 LLtype, Offtype, MLtype;
+    const BYTE* ip = istart; 
+    const BYTE* const iend = istart + srcSize; 
+    U32 LLtype, Offtype, MLtype; 
     unsigned LLlog, Offlog, MLlog;
-    size_t dumpsLength;
-
-    /* check */
-    if (srcSize < MIN_SEQUENCES_SIZE)
-        return ERROR(srcSize_wrong);
-
-    /* SeqHead */
-    *nbSeq = *ip++;
-    if (*nbSeq==0) return 1;
+    size_t dumpsLength; 
+ 
+    /* check */ 
+    if (srcSize < MIN_SEQUENCES_SIZE) 
+        return ERROR(srcSize_wrong); 
+ 
+    /* SeqHead */ 
+    *nbSeq = *ip++; 
+    if (*nbSeq==0) return 1; 
     if (*nbSeq >= 128) {
         if (ip >= iend) return ERROR(srcSize_wrong);
-        *nbSeq = ((nbSeq[0]-128)<<8) + *ip++;
+        *nbSeq = ((nbSeq[0]-128)<<8) + *ip++; 
     }
-
+ 
     if (ip >= iend) return ERROR(srcSize_wrong);
-    LLtype  = *ip >> 6;
-    Offtype = (*ip >> 4) & 3;
-    MLtype  = (*ip >> 2) & 3;
-    if (*ip & 2) {
+    LLtype  = *ip >> 6; 
+    Offtype = (*ip >> 4) & 3; 
+    MLtype  = (*ip >> 2) & 3; 
+    if (*ip & 2) { 
         if (ip+3 > iend) return ERROR(srcSize_wrong);
-        dumpsLength  = ip[2];
-        dumpsLength += ip[1] << 8;
-        ip += 3;
-    } else {
+        dumpsLength  = ip[2]; 
+        dumpsLength += ip[1] << 8; 
+        ip += 3; 
+    } else { 
         if (ip+2 > iend) return ERROR(srcSize_wrong);
-        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)
-        {
-        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:
+        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) 
+        { 
+        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: 
             if (!flagStaticTable) return ERROR(corruption_detected);
-            break;
-        case FSEv05_ENCODING_DYNAMIC :
-        default :   /* impossible */
+            break; 
+        case FSEv05_ENCODING_DYNAMIC : 
+        default :   /* impossible */ 
             {   unsigned max = MaxLL;
                 headerSize = FSEv05_readNCount(norm, &max, &LLlog, ip, iend-ip);
                 if (FSEv05_isError(headerSize)) return ERROR(GENERIC);
@@ -3067,23 +3067,23 @@ static size_t ZSTDv05_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t
                 ip += headerSize;
                 FSEv05_buildDTable(DTableLL, norm, max, LLlog);
         }   }
-
-        switch(Offtype)
-        {
-        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:
+ 
+        switch(Offtype) 
+        { 
+        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: 
             if (!flagStaticTable) return ERROR(corruption_detected);
-            break;
-        case FSEv05_ENCODING_DYNAMIC :
-        default :   /* impossible */
+            break; 
+        case FSEv05_ENCODING_DYNAMIC : 
+        default :   /* impossible */ 
             {   unsigned max = MaxOff;
                 headerSize = FSEv05_readNCount(norm, &max, &Offlog, ip, iend-ip);
                 if (FSEv05_isError(headerSize)) return ERROR(GENERIC);
@@ -3091,23 +3091,23 @@ static size_t ZSTDv05_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t
                 ip += headerSize;
                 FSEv05_buildDTable(DTableOffb, norm, max, Offlog);
         }   }
-
-        switch(MLtype)
-        {
-        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:
+ 
+        switch(MLtype) 
+        { 
+        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: 
             if (!flagStaticTable) return ERROR(corruption_detected);
-            break;
-        case FSEv05_ENCODING_DYNAMIC :
-        default :   /* impossible */
+            break; 
+        case FSEv05_ENCODING_DYNAMIC : 
+        default :   /* impossible */ 
             {   unsigned max = MaxML;
                 headerSize = FSEv05_readNCount(norm, &max, &MLlog, ip, iend-ip);
                 if (FSEv05_isError(headerSize)) return ERROR(GENERIC);
@@ -3115,44 +3115,44 @@ static size_t ZSTDv05_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t
                 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) {
+ 
+    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) { 
         const U32 add = *dumps++;
-        if (add < 255) litLength += add;
+        if (add < 255) litLength += add; 
         else if (dumps + 2 <= de) {
             litLength = MEM_readLE16(dumps);
             dumps += 2;
@@ -3161,35 +3161,35 @@ static void ZSTDv05_decodeSequence(seq_t* seq, seqState_t* seqState)
                 dumps += 1;
             }
             litLength>>=1;
-        }
+        } 
         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) {
+    } 
+ 
+    /* 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) { 
         const U32 add = dumps<de ? *dumps++ : 0;
-        if (add < 255) matchLength += add;
+        if (add < 255) matchLength += add; 
         else if (dumps + 2 <= de) {
             matchLength = MEM_readLE16(dumps);
             dumps += 2;
@@ -3198,327 +3198,327 @@ static void ZSTDv05_decodeSequence(seq_t* seq, seqState_t* seqState)
                 dumps += 1;
             }
             matchLength >>= 1;
-        }
+        } 
         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,
+    } 
+    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,
-                                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 */
+                                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 };   /* subtracted */
-    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 */
+    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) 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;
+ 
+    /* 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; 
             if (op > oend_8 || sequence.matchLength < MINMATCH) {
               while (op < oMatchEnd) *op++ = *match++;
               return sequenceLength;
             }
-    }   }
+    }   } 
     /* Requirement: op <= oend_8 */
-
-    /* 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;
-
+ 
+    /* 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-(16-MINMATCH)) {
-        if (op < oend_8) {
-            ZSTDv05_wildcopy(op, match, oend_8 - op);
-            match += oend_8 - op;
-            op = oend_8;
-        }
-        while (op < oMatchEnd)
-            *op++ = *match++;
-    } else {
+        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, (ptrdiff_t)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;
+    } 
+    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*)dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + maxDstSize;
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + maxDstSize; 
     size_t errorCode, dumpsLength=0;
-    const BYTE* litPtr = dctx->litPtr;
-    const BYTE* const litEnd = litPtr + dctx->litSize;
+    const BYTE* litPtr = dctx->litPtr; 
+    const BYTE* const litEnd = litPtr + dctx->litSize; 
     int nbSeq=0;
     const BYTE* dumps = NULL;
     unsigned* DTableLL = dctx->LLTable;
     unsigned* DTableML = dctx->MLTable;
     unsigned* 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,
+    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, dctx->flagStaticTables);
-    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);
+    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, litEnd, 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);
+            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); 
         if (lastLLSize > 0) {
             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;
+    } 
+ 
+    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*)dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + maxDstSize;
-    size_t remainingSize = srcSize;
-    blockProperties_t blockProperties;
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + maxDstSize; 
+    size_t remainingSize = srcSize; 
+    blockProperties_t blockProperties; 
     memset(&blockProperties, 0, sizeof(blockProperties));
-
-    /* Frame Header */
+ 
+    /* 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
-}
-
+        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 
+} 
+ 
 /* ZSTD_errorFrameSizeInfoLegacy() :
    assumes `cSize` and `dBound` are _not_ NULL */
 static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)
@@ -3533,7 +3533,7 @@ void ZSTDv05_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cS
     size_t remainingSize = srcSize;
     size_t nbBlocks = 0;
     blockProperties_t blockProperties;
-
+ 
     /* Frame Header */
     if (srcSize < ZSTDv05_frameHeaderSize_min) {
         ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
@@ -3572,479 +3572,479 @@ void ZSTDv05_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cS
     *dBound = nbBlocks * BLOCKSIZE;
 }
 
-/* ******************************
-*  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);
-        if (ZSTDv05_isError(dctx->headerSize)) return dctx->headerSize;
-        memcpy(dctx->headerBuffer, src, ZSTDv05_frameHeaderSize_min);
-        if (dctx->headerSize > ZSTDv05_frameHeaderSize_min) return ERROR(GENERIC); /* should never happen */
-        dctx->expected = 0;   /* not necessary to copy more */
-        /* fallthrough */
-    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];
+/* ****************************** 
+*  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); 
+        if (ZSTDv05_isError(dctx->headerSize)) return dctx->headerSize; 
+        memcpy(dctx->headerBuffer, src, ZSTDv05_frameHeaderSize_min); 
+        if (dctx->headerSize > ZSTDv05_frameHeaderSize_min) return ERROR(GENERIC); /* should never happen */ 
+        dctx->expected = 0;   /* not necessary to copy more */ 
+        /* fallthrough */ 
+    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]; 
     unsigned offcodeMaxValue=MaxOff, offcodeLog;
-    short matchlengthNCount[MaxML+1];
+    short matchlengthNCount[MaxML+1]; 
     unsigned matchlengthMaxValue = MaxML, matchlengthLog;
-    short litlengthNCount[MaxLL+1];
+    short litlengthNCount[MaxLL+1]; 
     unsigned litlengthMaxValue = MaxLL, litlengthLog;
-
-    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);
+ 
+    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); 
     if (offcodeLog > OffFSEv05Log) 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->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); 
     if (matchlengthLog > MLFSEv05Log) 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);
+    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 (litlengthLog > LLFSEv05Log) return ERROR(dictionary_corrupted);
-    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);
+    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); 
     if (length > 0) {
         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 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;
-            }
+*            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; 
+            } 
 	    /* fall-through */
-        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;
-                }
+        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 */
-            }
+            } 
 	    /* fall-through */
-        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_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; 
 		/* fall-through */
-        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_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; 
+            } 
 	    /* fall-through */
-        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;
+        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 */
                 }
 	    }
 	    /* fall-through */
-        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; }
+        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; } 
diff --git a/contrib/libs/zstd/lib/legacy/zstd_v05.h b/contrib/libs/zstd/lib/legacy/zstd_v05.h
index bd423bfc1b..ac0ec3ce06 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_v05.h
+++ b/contrib/libs/zstd/lib/legacy/zstd_v05.h
@@ -7,32 +7,32 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-#ifndef ZSTDv05_H
-#define ZSTDv05_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/*-*************************************
-*  Dependencies
-***************************************/
-#include <stddef.h>   /* size_t */
+ 
+#ifndef ZSTDv05_H 
+#define ZSTDv05_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/*-************************************* 
+*  Dependencies 
+***************************************/ 
+#include <stddef.h>   /* size_t */ 
 #include "../common/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);
-
+ 
+ 
+/* ************************************* 
+*  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); 
+ 
  /**
  ZSTDv05_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.5.x format
      srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
@@ -40,123 +40,123 @@ size_t ZSTDv05_decompress( void* dst, size_t dstCapacity,
                                  or an error code if it fails (which can be tested using ZSTDv01_isError())
      dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame
                                  or ZSTD_CONTENTSIZE_ERROR if an error occurs
-
+ 
     note : assumes `cSize` and `dBound` are _not_ NULL.
  */
 void ZSTDv05_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
                                      size_t* cSize, unsigned long long* dBound);
 
-/* *************************************
-*  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);
-
-
-/*-***********************
-*  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,
-                                            void* dst, size_t dstCapacity,
-                                      const void* src, size_t srcSize,
-                                      const void* dict,size_t dictSize);
-
-/*-************************
-*  Advanced Streaming API
-***************************/
-typedef enum { ZSTDv05_fast, ZSTDv05_greedy, ZSTDv05_lazy, ZSTDv05_lazy2, ZSTDv05_btlazy2, ZSTDv05_opt, ZSTDv05_btopt } ZSTDv05_strategy;
-typedef struct {
-    U64 srcSize;
-    U32 windowLog;     /* the only useful information to retrieve */
-    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);
-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 */
+/* ************************************* 
+*  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); 
+ 
+ 
+/*-*********************** 
+*  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, 
+                                            void* dst, size_t dstCapacity, 
+                                      const void* src, size_t srcSize, 
+                                      const void* dict,size_t dictSize); 
+ 
+/*-************************ 
+*  Advanced Streaming API 
+***************************/ 
+typedef enum { ZSTDv05_fast, ZSTDv05_greedy, ZSTDv05_lazy, ZSTDv05_lazy2, ZSTDv05_btlazy2, ZSTDv05_opt, ZSTDv05_btopt } ZSTDv05_strategy; 
+typedef struct { 
+    U64 srcSize; 
+    U32 windowLog;     /* the only useful information to retrieve */ 
+    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); 
+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 */ 
diff --git a/contrib/libs/zstd/lib/legacy/zstd_v06.c b/contrib/libs/zstd/lib/legacy/zstd_v06.c
index ead213c484..11a18777f5 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_v06.c
+++ b/contrib/libs/zstd/lib/legacy/zstd_v06.c
@@ -7,902 +7,902 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-
-/*- Dependencies -*/
-#include "zstd_v06.h"
-#include <stddef.h>    /* size_t, ptrdiff_t */
-#include <string.h>    /* memcpy */
-#include <stdlib.h>    /* malloc, free, qsort */
+ 
+ 
+/*- Dependencies -*/ 
+#include "zstd_v06.h" 
+#include <stddef.h>    /* size_t, ptrdiff_t */ 
+#include <string.h>    /* memcpy */ 
+#include <stdlib.h>    /* malloc, free, qsort */ 
 #include "../common/error_private.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
-
-
-/*-****************************************
-*  Compiler specifics
-******************************************/
+ 
+ 
+ 
+/* ****************************************************************** 
+   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 
+ 
+ 
+/*-**************************************** 
+*  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
-
-
-/*-**************************************************************
-*  Basic Types
-*****************************************************************/
-#if  !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+#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 (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) ) 
 # if defined(_AIX)
 #  include <inttypes.h>
 # else
 #  include <stdint.h> /* intptr_t */
 # endif
-  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 */
+  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(__INTEL_COMPILER) || defined(__GNUC__) || defined(__ICCARM__)
-#    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 void MEM_write16(void* memPtr, U16 value) { *(U16*)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; }
-
-#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));
-}
-
-
-#endif /* MEM_FORCE_MEMORY_ACCESS */
-
-MEM_STATIC U32 MEM_swap32(U32 in)
-{
-#if defined(_MSC_VER)     /* Visual Studio */
-    return _byteswap_ulong(in);
+#    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 void MEM_write16(void* memPtr, U16 value) { *(U16*)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; } 
+ 
+#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)); 
+} 
+ 
+ 
+#endif /* MEM_FORCE_MEMORY_ACCESS */ 
+ 
+MEM_STATIC U32 MEM_swap32(U32 in) 
+{ 
+#if defined(_MSC_VER)     /* Visual Studio */ 
+    return _byteswap_ulong(in); 
 #elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)
-    return __builtin_bswap32(in);
-#else
-    return  ((in << 24) & 0xff000000 ) |
-            ((in <<  8) & 0x00ff0000 ) |
-            ((in >>  8) & 0x0000ff00 ) |
-            ((in >> 24) & 0x000000ff );
-#endif
-}
-
-MEM_STATIC U64 MEM_swap64(U64 in)
-{
-#if defined(_MSC_VER)     /* Visual Studio */
-    return _byteswap_uint64(in);
+    return __builtin_bswap32(in); 
+#else 
+    return  ((in << 24) & 0xff000000 ) | 
+            ((in <<  8) & 0x00ff0000 ) | 
+            ((in >>  8) & 0x0000ff00 ) | 
+            ((in >> 24) & 0x000000ff ); 
+#endif 
+} 
+ 
+MEM_STATIC U64 MEM_swap64(U64 in) 
+{ 
+#if defined(_MSC_VER)     /* Visual Studio */ 
+    return _byteswap_uint64(in); 
 #elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)
-    return __builtin_bswap64(in);
-#else
-    return  ((in << 56) & 0xff00000000000000ULL) |
-            ((in << 40) & 0x00ff000000000000ULL) |
-            ((in << 24) & 0x0000ff0000000000ULL) |
-            ((in << 8)  & 0x000000ff00000000ULL) |
-            ((in >> 8)  & 0x00000000ff000000ULL) |
-            ((in >> 24) & 0x0000000000ff0000ULL) |
-            ((in >> 40) & 0x000000000000ff00ULL) |
-            ((in >> 56) & 0x00000000000000ffULL);
-#endif
-}
-
-
-/*=== 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 U32 MEM_readLE32(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read32(memPtr);
-    else
-        return MEM_swap32(MEM_read32(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 size_t MEM_readLEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readLE32(memPtr);
-    else
-        return (size_t)MEM_readLE64(memPtr);
-}
-
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* MEM_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 ZSTDv06_STATIC_H
-#define ZSTDv06_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
-
-
-
-/*- Advanced Decompression functions -*/
-
-/*! ZSTDv06_decompress_usingPreparedDCtx() :
-*   Same as ZSTDv06_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 ZSTDv06_decompressBegin_usingDict().
-*   Requires 2 contexts : 1 for reference (preparedDCtx), which will not be modified, and 1 to run the decompression operation (dctx) */
+    return __builtin_bswap64(in); 
+#else 
+    return  ((in << 56) & 0xff00000000000000ULL) | 
+            ((in << 40) & 0x00ff000000000000ULL) | 
+            ((in << 24) & 0x0000ff0000000000ULL) | 
+            ((in << 8)  & 0x000000ff00000000ULL) | 
+            ((in >> 8)  & 0x00000000ff000000ULL) | 
+            ((in >> 24) & 0x0000000000ff0000ULL) | 
+            ((in >> 40) & 0x000000000000ff00ULL) | 
+            ((in >> 56) & 0x00000000000000ffULL); 
+#endif 
+} 
+ 
+ 
+/*=== 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 U32 MEM_readLE32(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read32(memPtr); 
+    else 
+        return MEM_swap32(MEM_read32(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 size_t MEM_readLEST(const void* memPtr) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_readLE32(memPtr); 
+    else 
+        return (size_t)MEM_readLE64(memPtr); 
+} 
+ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* MEM_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 ZSTDv06_STATIC_H 
+#define ZSTDv06_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 
+ 
+ 
+ 
+/*- Advanced Decompression functions -*/ 
+ 
+/*! ZSTDv06_decompress_usingPreparedDCtx() : 
+*   Same as ZSTDv06_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 ZSTDv06_decompressBegin_usingDict(). 
+*   Requires 2 contexts : 1 for reference (preparedDCtx), which will not be modified, and 1 to run the decompression operation (dctx) */ 
 ZSTDLIBv06_API size_t ZSTDv06_decompress_usingPreparedDCtx(
-                                           ZSTDv06_DCtx* dctx, const ZSTDv06_DCtx* preparedDCtx,
-                                           void* dst, size_t dstCapacity,
-                                     const void* src, size_t srcSize);
-
-
-
-#define ZSTDv06_FRAMEHEADERSIZE_MAX 13    /* for static allocation */
-static const size_t ZSTDv06_frameHeaderSize_min = 5;
-static const size_t ZSTDv06_frameHeaderSize_max = ZSTDv06_FRAMEHEADERSIZE_MAX;
-
+                                           ZSTDv06_DCtx* dctx, const ZSTDv06_DCtx* preparedDCtx, 
+                                           void* dst, size_t dstCapacity, 
+                                     const void* src, size_t srcSize); 
+ 
+ 
+ 
+#define ZSTDv06_FRAMEHEADERSIZE_MAX 13    /* for static allocation */ 
+static const size_t ZSTDv06_frameHeaderSize_min = 5; 
+static const size_t ZSTDv06_frameHeaderSize_max = ZSTDv06_FRAMEHEADERSIZE_MAX; 
+ 
 ZSTDLIBv06_API size_t ZSTDv06_decompressBegin(ZSTDv06_DCtx* dctx);
-
-/*
-  Streaming decompression, direct mode (bufferless)
-
-  A ZSTDv06_DCtx object is required to track streaming operations.
-  Use ZSTDv06_createDCtx() / ZSTDv06_freeDCtx() to manage it.
-  A ZSTDv06_DCtx object can be re-used multiple times.
-
-  First optional operation is to retrieve frame parameters, using ZSTDv06_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 ZSTDv06_frameHeaderSize_min to ZSTDv06_frameHeaderSize_max (so if `srcSize` >= ZSTDv06_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 ZSTDv06_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 ZSTDv06_isError()
-
-  Start decompression, with ZSTDv06_decompressBegin() or ZSTDv06_decompressBegin_usingDict().
-  Alternatively, you can copy a prepared context, using ZSTDv06_copyDCtx().
-
-  Then use ZSTDv06_nextSrcSizeToDecompress() and ZSTDv06_decompressContinue() alternatively.
-  ZSTDv06_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTDv06_decompressContinue().
-  ZSTDv06_decompressContinue() requires this exact amount of bytes, or it will fail.
-  ZSTDv06_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 ZSTDv06_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity)
-  It can be zero, which is not an error; it just means ZSTDv06_decompressContinue() has decoded some header.
-
-  A frame is fully decoded when ZSTDv06_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 <= ZSTDv06_BLOCKSIZE_MAX (128 KB)
-    - Compressing or decompressing requires a context structure
-      + Use ZSTDv06_createCCtx() and ZSTDv06_createDCtx()
-    - It is necessary to init context before starting
-      + compression : ZSTDv06_compressBegin()
-      + decompression : ZSTDv06_decompressBegin()
-      + variants _usingDict() are also allowed
-      + copyCCtx() and copyDCtx() work too
-    - When a block is considered not compressible enough, ZSTDv06_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
-      + ZSTDv06_decompressBlock() doesn't accept uncompressed data as input !!
-*/
-
-#define ZSTDv06_BLOCKSIZE_MAX (128 * 1024)   /* define, for static allocation */
+ 
+/* 
+  Streaming decompression, direct mode (bufferless) 
+ 
+  A ZSTDv06_DCtx object is required to track streaming operations. 
+  Use ZSTDv06_createDCtx() / ZSTDv06_freeDCtx() to manage it. 
+  A ZSTDv06_DCtx object can be re-used multiple times. 
+ 
+  First optional operation is to retrieve frame parameters, using ZSTDv06_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 ZSTDv06_frameHeaderSize_min to ZSTDv06_frameHeaderSize_max (so if `srcSize` >= ZSTDv06_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 ZSTDv06_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 ZSTDv06_isError() 
+ 
+  Start decompression, with ZSTDv06_decompressBegin() or ZSTDv06_decompressBegin_usingDict(). 
+  Alternatively, you can copy a prepared context, using ZSTDv06_copyDCtx(). 
+ 
+  Then use ZSTDv06_nextSrcSizeToDecompress() and ZSTDv06_decompressContinue() alternatively. 
+  ZSTDv06_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTDv06_decompressContinue(). 
+  ZSTDv06_decompressContinue() requires this exact amount of bytes, or it will fail. 
+  ZSTDv06_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 ZSTDv06_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity) 
+  It can be zero, which is not an error; it just means ZSTDv06_decompressContinue() has decoded some header. 
+ 
+  A frame is fully decoded when ZSTDv06_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 <= ZSTDv06_BLOCKSIZE_MAX (128 KB) 
+    - Compressing or decompressing requires a context structure 
+      + Use ZSTDv06_createCCtx() and ZSTDv06_createDCtx() 
+    - It is necessary to init context before starting 
+      + compression : ZSTDv06_compressBegin() 
+      + decompression : ZSTDv06_decompressBegin() 
+      + variants _usingDict() are also allowed 
+      + copyCCtx() and copyDCtx() work too 
+    - When a block is considered not compressible enough, ZSTDv06_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 
+      + ZSTDv06_decompressBlock() doesn't accept uncompressed data as input !! 
+*/ 
+ 
+#define ZSTDv06_BLOCKSIZE_MAX (128 * 1024)   /* define, for static allocation */ 
 ZSTDLIBv06_API size_t ZSTDv06_decompressBlock(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* ZSTDv06_STATIC_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 ZSTDv06_CCOMMON_H_MODULE
-#define ZSTDv06_CCOMMON_H_MODULE
-
-
-/*-*************************************
-*  Common macros
-***************************************/
-#define MIN(a,b) ((a)<(b) ? (a) : (b))
-#define MAX(a,b) ((a)>(b) ? (a) : (b))
-
-
-/*-*************************************
-*  Common constants
-***************************************/
-#define ZSTDv06_DICT_MAGIC  0xEC30A436
-
-#define ZSTDv06_REP_NUM    3
-#define ZSTDv06_REP_INIT   ZSTDv06_REP_NUM
-#define ZSTDv06_REP_MOVE   (ZSTDv06_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 ZSTDv06_WINDOWLOG_ABSOLUTEMIN 12
-static const size_t ZSTDv06_fcs_fieldSize[4] = { 0, 1, 2, 8 };
-
-#define ZSTDv06_BLOCKHEADERSIZE 3   /* because C standard does not allow a static const value to be defined using another static const value .... :( */
-static const size_t ZSTDv06_blockHeaderSize = ZSTDv06_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 FSEv06_ENCODING_RAW     0
-#define FSEv06_ENCODING_RLE     1
-#define FSEv06_ENCODING_STATIC  2
-#define FSEv06_ENCODING_DYNAMIC 3
-
+ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* ZSTDv06_STATIC_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 ZSTDv06_CCOMMON_H_MODULE 
+#define ZSTDv06_CCOMMON_H_MODULE 
+ 
+ 
+/*-************************************* 
+*  Common macros 
+***************************************/ 
+#define MIN(a,b) ((a)<(b) ? (a) : (b)) 
+#define MAX(a,b) ((a)>(b) ? (a) : (b)) 
+ 
+ 
+/*-************************************* 
+*  Common constants 
+***************************************/ 
+#define ZSTDv06_DICT_MAGIC  0xEC30A436 
+ 
+#define ZSTDv06_REP_NUM    3 
+#define ZSTDv06_REP_INIT   ZSTDv06_REP_NUM 
+#define ZSTDv06_REP_MOVE   (ZSTDv06_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 ZSTDv06_WINDOWLOG_ABSOLUTEMIN 12 
+static const size_t ZSTDv06_fcs_fieldSize[4] = { 0, 1, 2, 8 }; 
+ 
+#define ZSTDv06_BLOCKHEADERSIZE 3   /* because C standard does not allow a static const value to be defined using another static const value .... :( */ 
+static const size_t ZSTDv06_blockHeaderSize = ZSTDv06_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 FSEv06_ENCODING_RAW     0 
+#define FSEv06_ENCODING_RLE     1 
+#define FSEv06_ENCODING_STATIC  2 
+#define FSEv06_ENCODING_DYNAMIC 3 
+ 
 #define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
 
-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 ZSTDv06_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
-#define COPY8(d,s) { ZSTDv06_copy8(d,s); d+=8; s+=8; }
-
-/*! ZSTDv06_wildcopy() :
-*   custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0) */
-#define WILDCOPY_OVERLENGTH 8
+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 ZSTDv06_copy8(void* dst, const void* src) { memcpy(dst, src, 8); } 
+#define COPY8(d,s) { ZSTDv06_copy8(d,s); d+=8; s+=8; } 
+ 
+/*! ZSTDv06_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 ZSTDv06_wildcopy(void* dst, const void* src, ptrdiff_t length)
-{
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + length;
-    do
-        COPY8(op, ip)
-    while (op < oend);
-}
-
-
-
-/*-*******************************************
-*  Private interfaces
-*********************************************/
-typedef struct {
-    U32 off;
-    U32 len;
-} ZSTDv06_match_t;
-
-typedef struct {
-    U32 price;
-    U32 off;
-    U32 mlen;
-    U32 litlen;
-    U32 rep[ZSTDv06_REP_INIT];
-} ZSTDv06_optimal_t;
-
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + length; 
+    do 
+        COPY8(op, ip) 
+    while (op < oend); 
+} 
+ 
+ 
+ 
+/*-******************************************* 
+*  Private interfaces 
+*********************************************/ 
+typedef struct { 
+    U32 off; 
+    U32 len; 
+} ZSTDv06_match_t; 
+ 
+typedef struct { 
+    U32 price; 
+    U32 off; 
+    U32 mlen; 
+    U32 litlen; 
+    U32 rep[ZSTDv06_REP_INIT]; 
+} ZSTDv06_optimal_t; 
+ 
 typedef struct { U32  unused; } ZSTDv06_stats_t;
-
-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 */
-    ZSTDv06_optimal_t* priceTable;
-    ZSTDv06_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;
-    ZSTDv06_stats_t stats;
-} seqStore_t;
-
-void ZSTDv06_seqToCodes(const seqStore_t* seqStorePtr, size_t const nbSeq);
-
-
-#endif   /* ZSTDv06_CCOMMON_H_MODULE */
-/* ******************************************************************
-   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 FSEv06_H
-#define FSEv06_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-
-/*-****************************************
-*  FSE simple functions
-******************************************/
-/*! FSEv06_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 FSEv06_isError() .
-
-    ** Important ** : FSEv06_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 FSEv06_decompress(void* dst,  size_t dstCapacity,
-                const void* cSrc, size_t cSrcSize);
-
-
-/*-*****************************************
-*  Tool functions
-******************************************/
-size_t FSEv06_compressBound(size_t size);       /* maximum compressed size */
-
-/* Error Management */
-unsigned    FSEv06_isError(size_t code);        /* tells if a return value is an error code */
-const char* FSEv06_getErrorName(size_t code);   /* provides error code string (useful for debugging) */
-
-
-
-/*-*****************************************
-*  FSE detailed API
-******************************************/
-/*!
-
-FSEv06_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 *** */
-
-/*! FSEv06_readNCount():
-    Read compactly saved 'normalizedCounter' from 'rBuffer'.
-    @return : size read from 'rBuffer',
-              or an errorCode, which can be tested using FSEv06_isError().
-              maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
-size_t FSEv06_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize);
-
-/*! Constructor and Destructor of FSEv06_DTable.
-    Note that its size depends on 'tableLog' */
-typedef unsigned FSEv06_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
-FSEv06_DTable* FSEv06_createDTable(unsigned tableLog);
-void        FSEv06_freeDTable(FSEv06_DTable* dt);
-
-/*! FSEv06_buildDTable():
-    Builds 'dt', which must be already allocated, using FSEv06_createDTable().
-    return : 0, or an errorCode, which can be tested using FSEv06_isError() */
-size_t FSEv06_buildDTable (FSEv06_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
-
-/*! FSEv06_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 FSEv06_isError() */
-size_t FSEv06_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSEv06_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 FSEv06_readNCount() if it was saved using FSEv06_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).
-FSEv06_readNCount() will provide 'tableLog' and 'maxSymbolValue'.
-The result of FSEv06_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 FSEv06_isError().
-
-The next step is to build the decompression tables 'FSEv06_DTable' from 'normalizedCounter'.
-This is performed by the function FSEv06_buildDTable().
-The space required by 'FSEv06_DTable' must be already allocated using FSEv06_createDTable().
-If there is an error, the function will return an error code, which can be tested using FSEv06_isError().
-
-`FSEv06_DTable` can then be used to decompress `cSrc`, with FSEv06_decompress_usingDTable().
-`cSrcSize` must be strictly correct, otherwise decompression will fail.
-FSEv06_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 FSEv06_isError(). (ex: dst buffer too small)
-*/
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* FSEv06_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.
-*/
-
-
-/*=========================================
-*  Target specific
-=========================================*/
-#if defined(__BMI__) && defined(__GNUC__)
-#  include <immintrin.h>   /* support for bextr (experimental) */
-#endif
-
-
-
-/*-********************************************
-*  bitStream decoding API (read backward)
-**********************************************/
-typedef struct
-{
-    size_t   bitContainer;
-    unsigned bitsConsumed;
-    const char* ptr;
-    const char* start;
-} BITv06_DStream_t;
-
-typedef enum { BITv06_DStream_unfinished = 0,
-               BITv06_DStream_endOfBuffer = 1,
-               BITv06_DStream_completed = 2,
-               BITv06_DStream_overflow = 3 } BITv06_DStream_status;  /* result of BITv06_reloadDStream() */
-               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
-
-MEM_STATIC size_t   BITv06_initDStream(BITv06_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
-MEM_STATIC size_t   BITv06_readBits(BITv06_DStream_t* bitD, unsigned nbBits);
-MEM_STATIC BITv06_DStream_status BITv06_reloadDStream(BITv06_DStream_t* bitD);
-MEM_STATIC unsigned BITv06_endOfDStream(const BITv06_DStream_t* bitD);
-
-
-
-/*-****************************************
-*  unsafe API
-******************************************/
-MEM_STATIC size_t BITv06_readBitsFast(BITv06_DStream_t* bitD, unsigned nbBits);
-/* faster, but works only if nbBits >= 1 */
-
-
-
-/*-**************************************************************
-*  Internal functions
-****************************************************************/
+ 
+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 */ 
+    ZSTDv06_optimal_t* priceTable; 
+    ZSTDv06_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; 
+    ZSTDv06_stats_t stats; 
+} seqStore_t; 
+ 
+void ZSTDv06_seqToCodes(const seqStore_t* seqStorePtr, size_t const nbSeq); 
+ 
+ 
+#endif   /* ZSTDv06_CCOMMON_H_MODULE */ 
+/* ****************************************************************** 
+   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 FSEv06_H 
+#define FSEv06_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+ 
+/*-**************************************** 
+*  FSE simple functions 
+******************************************/ 
+/*! FSEv06_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 FSEv06_isError() . 
+ 
+    ** Important ** : FSEv06_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 FSEv06_decompress(void* dst,  size_t dstCapacity, 
+                const void* cSrc, size_t cSrcSize); 
+ 
+ 
+/*-***************************************** 
+*  Tool functions 
+******************************************/ 
+size_t FSEv06_compressBound(size_t size);       /* maximum compressed size */ 
+ 
+/* Error Management */ 
+unsigned    FSEv06_isError(size_t code);        /* tells if a return value is an error code */ 
+const char* FSEv06_getErrorName(size_t code);   /* provides error code string (useful for debugging) */ 
+ 
+ 
+ 
+/*-***************************************** 
+*  FSE detailed API 
+******************************************/ 
+/*! 
+ 
+FSEv06_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 *** */ 
+ 
+/*! FSEv06_readNCount(): 
+    Read compactly saved 'normalizedCounter' from 'rBuffer'. 
+    @return : size read from 'rBuffer', 
+              or an errorCode, which can be tested using FSEv06_isError(). 
+              maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */ 
+size_t FSEv06_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize); 
+ 
+/*! Constructor and Destructor of FSEv06_DTable. 
+    Note that its size depends on 'tableLog' */ 
+typedef unsigned FSEv06_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */ 
+FSEv06_DTable* FSEv06_createDTable(unsigned tableLog); 
+void        FSEv06_freeDTable(FSEv06_DTable* dt); 
+ 
+/*! FSEv06_buildDTable(): 
+    Builds 'dt', which must be already allocated, using FSEv06_createDTable(). 
+    return : 0, or an errorCode, which can be tested using FSEv06_isError() */ 
+size_t FSEv06_buildDTable (FSEv06_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog); 
+ 
+/*! FSEv06_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 FSEv06_isError() */ 
+size_t FSEv06_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSEv06_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 FSEv06_readNCount() if it was saved using FSEv06_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). 
+FSEv06_readNCount() will provide 'tableLog' and 'maxSymbolValue'. 
+The result of FSEv06_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 FSEv06_isError(). 
+ 
+The next step is to build the decompression tables 'FSEv06_DTable' from 'normalizedCounter'. 
+This is performed by the function FSEv06_buildDTable(). 
+The space required by 'FSEv06_DTable' must be already allocated using FSEv06_createDTable(). 
+If there is an error, the function will return an error code, which can be tested using FSEv06_isError(). 
+ 
+`FSEv06_DTable` can then be used to decompress `cSrc`, with FSEv06_decompress_usingDTable(). 
+`cSrcSize` must be strictly correct, otherwise decompression will fail. 
+FSEv06_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 FSEv06_isError(). (ex: dst buffer too small) 
+*/ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* FSEv06_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. 
+*/ 
+ 
+ 
+/*========================================= 
+*  Target specific 
+=========================================*/ 
+#if defined(__BMI__) && defined(__GNUC__) 
+#  include <immintrin.h>   /* support for bextr (experimental) */ 
+#endif 
+ 
+ 
+ 
+/*-******************************************** 
+*  bitStream decoding API (read backward) 
+**********************************************/ 
+typedef struct 
+{ 
+    size_t   bitContainer; 
+    unsigned bitsConsumed; 
+    const char* ptr; 
+    const char* start; 
+} BITv06_DStream_t; 
+ 
+typedef enum { BITv06_DStream_unfinished = 0, 
+               BITv06_DStream_endOfBuffer = 1, 
+               BITv06_DStream_completed = 2, 
+               BITv06_DStream_overflow = 3 } BITv06_DStream_status;  /* result of BITv06_reloadDStream() */ 
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */ 
+ 
+MEM_STATIC size_t   BITv06_initDStream(BITv06_DStream_t* bitD, const void* srcBuffer, size_t srcSize); 
+MEM_STATIC size_t   BITv06_readBits(BITv06_DStream_t* bitD, unsigned nbBits); 
+MEM_STATIC BITv06_DStream_status BITv06_reloadDStream(BITv06_DStream_t* bitD); 
+MEM_STATIC unsigned BITv06_endOfDStream(const BITv06_DStream_t* bitD); 
+ 
+ 
+ 
+/*-**************************************** 
+*  unsafe API 
+******************************************/ 
+MEM_STATIC size_t BITv06_readBitsFast(BITv06_DStream_t* bitD, unsigned nbBits); 
+/* faster, but works only if nbBits >= 1 */ 
+ 
+ 
+ 
+/*-************************************************************** 
+*  Internal functions 
+****************************************************************/ 
 MEM_STATIC unsigned BITv06_highbit32 ( U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
     unsigned long r;
     return _BitScanReverse(&r, val) ? (unsigned)r : 0;
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */ 
     return __builtin_clz (val) ^ 31;
-#   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
-**********************************************************/
-/*! BITv06_initDStream() :
-*   Initialize a BITv06_DStream_t.
-*   `bitD` : a pointer to an already allocated BITv06_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 BITv06_initDStream(BITv06_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->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 - BITv06_highbit32(lastByte); }
-    } else {
-        bitD->start = (const char*)srcBuffer;
-        bitD->ptr   = bitD->start;
-        bitD->bitContainer = *(const BYTE*)(bitD->start);
-        switch(srcSize)
-        {
+#   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 
+**********************************************************/ 
+/*! BITv06_initDStream() : 
+*   Initialize a BITv06_DStream_t. 
+*   `bitD` : a pointer to an already allocated BITv06_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 BITv06_initDStream(BITv06_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->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 - BITv06_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);/* fall-through */
             case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);/* fall-through */
             case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);/* fall-through */
@@ -910,2752 +910,2752 @@ MEM_STATIC size_t BITv06_initDStream(BITv06_DStream_t* bitD, const void* srcBuff
             case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; /* fall-through */
             case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) <<  8; /* fall-through */
             default: break;
-        }
-        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
-          if (lastByte == 0) return ERROR(GENERIC);   /* endMark not present */
-          bitD->bitsConsumed = 8 - BITv06_highbit32(lastByte); }
-        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
-    }
-
-    return srcSize;
-}
-
-
- MEM_STATIC size_t BITv06_lookBits(const BITv06_DStream_t* bitD, U32 nbBits)
-{
-    U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;
-    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
-}
-
-/*! BITv06_lookBitsFast() :
-*   unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BITv06_lookBitsFast(const BITv06_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 BITv06_skipBits(BITv06_DStream_t* bitD, U32 nbBits)
-{
-    bitD->bitsConsumed += nbBits;
-}
-
-MEM_STATIC size_t BITv06_readBits(BITv06_DStream_t* bitD, U32 nbBits)
-{
-    size_t const value = BITv06_lookBits(bitD, nbBits);
-    BITv06_skipBits(bitD, nbBits);
-    return value;
-}
-
-/*! BITv06_readBitsFast() :
-*   unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BITv06_readBitsFast(BITv06_DStream_t* bitD, U32 nbBits)
-{
-    size_t const value = BITv06_lookBitsFast(bitD, nbBits);
-    BITv06_skipBits(bitD, nbBits);
-    return value;
-}
-
-MEM_STATIC BITv06_DStream_status BITv06_reloadDStream(BITv06_DStream_t* bitD)
-{
+        } 
+        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; 
+          if (lastByte == 0) return ERROR(GENERIC);   /* endMark not present */ 
+          bitD->bitsConsumed = 8 - BITv06_highbit32(lastByte); } 
+        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; 
+    } 
+ 
+    return srcSize; 
+} 
+ 
+ 
+ MEM_STATIC size_t BITv06_lookBits(const BITv06_DStream_t* bitD, U32 nbBits) 
+{ 
+    U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1; 
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask); 
+} 
+ 
+/*! BITv06_lookBitsFast() : 
+*   unsafe version; only works only if nbBits >= 1 */ 
+MEM_STATIC size_t BITv06_lookBitsFast(const BITv06_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 BITv06_skipBits(BITv06_DStream_t* bitD, U32 nbBits) 
+{ 
+    bitD->bitsConsumed += nbBits; 
+} 
+ 
+MEM_STATIC size_t BITv06_readBits(BITv06_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t const value = BITv06_lookBits(bitD, nbBits); 
+    BITv06_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+/*! BITv06_readBitsFast() : 
+*   unsafe version; only works only if nbBits >= 1 */ 
+MEM_STATIC size_t BITv06_readBitsFast(BITv06_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t const value = BITv06_lookBitsFast(bitD, nbBits); 
+    BITv06_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+MEM_STATIC BITv06_DStream_status BITv06_reloadDStream(BITv06_DStream_t* bitD) 
+{ 
     if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */
         return BITv06_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 BITv06_DStream_unfinished;
-    }
-    if (bitD->ptr == bitD->start) {
-        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BITv06_DStream_endOfBuffer;
-        return BITv06_DStream_completed;
-    }
-    {   U32 nbBytes = bitD->bitsConsumed >> 3;
-        BITv06_DStream_status result = BITv06_DStream_unfinished;
-        if (bitD->ptr - nbBytes < bitD->start) {
-            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
-            result = BITv06_DStream_endOfBuffer;
-        }
-        bitD->ptr -= nbBytes;
-        bitD->bitsConsumed -= nbBytes*8;
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
-        return result;
-    }
-}
-
-/*! BITv06_endOfDStream() :
-*   @return Tells if DStream has exactly reached its end (all bits consumed).
-*/
-MEM_STATIC unsigned BITv06_endOfDStream(const BITv06_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 FSEv06_STATIC_H
-#define FSEv06_STATIC_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* *****************************************
-*  Static allocation
-*******************************************/
-/* FSE buffer bounds */
-#define FSEv06_NCOUNTBOUND 512
-#define FSEv06_BLOCKBOUND(size) (size + (size>>7))
-#define FSEv06_COMPRESSBOUND(size) (FSEv06_NCOUNTBOUND + FSEv06_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 FSEv06_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
-
-
-/* *****************************************
-*  FSE advanced API
-*******************************************/
-size_t FSEv06_countFast(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize);
-/* same as FSEv06_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr  */
-
-size_t FSEv06_buildDTable_raw (FSEv06_DTable* dt, unsigned nbBits);
-/* build a fake FSEv06_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */
-
-size_t FSEv06_buildDTable_rle (FSEv06_DTable* dt, unsigned char symbolValue);
-/* build a fake FSEv06_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 */
-} FSEv06_DState_t;
-
-
-static void     FSEv06_initDState(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD, const FSEv06_DTable* dt);
-
-static unsigned char FSEv06_decodeSymbol(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD);
-
-
-/* *****************************************
-*  FSE unsafe API
-*******************************************/
-static unsigned char FSEv06_decodeSymbolFast(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD);
-/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
-
-
-/* *****************************************
-*  Implementation of inlined functions
-*******************************************/
-
-
+ 
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) { 
+        bitD->ptr -= bitD->bitsConsumed >> 3; 
+        bitD->bitsConsumed &= 7; 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr); 
+        return BITv06_DStream_unfinished; 
+    } 
+    if (bitD->ptr == bitD->start) { 
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BITv06_DStream_endOfBuffer; 
+        return BITv06_DStream_completed; 
+    } 
+    {   U32 nbBytes = bitD->bitsConsumed >> 3; 
+        BITv06_DStream_status result = BITv06_DStream_unfinished; 
+        if (bitD->ptr - nbBytes < bitD->start) { 
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */ 
+            result = BITv06_DStream_endOfBuffer; 
+        } 
+        bitD->ptr -= nbBytes; 
+        bitD->bitsConsumed -= nbBytes*8; 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */ 
+        return result; 
+    } 
+} 
+ 
+/*! BITv06_endOfDStream() : 
+*   @return Tells if DStream has exactly reached its end (all bits consumed). 
+*/ 
+MEM_STATIC unsigned BITv06_endOfDStream(const BITv06_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 FSEv06_STATIC_H 
+#define FSEv06_STATIC_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* ***************************************** 
+*  Static allocation 
+*******************************************/ 
+/* FSE buffer bounds */ 
+#define FSEv06_NCOUNTBOUND 512 
+#define FSEv06_BLOCKBOUND(size) (size + (size>>7)) 
+#define FSEv06_COMPRESSBOUND(size) (FSEv06_NCOUNTBOUND + FSEv06_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 FSEv06_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog)) 
+ 
+ 
+/* ***************************************** 
+*  FSE advanced API 
+*******************************************/ 
+size_t FSEv06_countFast(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize); 
+/* same as FSEv06_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr  */ 
+ 
+size_t FSEv06_buildDTable_raw (FSEv06_DTable* dt, unsigned nbBits); 
+/* build a fake FSEv06_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */ 
+ 
+size_t FSEv06_buildDTable_rle (FSEv06_DTable* dt, unsigned char symbolValue); 
+/* build a fake FSEv06_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 */ 
+} FSEv06_DState_t; 
+ 
+ 
+static void     FSEv06_initDState(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD, const FSEv06_DTable* dt); 
+ 
+static unsigned char FSEv06_decodeSymbol(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD); 
+ 
+ 
+/* ***************************************** 
+*  FSE unsafe API 
+*******************************************/ 
+static unsigned char FSEv06_decodeSymbolFast(FSEv06_DState_t* DStatePtr, BITv06_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;
-} FSEv06_DTableHeader;   /* sizeof U32 */
-
-typedef struct
-{
-    unsigned short newState;
-    unsigned char  symbol;
-    unsigned char  nbBits;
-} FSEv06_decode_t;   /* size == U32 */
-
-MEM_STATIC void FSEv06_initDState(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD, const FSEv06_DTable* dt)
-{
-    const void* ptr = dt;
-    const FSEv06_DTableHeader* const DTableH = (const FSEv06_DTableHeader*)ptr;
-    DStatePtr->state = BITv06_readBits(bitD, DTableH->tableLog);
-    BITv06_reloadDStream(bitD);
-    DStatePtr->table = dt + 1;
-}
-
-MEM_STATIC BYTE FSEv06_peekSymbol(const FSEv06_DState_t* DStatePtr)
-{
-    FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    return DInfo.symbol;
-}
-
-MEM_STATIC void FSEv06_updateState(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD)
-{
-    FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    U32 const nbBits = DInfo.nbBits;
-    size_t const lowBits = BITv06_readBits(bitD, nbBits);
-    DStatePtr->state = DInfo.newState + lowBits;
-}
-
-MEM_STATIC BYTE FSEv06_decodeSymbol(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD)
-{
-    FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    U32 const nbBits = DInfo.nbBits;
-    BYTE const symbol = DInfo.symbol;
-    size_t const lowBits = BITv06_readBits(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-/*! FSEv06_decodeSymbolFast() :
-    unsafe, only works if no symbol has a probability > 50% */
-MEM_STATIC BYTE FSEv06_decodeSymbolFast(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD)
-{
-    FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    U32 const nbBits = DInfo.nbBits;
-    BYTE const symbol = DInfo.symbol;
-    size_t const lowBits = BITv06_readBitsFast(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-
-
-#ifndef FSEv06_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 FSEv06_MAX_MEMORY_USAGE 14
-#define FSEv06_DEFAULT_MEMORY_USAGE 13
-
-/*!FSEv06_MAX_SYMBOL_VALUE :
-*  Maximum symbol value authorized.
-*  Required for proper stack allocation */
-#define FSEv06_MAX_SYMBOL_VALUE 255
-
-
-/* **************************************************************
-*  template functions type & suffix
-****************************************************************/
-#define FSEv06_FUNCTION_TYPE BYTE
-#define FSEv06_FUNCTION_EXTENSION
-#define FSEv06_DECODE_TYPE FSEv06_decode_t
-
-
-#endif   /* !FSEv06_COMMONDEFS_ONLY */
-
-
-/* ***************************************************************
-*  Constants
-*****************************************************************/
-#define FSEv06_MAX_TABLELOG  (FSEv06_MAX_MEMORY_USAGE-2)
-#define FSEv06_MAX_TABLESIZE (1U<<FSEv06_MAX_TABLELOG)
-#define FSEv06_MAXTABLESIZE_MASK (FSEv06_MAX_TABLESIZE-1)
-#define FSEv06_DEFAULT_TABLELOG (FSEv06_DEFAULT_MEMORY_USAGE-2)
-#define FSEv06_MIN_TABLELOG 5
-
-#define FSEv06_TABLELOG_ABSOLUTE_MAX 15
-#if FSEv06_MAX_TABLELOG > FSEv06_TABLELOG_ABSOLUTE_MAX
-#error "FSEv06_MAX_TABLELOG > FSEv06_TABLELOG_ABSOLUTE_MAX is not supported"
-#endif
-
-#define FSEv06_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3)
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* FSEv06_STATIC_H */
-/*
-   Common functions of New Generation Entropy library
-   Copyright (C) 2016, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    You can contact the author at :
-    - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
-    - Public forum : https://groups.google.com/forum/#!forum/lz4c
-*************************************************************************** */
-
-
-/*-****************************************
-*  FSE Error Management
-******************************************/
-unsigned FSEv06_isError(size_t code) { return ERR_isError(code); }
-
-const char* FSEv06_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-
-/* **************************************************************
-*  HUF Error Management
-****************************************************************/
+ 
+typedef struct { 
+    U16 tableLog; 
+    U16 fastMode; 
+} FSEv06_DTableHeader;   /* sizeof U32 */ 
+ 
+typedef struct 
+{ 
+    unsigned short newState; 
+    unsigned char  symbol; 
+    unsigned char  nbBits; 
+} FSEv06_decode_t;   /* size == U32 */ 
+ 
+MEM_STATIC void FSEv06_initDState(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD, const FSEv06_DTable* dt) 
+{ 
+    const void* ptr = dt; 
+    const FSEv06_DTableHeader* const DTableH = (const FSEv06_DTableHeader*)ptr; 
+    DStatePtr->state = BITv06_readBits(bitD, DTableH->tableLog); 
+    BITv06_reloadDStream(bitD); 
+    DStatePtr->table = dt + 1; 
+} 
+ 
+MEM_STATIC BYTE FSEv06_peekSymbol(const FSEv06_DState_t* DStatePtr) 
+{ 
+    FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    return DInfo.symbol; 
+} 
+ 
+MEM_STATIC void FSEv06_updateState(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD) 
+{ 
+    FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    U32 const nbBits = DInfo.nbBits; 
+    size_t const lowBits = BITv06_readBits(bitD, nbBits); 
+    DStatePtr->state = DInfo.newState + lowBits; 
+} 
+ 
+MEM_STATIC BYTE FSEv06_decodeSymbol(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD) 
+{ 
+    FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    U32 const nbBits = DInfo.nbBits; 
+    BYTE const symbol = DInfo.symbol; 
+    size_t const lowBits = BITv06_readBits(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+/*! FSEv06_decodeSymbolFast() : 
+    unsafe, only works if no symbol has a probability > 50% */ 
+MEM_STATIC BYTE FSEv06_decodeSymbolFast(FSEv06_DState_t* DStatePtr, BITv06_DStream_t* bitD) 
+{ 
+    FSEv06_decode_t const DInfo = ((const FSEv06_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    U32 const nbBits = DInfo.nbBits; 
+    BYTE const symbol = DInfo.symbol; 
+    size_t const lowBits = BITv06_readBitsFast(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+ 
+ 
+#ifndef FSEv06_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 FSEv06_MAX_MEMORY_USAGE 14 
+#define FSEv06_DEFAULT_MEMORY_USAGE 13 
+ 
+/*!FSEv06_MAX_SYMBOL_VALUE : 
+*  Maximum symbol value authorized. 
+*  Required for proper stack allocation */ 
+#define FSEv06_MAX_SYMBOL_VALUE 255 
+ 
+ 
+/* ************************************************************** 
+*  template functions type & suffix 
+****************************************************************/ 
+#define FSEv06_FUNCTION_TYPE BYTE 
+#define FSEv06_FUNCTION_EXTENSION 
+#define FSEv06_DECODE_TYPE FSEv06_decode_t 
+ 
+ 
+#endif   /* !FSEv06_COMMONDEFS_ONLY */ 
+ 
+ 
+/* *************************************************************** 
+*  Constants 
+*****************************************************************/ 
+#define FSEv06_MAX_TABLELOG  (FSEv06_MAX_MEMORY_USAGE-2) 
+#define FSEv06_MAX_TABLESIZE (1U<<FSEv06_MAX_TABLELOG) 
+#define FSEv06_MAXTABLESIZE_MASK (FSEv06_MAX_TABLESIZE-1) 
+#define FSEv06_DEFAULT_TABLELOG (FSEv06_DEFAULT_MEMORY_USAGE-2) 
+#define FSEv06_MIN_TABLELOG 5 
+ 
+#define FSEv06_TABLELOG_ABSOLUTE_MAX 15 
+#if FSEv06_MAX_TABLELOG > FSEv06_TABLELOG_ABSOLUTE_MAX 
+#error "FSEv06_MAX_TABLELOG > FSEv06_TABLELOG_ABSOLUTE_MAX is not supported" 
+#endif 
+ 
+#define FSEv06_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3) 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* FSEv06_STATIC_H */ 
+/* 
+   Common functions of New Generation Entropy library 
+   Copyright (C) 2016, Yann Collet. 
+ 
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+   Redistribution and use in source and binary forms, with or without 
+   modification, are permitted provided that the following conditions are 
+   met: 
+ 
+       * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer. 
+       * Redistributions in binary form must reproduce the above 
+   copyright notice, this list of conditions and the following disclaimer 
+   in the documentation and/or other materials provided with the 
+   distribution. 
+ 
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+    You can contact the author at : 
+    - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+*************************************************************************** */ 
+ 
+ 
+/*-**************************************** 
+*  FSE Error Management 
+******************************************/ 
+unsigned FSEv06_isError(size_t code) { return ERR_isError(code); } 
+ 
+const char* FSEv06_getErrorName(size_t code) { return ERR_getErrorName(code); } 
+ 
+ 
+/* ************************************************************** 
+*  HUF Error Management 
+****************************************************************/ 
 static unsigned HUFv06_isError(size_t code) { return ERR_isError(code); }
-
-
-/*-**************************************************************
-*  FSE NCount encoding-decoding
-****************************************************************/
-static short FSEv06_abs(short a) { return a<0 ? -a : a; }
-
-size_t FSEv06_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) + FSEv06_MIN_TABLELOG;   /* extract tableLog */
-    if (nbBits > FSEv06_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
-    bitStream >>= 4;
-    bitCount = 4;
-    *tableLogPtr = nbBits;
-    remaining = (1<<nbBits)+1;
-    threshold = 1<<nbBits;
-    nbBits++;
-
-    while ((remaining>1) && (charnum<=*maxSVPtr)) {
-        if (previous0) {
-            unsigned n0 = charnum;
-            while ((bitStream & 0xFFFF) == 0xFFFF) {
-                n0+=24;
-                if (ip < iend-5) {
-                    ip+=2;
-                    bitStream = MEM_readLE32(ip) >> bitCount;
-                } else {
-                    bitStream >>= 16;
-                    bitCount+=16;
-            }   }
-            while ((bitStream & 3) == 3) {
-                n0+=3;
-                bitStream>>=2;
-                bitCount+=2;
-            }
-            n0 += bitStream & 3;
-            bitCount += 2;
-            if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);
-            while (charnum < n0) normalizedCounter[charnum++] = 0;
-            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
-                ip += bitCount>>3;
-                bitCount &= 7;
-                bitStream = MEM_readLE32(ip) >> bitCount;
-            }
-            else
-                bitStream >>= 2;
-        }
-        {   short const max = (short)((2*threshold-1)-remaining);
-            short count;
-
-            if ((bitStream & (threshold-1)) < (U32)max) {
-                count = (short)(bitStream & (threshold-1));
-                bitCount   += nbBits-1;
-            } else {
-                count = (short)(bitStream & (2*threshold-1));
-                if (count >= threshold) count -= max;
-                bitCount   += nbBits;
-            }
-
-            count--;   /* extra accuracy */
-            remaining -= FSEv06_abs(count);
-            normalizedCounter[charnum++] = count;
-            previous0 = !count;
-            while (remaining < threshold) {
-                nbBits--;
-                threshold >>= 1;
-            }
-
-            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
-                ip += bitCount>>3;
-                bitCount &= 7;
-            } else {
-                bitCount -= (int)(8 * (iend - 4 - ip));
-                ip = iend - 4;
-            }
-            bitStream = MEM_readLE32(ip) >> (bitCount & 31);
-    }   }   /* while ((remaining>1) && (charnum<=*maxSVPtr)) */
-    if (remaining != 1) return ERROR(GENERIC);
-    *maxSVPtr = charnum-1;
-
-    ip += (bitCount+7)>>3;
-    if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);
-    return ip-istart;
-}
-/* ******************************************************************
-   FSE : Finite State Entropy decoder
-   Copyright (C) 2013-2015, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    You can contact the author at :
-    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
-    - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-
-
-/* **************************************************************
-*  Compiler specifics
-****************************************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  define FORCE_INLINE static __forceinline
-#  include <intrin.h>                    /* For Visual 2005 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
-#else
+ 
+ 
+/*-************************************************************** 
+*  FSE NCount encoding-decoding 
+****************************************************************/ 
+static short FSEv06_abs(short a) { return a<0 ? -a : a; } 
+ 
+size_t FSEv06_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) + FSEv06_MIN_TABLELOG;   /* extract tableLog */ 
+    if (nbBits > FSEv06_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge); 
+    bitStream >>= 4; 
+    bitCount = 4; 
+    *tableLogPtr = nbBits; 
+    remaining = (1<<nbBits)+1; 
+    threshold = 1<<nbBits; 
+    nbBits++; 
+ 
+    while ((remaining>1) && (charnum<=*maxSVPtr)) { 
+        if (previous0) { 
+            unsigned n0 = charnum; 
+            while ((bitStream & 0xFFFF) == 0xFFFF) { 
+                n0+=24; 
+                if (ip < iend-5) { 
+                    ip+=2; 
+                    bitStream = MEM_readLE32(ip) >> bitCount; 
+                } else { 
+                    bitStream >>= 16; 
+                    bitCount+=16; 
+            }   } 
+            while ((bitStream & 3) == 3) { 
+                n0+=3; 
+                bitStream>>=2; 
+                bitCount+=2; 
+            } 
+            n0 += bitStream & 3; 
+            bitCount += 2; 
+            if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall); 
+            while (charnum < n0) normalizedCounter[charnum++] = 0; 
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { 
+                ip += bitCount>>3; 
+                bitCount &= 7; 
+                bitStream = MEM_readLE32(ip) >> bitCount; 
+            } 
+            else 
+                bitStream >>= 2; 
+        } 
+        {   short const max = (short)((2*threshold-1)-remaining); 
+            short count; 
+ 
+            if ((bitStream & (threshold-1)) < (U32)max) { 
+                count = (short)(bitStream & (threshold-1)); 
+                bitCount   += nbBits-1; 
+            } else { 
+                count = (short)(bitStream & (2*threshold-1)); 
+                if (count >= threshold) count -= max; 
+                bitCount   += nbBits; 
+            } 
+ 
+            count--;   /* extra accuracy */ 
+            remaining -= FSEv06_abs(count); 
+            normalizedCounter[charnum++] = count; 
+            previous0 = !count; 
+            while (remaining < threshold) { 
+                nbBits--; 
+                threshold >>= 1; 
+            } 
+ 
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { 
+                ip += bitCount>>3; 
+                bitCount &= 7; 
+            } else { 
+                bitCount -= (int)(8 * (iend - 4 - ip)); 
+                ip = iend - 4; 
+            } 
+            bitStream = MEM_readLE32(ip) >> (bitCount & 31); 
+    }   }   /* while ((remaining>1) && (charnum<=*maxSVPtr)) */ 
+    if (remaining != 1) return ERROR(GENERIC); 
+    *maxSVPtr = charnum-1; 
+ 
+    ip += (bitCount+7)>>3; 
+    if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong); 
+    return ip-istart; 
+} 
+/* ****************************************************************** 
+   FSE : Finite State Entropy decoder 
+   Copyright (C) 2013-2015, Yann Collet. 
+ 
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+   Redistribution and use in source and binary forms, with or without 
+   modification, are permitted provided that the following conditions are 
+   met: 
+ 
+       * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer. 
+       * Redistributions in binary form must reproduce the above 
+   copyright notice, this list of conditions and the following disclaimer 
+   in the documentation and/or other materials provided with the 
+   distribution. 
+ 
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+    You can contact the author at : 
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+ 
+ 
+/* ************************************************************** 
+*  Compiler specifics 
+****************************************************************/ 
+#ifdef _MSC_VER    /* Visual Studio */ 
+#  define FORCE_INLINE static __forceinline 
+#  include <intrin.h>                    /* For Visual 2005 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */ 
+#else 
 #  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
 #    ifdef __GNUC__
 #      define FORCE_INLINE static inline __attribute__((always_inline))
 #    else
 #      define FORCE_INLINE static inline
 #    endif
-#  else
+#  else 
 #    define FORCE_INLINE static
 #  endif /* __STDC_VERSION__ */
-#endif
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#define FSEv06_isError ERR_isError
-#define FSEv06_STATIC_ASSERT(c) { enum { FSEv06_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-
-
-/* **************************************************************
-*  Complex types
-****************************************************************/
-typedef U32 DTable_max_t[FSEv06_DTABLE_SIZE_U32(FSEv06_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 FSEv06_FUNCTION_EXTENSION
-#  error "FSEv06_FUNCTION_EXTENSION must be defined"
-#endif
-#ifndef FSEv06_FUNCTION_TYPE
-#  error "FSEv06_FUNCTION_TYPE must be defined"
-#endif
-
-/* Function names */
-#define FSEv06_CAT(X,Y) X##Y
-#define FSEv06_FUNCTION_NAME(X,Y) FSEv06_CAT(X,Y)
-#define FSEv06_TYPE_NAME(X,Y) FSEv06_CAT(X,Y)
-
-
-/* Function templates */
-FSEv06_DTable* FSEv06_createDTable (unsigned tableLog)
-{
-    if (tableLog > FSEv06_TABLELOG_ABSOLUTE_MAX) tableLog = FSEv06_TABLELOG_ABSOLUTE_MAX;
-    return (FSEv06_DTable*)malloc( FSEv06_DTABLE_SIZE_U32(tableLog) * sizeof (U32) );
-}
-
-void FSEv06_freeDTable (FSEv06_DTable* dt)
-{
-    free(dt);
-}
-
-size_t FSEv06_buildDTable(FSEv06_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
-{
-    void* const tdPtr = dt+1;   /* because *dt is unsigned, 32-bits aligned on 32-bits */
-    FSEv06_DECODE_TYPE* const tableDecode = (FSEv06_DECODE_TYPE*) (tdPtr);
-    U16 symbolNext[FSEv06_MAX_SYMBOL_VALUE+1];
-
-    U32 const maxSV1 = maxSymbolValue + 1;
-    U32 const tableSize = 1 << tableLog;
-    U32 highThreshold = tableSize-1;
-
-    /* Sanity Checks */
-    if (maxSymbolValue > FSEv06_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
-    if (tableLog > FSEv06_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
-
-    /* Init, lay down lowprob symbols */
-    {   FSEv06_DTableHeader DTableH;
-        DTableH.tableLog = (U16)tableLog;
-        DTableH.fastMode = 1;
-        {   S16 const largeLimit= (S16)(1 << (tableLog-1));
-            U32 s;
-            for (s=0; s<maxSV1; s++) {
-                if (normalizedCounter[s]==-1) {
-                    tableDecode[highThreshold--].symbol = (FSEv06_FUNCTION_TYPE)s;
-                    symbolNext[s] = 1;
-                } else {
-                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
-                    symbolNext[s] = normalizedCounter[s];
-        }   }   }
-        memcpy(dt, &DTableH, sizeof(DTableH));
-    }
-
-    /* Spread symbols */
-    {   U32 const tableMask = tableSize-1;
-        U32 const step = FSEv06_TABLESTEP(tableSize);
-        U32 s, position = 0;
-        for (s=0; s<maxSV1; s++) {
-            int i;
-            for (i=0; i<normalizedCounter[s]; i++) {
-                tableDecode[position].symbol = (FSEv06_FUNCTION_TYPE)s;
-                position = (position + step) & tableMask;
-                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
-        }   }
-
-        if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
-    }
-
-    /* Build Decoding table */
-    {   U32 u;
-        for (u=0; u<tableSize; u++) {
-            FSEv06_FUNCTION_TYPE const symbol = (FSEv06_FUNCTION_TYPE)(tableDecode[u].symbol);
-            U16 nextState = symbolNext[symbol]++;
-            tableDecode[u].nbBits = (BYTE) (tableLog - BITv06_highbit32 ((U32)nextState) );
-            tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
-    }   }
-
-    return 0;
-}
-
-
-
-#ifndef FSEv06_COMMONDEFS_ONLY
-
-/*-*******************************************************
-*  Decompression (Byte symbols)
-*********************************************************/
-size_t FSEv06_buildDTable_rle (FSEv06_DTable* dt, BYTE symbolValue)
-{
-    void* ptr = dt;
-    FSEv06_DTableHeader* const DTableH = (FSEv06_DTableHeader*)ptr;
-    void* dPtr = dt + 1;
-    FSEv06_decode_t* const cell = (FSEv06_decode_t*)dPtr;
-
-    DTableH->tableLog = 0;
-    DTableH->fastMode = 0;
-
-    cell->newState = 0;
-    cell->symbol = symbolValue;
-    cell->nbBits = 0;
-
-    return 0;
-}
-
-
-size_t FSEv06_buildDTable_raw (FSEv06_DTable* dt, unsigned nbBits)
-{
-    void* ptr = dt;
-    FSEv06_DTableHeader* const DTableH = (FSEv06_DTableHeader*)ptr;
-    void* dPtr = dt + 1;
-    FSEv06_decode_t* const dinfo = (FSEv06_decode_t*)dPtr;
-    const unsigned tableSize = 1 << nbBits;
-    const unsigned tableMask = tableSize - 1;
-    const unsigned maxSV1 = tableMask+1;
-    unsigned s;
-
-    /* Sanity checks */
-    if (nbBits < 1) return ERROR(GENERIC);         /* min size */
-
-    /* Build Decoding Table */
-    DTableH->tableLog = (U16)nbBits;
-    DTableH->fastMode = 1;
-    for (s=0; s<maxSV1; s++) {
-        dinfo[s].newState = 0;
-        dinfo[s].symbol = (BYTE)s;
-        dinfo[s].nbBits = (BYTE)nbBits;
-    }
-
-    return 0;
-}
-
-FORCE_INLINE size_t FSEv06_decompress_usingDTable_generic(
-          void* dst, size_t maxDstSize,
-    const void* cSrc, size_t cSrcSize,
-    const FSEv06_DTable* dt, const unsigned fast)
-{
-    BYTE* const ostart = (BYTE*) dst;
-    BYTE* op = ostart;
-    BYTE* const omax = op + maxDstSize;
-    BYTE* const olimit = omax-3;
-
-    BITv06_DStream_t bitD;
-    FSEv06_DState_t state1;
-    FSEv06_DState_t state2;
-
-    /* Init */
-    { size_t const errorCode = BITv06_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */
-      if (FSEv06_isError(errorCode)) return errorCode; }
-
-    FSEv06_initDState(&state1, &bitD, dt);
-    FSEv06_initDState(&state2, &bitD, dt);
-
-#define FSEv06_GETSYMBOL(statePtr) fast ? FSEv06_decodeSymbolFast(statePtr, &bitD) : FSEv06_decodeSymbol(statePtr, &bitD)
-
-    /* 4 symbols per loop */
-    for ( ; (BITv06_reloadDStream(&bitD)==BITv06_DStream_unfinished) && (op<olimit) ; op+=4) {
-        op[0] = FSEv06_GETSYMBOL(&state1);
-
-        if (FSEv06_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            BITv06_reloadDStream(&bitD);
-
-        op[1] = FSEv06_GETSYMBOL(&state2);
-
-        if (FSEv06_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            { if (BITv06_reloadDStream(&bitD) > BITv06_DStream_unfinished) { op+=2; break; } }
-
-        op[2] = FSEv06_GETSYMBOL(&state1);
-
-        if (FSEv06_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            BITv06_reloadDStream(&bitD);
-
-        op[3] = FSEv06_GETSYMBOL(&state2);
-    }
-
-    /* tail */
-    /* note : BITv06_reloadDStream(&bitD) >= FSEv06_DStream_partiallyFilled; Ends at exactly BITv06_DStream_completed */
-    while (1) {
-        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
-
-        *op++ = FSEv06_GETSYMBOL(&state1);
-
-        if (BITv06_reloadDStream(&bitD)==BITv06_DStream_overflow) {
-            *op++ = FSEv06_GETSYMBOL(&state2);
-            break;
-        }
-
-        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
-
-        *op++ = FSEv06_GETSYMBOL(&state2);
-
-        if (BITv06_reloadDStream(&bitD)==BITv06_DStream_overflow) {
-            *op++ = FSEv06_GETSYMBOL(&state1);
-            break;
-    }   }
-
-    return op-ostart;
-}
-
-
-size_t FSEv06_decompress_usingDTable(void* dst, size_t originalSize,
-                            const void* cSrc, size_t cSrcSize,
-                            const FSEv06_DTable* dt)
-{
-    const void* ptr = dt;
-    const FSEv06_DTableHeader* DTableH = (const FSEv06_DTableHeader*)ptr;
-    const U32 fastMode = DTableH->fastMode;
-
-    /* select fast mode (static) */
-    if (fastMode) return FSEv06_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
-    return FSEv06_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
-}
-
-
-size_t FSEv06_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[FSEv06_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 = FSEv06_MAX_SYMBOL_VALUE;
-
-    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */
-
-    /* normal FSE decoding mode */
-    {   size_t const NCountLength = FSEv06_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
-        if (FSEv06_isError(NCountLength)) return NCountLength;
-        if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */
-        ip += NCountLength;
-        cSrcSize -= NCountLength;
-    }
-
-    { size_t const errorCode = FSEv06_buildDTable (dt, counting, maxSymbolValue, tableLog);
-      if (FSEv06_isError(errorCode)) return errorCode; }
-
-    return FSEv06_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);   /* always return, even if it is an error code */
-}
-
-
-
-#endif   /* FSEv06_COMMONDEFS_ONLY */
-/* ******************************************************************
-   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 HUFv06_H
-#define HUFv06_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* ****************************************
-*  HUF simple functions
-******************************************/
-size_t HUFv06_decompress(void* dst,  size_t dstSize,
-                const void* cSrc, size_t cSrcSize);
-/*
-HUFv06_decompress() :
-    Decompress HUF data from buffer 'cSrc', of size 'cSrcSize',
-    into already allocated destination buffer 'dst', of size 'dstSize'.
-    `dstSize` : must be the **exact** size of original (uncompressed) data.
-    Note : in contrast with FSE, HUFv06_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 HUFv06_isError()
-*/
-
-
-/* ****************************************
-*  Tool functions
-******************************************/
-size_t HUFv06_compressBound(size_t size);       /**< maximum compressed size */
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif   /* HUFv06_H */
-/* ******************************************************************
-   Huffman codec, part of New Generation Entropy library
-   header file, for static linking only
-   Copyright (C) 2013-2016, Yann Collet
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-****************************************************************** */
-#ifndef HUFv06_STATIC_H
-#define HUFv06_STATIC_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* ****************************************
-*  Static allocation
-******************************************/
-/* HUF buffer bounds */
-#define HUFv06_CTABLEBOUND 129
-#define HUFv06_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true if incompressible pre-filtered with fast heuristic */
-#define HUFv06_COMPRESSBOUND(size) (HUFv06_CTABLEBOUND + HUFv06_BLOCKBOUND(size))   /* Macro version, useful for static allocation */
-
-/* static allocation of HUF's DTable */
-#define HUFv06_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog))
-#define HUFv06_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
-        unsigned short DTable[HUFv06_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
-#define HUFv06_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \
-        unsigned int DTable[HUFv06_DTABLE_SIZE(maxTableLog)] = { maxTableLog }
-#define HUFv06_CREATE_STATIC_DTABLEX6(DTable, maxTableLog) \
-        unsigned int DTable[HUFv06_DTABLE_SIZE(maxTableLog) * 3 / 2] = { maxTableLog }
-
-
-/* ****************************************
-*  Advanced decompression functions
-******************************************/
-size_t HUFv06_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
-size_t HUFv06_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */
-
-
-
-/*!
-HUFv06_decompress() does the following:
-1. select the decompression algorithm (X2, X4, X6) based on pre-computed heuristics
-2. build Huffman table from save, using HUFv06_readDTableXn()
-3. decode 1 or 4 segments in parallel using HUFv06_decompressSXn_usingDTable
-*/
-size_t HUFv06_readDTableX2 (unsigned short* DTable, const void* src, size_t srcSize);
-size_t HUFv06_readDTableX4 (unsigned* DTable, const void* src, size_t srcSize);
-
-size_t HUFv06_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable);
-size_t HUFv06_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable);
-
-
-/* single stream variants */
-size_t HUFv06_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
-size_t HUFv06_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */
-
-size_t HUFv06_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable);
-size_t HUFv06_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable);
-
-
-
-/* **************************************************************
-*  Constants
-****************************************************************/
-#define HUFv06_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUFv06_MAX_TABLELOG. Beyond that value, code does not work */
-#define HUFv06_MAX_TABLELOG  12           /* max configured tableLog (for static allocation); can be modified up to HUFv06_ABSOLUTEMAX_TABLELOG */
-#define HUFv06_DEFAULT_TABLELOG  HUFv06_MAX_TABLELOG   /* tableLog by default, when not specified */
-#define HUFv06_MAX_SYMBOL_VALUE 255
-#if (HUFv06_MAX_TABLELOG > HUFv06_ABSOLUTEMAX_TABLELOG)
-#  error "HUFv06_MAX_TABLELOG is too large !"
-#endif
-
-
-
-/*! HUFv06_readStats() :
-    Read compact Huffman tree, saved by HUFv06_writeCTable().
-    `huffWeight` is destination buffer.
-    @return : size read from `src`
-*/
-MEM_STATIC size_t HUFv06_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                            U32* nbSymbolsPtr, U32* tableLogPtr,
-                            const void* src, size_t srcSize)
-{
-    U32 weightTotal;
-    const BYTE* ip = (const BYTE*) src;
+#endif 
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#define FSEv06_isError ERR_isError 
+#define FSEv06_STATIC_ASSERT(c) { enum { FSEv06_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */ 
+ 
+ 
+/* ************************************************************** 
+*  Complex types 
+****************************************************************/ 
+typedef U32 DTable_max_t[FSEv06_DTABLE_SIZE_U32(FSEv06_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 FSEv06_FUNCTION_EXTENSION 
+#  error "FSEv06_FUNCTION_EXTENSION must be defined" 
+#endif 
+#ifndef FSEv06_FUNCTION_TYPE 
+#  error "FSEv06_FUNCTION_TYPE must be defined" 
+#endif 
+ 
+/* Function names */ 
+#define FSEv06_CAT(X,Y) X##Y 
+#define FSEv06_FUNCTION_NAME(X,Y) FSEv06_CAT(X,Y) 
+#define FSEv06_TYPE_NAME(X,Y) FSEv06_CAT(X,Y) 
+ 
+ 
+/* Function templates */ 
+FSEv06_DTable* FSEv06_createDTable (unsigned tableLog) 
+{ 
+    if (tableLog > FSEv06_TABLELOG_ABSOLUTE_MAX) tableLog = FSEv06_TABLELOG_ABSOLUTE_MAX; 
+    return (FSEv06_DTable*)malloc( FSEv06_DTABLE_SIZE_U32(tableLog) * sizeof (U32) ); 
+} 
+ 
+void FSEv06_freeDTable (FSEv06_DTable* dt) 
+{ 
+    free(dt); 
+} 
+ 
+size_t FSEv06_buildDTable(FSEv06_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) 
+{ 
+    void* const tdPtr = dt+1;   /* because *dt is unsigned, 32-bits aligned on 32-bits */ 
+    FSEv06_DECODE_TYPE* const tableDecode = (FSEv06_DECODE_TYPE*) (tdPtr); 
+    U16 symbolNext[FSEv06_MAX_SYMBOL_VALUE+1]; 
+ 
+    U32 const maxSV1 = maxSymbolValue + 1; 
+    U32 const tableSize = 1 << tableLog; 
+    U32 highThreshold = tableSize-1; 
+ 
+    /* Sanity Checks */ 
+    if (maxSymbolValue > FSEv06_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge); 
+    if (tableLog > FSEv06_MAX_TABLELOG) return ERROR(tableLog_tooLarge); 
+ 
+    /* Init, lay down lowprob symbols */ 
+    {   FSEv06_DTableHeader DTableH; 
+        DTableH.tableLog = (U16)tableLog; 
+        DTableH.fastMode = 1; 
+        {   S16 const largeLimit= (S16)(1 << (tableLog-1)); 
+            U32 s; 
+            for (s=0; s<maxSV1; s++) { 
+                if (normalizedCounter[s]==-1) { 
+                    tableDecode[highThreshold--].symbol = (FSEv06_FUNCTION_TYPE)s; 
+                    symbolNext[s] = 1; 
+                } else { 
+                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0; 
+                    symbolNext[s] = normalizedCounter[s]; 
+        }   }   } 
+        memcpy(dt, &DTableH, sizeof(DTableH)); 
+    } 
+ 
+    /* Spread symbols */ 
+    {   U32 const tableMask = tableSize-1; 
+        U32 const step = FSEv06_TABLESTEP(tableSize); 
+        U32 s, position = 0; 
+        for (s=0; s<maxSV1; s++) { 
+            int i; 
+            for (i=0; i<normalizedCounter[s]; i++) { 
+                tableDecode[position].symbol = (FSEv06_FUNCTION_TYPE)s; 
+                position = (position + step) & tableMask; 
+                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */ 
+        }   } 
+ 
+        if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */ 
+    } 
+ 
+    /* Build Decoding table */ 
+    {   U32 u; 
+        for (u=0; u<tableSize; u++) { 
+            FSEv06_FUNCTION_TYPE const symbol = (FSEv06_FUNCTION_TYPE)(tableDecode[u].symbol); 
+            U16 nextState = symbolNext[symbol]++; 
+            tableDecode[u].nbBits = (BYTE) (tableLog - BITv06_highbit32 ((U32)nextState) ); 
+            tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize); 
+    }   } 
+ 
+    return 0; 
+} 
+ 
+ 
+ 
+#ifndef FSEv06_COMMONDEFS_ONLY 
+ 
+/*-******************************************************* 
+*  Decompression (Byte symbols) 
+*********************************************************/ 
+size_t FSEv06_buildDTable_rle (FSEv06_DTable* dt, BYTE symbolValue) 
+{ 
+    void* ptr = dt; 
+    FSEv06_DTableHeader* const DTableH = (FSEv06_DTableHeader*)ptr; 
+    void* dPtr = dt + 1; 
+    FSEv06_decode_t* const cell = (FSEv06_decode_t*)dPtr; 
+ 
+    DTableH->tableLog = 0; 
+    DTableH->fastMode = 0; 
+ 
+    cell->newState = 0; 
+    cell->symbol = symbolValue; 
+    cell->nbBits = 0; 
+ 
+    return 0; 
+} 
+ 
+ 
+size_t FSEv06_buildDTable_raw (FSEv06_DTable* dt, unsigned nbBits) 
+{ 
+    void* ptr = dt; 
+    FSEv06_DTableHeader* const DTableH = (FSEv06_DTableHeader*)ptr; 
+    void* dPtr = dt + 1; 
+    FSEv06_decode_t* const dinfo = (FSEv06_decode_t*)dPtr; 
+    const unsigned tableSize = 1 << nbBits; 
+    const unsigned tableMask = tableSize - 1; 
+    const unsigned maxSV1 = tableMask+1; 
+    unsigned s; 
+ 
+    /* Sanity checks */ 
+    if (nbBits < 1) return ERROR(GENERIC);         /* min size */ 
+ 
+    /* Build Decoding Table */ 
+    DTableH->tableLog = (U16)nbBits; 
+    DTableH->fastMode = 1; 
+    for (s=0; s<maxSV1; s++) { 
+        dinfo[s].newState = 0; 
+        dinfo[s].symbol = (BYTE)s; 
+        dinfo[s].nbBits = (BYTE)nbBits; 
+    } 
+ 
+    return 0; 
+} 
+ 
+FORCE_INLINE size_t FSEv06_decompress_usingDTable_generic( 
+          void* dst, size_t maxDstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const FSEv06_DTable* dt, const unsigned fast) 
+{ 
+    BYTE* const ostart = (BYTE*) dst; 
+    BYTE* op = ostart; 
+    BYTE* const omax = op + maxDstSize; 
+    BYTE* const olimit = omax-3; 
+ 
+    BITv06_DStream_t bitD; 
+    FSEv06_DState_t state1; 
+    FSEv06_DState_t state2; 
+ 
+    /* Init */ 
+    { size_t const errorCode = BITv06_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */ 
+      if (FSEv06_isError(errorCode)) return errorCode; } 
+ 
+    FSEv06_initDState(&state1, &bitD, dt); 
+    FSEv06_initDState(&state2, &bitD, dt); 
+ 
+#define FSEv06_GETSYMBOL(statePtr) fast ? FSEv06_decodeSymbolFast(statePtr, &bitD) : FSEv06_decodeSymbol(statePtr, &bitD) 
+ 
+    /* 4 symbols per loop */ 
+    for ( ; (BITv06_reloadDStream(&bitD)==BITv06_DStream_unfinished) && (op<olimit) ; op+=4) { 
+        op[0] = FSEv06_GETSYMBOL(&state1); 
+ 
+        if (FSEv06_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            BITv06_reloadDStream(&bitD); 
+ 
+        op[1] = FSEv06_GETSYMBOL(&state2); 
+ 
+        if (FSEv06_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            { if (BITv06_reloadDStream(&bitD) > BITv06_DStream_unfinished) { op+=2; break; } } 
+ 
+        op[2] = FSEv06_GETSYMBOL(&state1); 
+ 
+        if (FSEv06_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            BITv06_reloadDStream(&bitD); 
+ 
+        op[3] = FSEv06_GETSYMBOL(&state2); 
+    } 
+ 
+    /* tail */ 
+    /* note : BITv06_reloadDStream(&bitD) >= FSEv06_DStream_partiallyFilled; Ends at exactly BITv06_DStream_completed */ 
+    while (1) { 
+        if (op>(omax-2)) return ERROR(dstSize_tooSmall); 
+ 
+        *op++ = FSEv06_GETSYMBOL(&state1); 
+ 
+        if (BITv06_reloadDStream(&bitD)==BITv06_DStream_overflow) { 
+            *op++ = FSEv06_GETSYMBOL(&state2); 
+            break; 
+        } 
+ 
+        if (op>(omax-2)) return ERROR(dstSize_tooSmall); 
+ 
+        *op++ = FSEv06_GETSYMBOL(&state2); 
+ 
+        if (BITv06_reloadDStream(&bitD)==BITv06_DStream_overflow) { 
+            *op++ = FSEv06_GETSYMBOL(&state1); 
+            break; 
+    }   } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+size_t FSEv06_decompress_usingDTable(void* dst, size_t originalSize, 
+                            const void* cSrc, size_t cSrcSize, 
+                            const FSEv06_DTable* dt) 
+{ 
+    const void* ptr = dt; 
+    const FSEv06_DTableHeader* DTableH = (const FSEv06_DTableHeader*)ptr; 
+    const U32 fastMode = DTableH->fastMode; 
+ 
+    /* select fast mode (static) */ 
+    if (fastMode) return FSEv06_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1); 
+    return FSEv06_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0); 
+} 
+ 
+ 
+size_t FSEv06_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[FSEv06_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 = FSEv06_MAX_SYMBOL_VALUE; 
+ 
+    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */ 
+ 
+    /* normal FSE decoding mode */ 
+    {   size_t const NCountLength = FSEv06_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize); 
+        if (FSEv06_isError(NCountLength)) return NCountLength; 
+        if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */ 
+        ip += NCountLength; 
+        cSrcSize -= NCountLength; 
+    } 
+ 
+    { size_t const errorCode = FSEv06_buildDTable (dt, counting, maxSymbolValue, tableLog); 
+      if (FSEv06_isError(errorCode)) return errorCode; } 
+ 
+    return FSEv06_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);   /* always return, even if it is an error code */ 
+} 
+ 
+ 
+ 
+#endif   /* FSEv06_COMMONDEFS_ONLY */ 
+/* ****************************************************************** 
+   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 HUFv06_H 
+#define HUFv06_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* **************************************** 
+*  HUF simple functions 
+******************************************/ 
+size_t HUFv06_decompress(void* dst,  size_t dstSize, 
+                const void* cSrc, size_t cSrcSize); 
+/* 
+HUFv06_decompress() : 
+    Decompress HUF data from buffer 'cSrc', of size 'cSrcSize', 
+    into already allocated destination buffer 'dst', of size 'dstSize'. 
+    `dstSize` : must be the **exact** size of original (uncompressed) data. 
+    Note : in contrast with FSE, HUFv06_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 HUFv06_isError() 
+*/ 
+ 
+ 
+/* **************************************** 
+*  Tool functions 
+******************************************/ 
+size_t HUFv06_compressBound(size_t size);       /**< maximum compressed size */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif   /* HUFv06_H */ 
+/* ****************************************************************** 
+   Huffman codec, part of New Generation Entropy library 
+   header file, for static linking only 
+   Copyright (C) 2013-2016, Yann Collet 
+ 
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+   Redistribution and use in source and binary forms, with or without 
+   modification, are permitted provided that the following conditions are 
+   met: 
+ 
+       * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer. 
+       * Redistributions in binary form must reproduce the above 
+   copyright notice, this list of conditions and the following disclaimer 
+   in the documentation and/or other materials provided with the 
+   distribution. 
+ 
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+   You can contact the author at : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+****************************************************************** */ 
+#ifndef HUFv06_STATIC_H 
+#define HUFv06_STATIC_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+/* **************************************** 
+*  Static allocation 
+******************************************/ 
+/* HUF buffer bounds */ 
+#define HUFv06_CTABLEBOUND 129 
+#define HUFv06_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true if incompressible pre-filtered with fast heuristic */ 
+#define HUFv06_COMPRESSBOUND(size) (HUFv06_CTABLEBOUND + HUFv06_BLOCKBOUND(size))   /* Macro version, useful for static allocation */ 
+ 
+/* static allocation of HUF's DTable */ 
+#define HUFv06_DTABLE_SIZE(maxTableLog)   (1 + (1<<maxTableLog)) 
+#define HUFv06_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \ 
+        unsigned short DTable[HUFv06_DTABLE_SIZE(maxTableLog)] = { maxTableLog } 
+#define HUFv06_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \ 
+        unsigned int DTable[HUFv06_DTABLE_SIZE(maxTableLog)] = { maxTableLog } 
+#define HUFv06_CREATE_STATIC_DTABLEX6(DTable, maxTableLog) \ 
+        unsigned int DTable[HUFv06_DTABLE_SIZE(maxTableLog) * 3 / 2] = { maxTableLog } 
+ 
+ 
+/* **************************************** 
+*  Advanced decompression functions 
+******************************************/ 
+size_t HUFv06_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */ 
+size_t HUFv06_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbols decoder */ 
+ 
+ 
+ 
+/*! 
+HUFv06_decompress() does the following: 
+1. select the decompression algorithm (X2, X4, X6) based on pre-computed heuristics 
+2. build Huffman table from save, using HUFv06_readDTableXn() 
+3. decode 1 or 4 segments in parallel using HUFv06_decompressSXn_usingDTable 
+*/ 
+size_t HUFv06_readDTableX2 (unsigned short* DTable, const void* src, size_t srcSize); 
+size_t HUFv06_readDTableX4 (unsigned* DTable, const void* src, size_t srcSize); 
+ 
+size_t HUFv06_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable); 
+size_t HUFv06_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable); 
+ 
+ 
+/* single stream variants */ 
+size_t HUFv06_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */ 
+size_t HUFv06_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */ 
+ 
+size_t HUFv06_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned short* DTable); 
+size_t HUFv06_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const unsigned* DTable); 
+ 
+ 
+ 
+/* ************************************************************** 
+*  Constants 
+****************************************************************/ 
+#define HUFv06_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUFv06_MAX_TABLELOG. Beyond that value, code does not work */ 
+#define HUFv06_MAX_TABLELOG  12           /* max configured tableLog (for static allocation); can be modified up to HUFv06_ABSOLUTEMAX_TABLELOG */ 
+#define HUFv06_DEFAULT_TABLELOG  HUFv06_MAX_TABLELOG   /* tableLog by default, when not specified */ 
+#define HUFv06_MAX_SYMBOL_VALUE 255 
+#if (HUFv06_MAX_TABLELOG > HUFv06_ABSOLUTEMAX_TABLELOG) 
+#  error "HUFv06_MAX_TABLELOG is too large !" 
+#endif 
+ 
+ 
+ 
+/*! HUFv06_readStats() : 
+    Read compact Huffman tree, saved by HUFv06_writeCTable(). 
+    `huffWeight` is destination buffer. 
+    @return : size read from `src` 
+*/ 
+MEM_STATIC size_t HUFv06_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats, 
+                            U32* nbSymbolsPtr, U32* tableLogPtr, 
+                            const void* src, size_t srcSize) 
+{ 
+    U32 weightTotal; 
+    const BYTE* ip = (const BYTE*) src; 
     size_t iSize;
-    size_t oSize;
-
+    size_t oSize; 
+ 
     if (!srcSize) return ERROR(srcSize_wrong);
     iSize = ip[0];
     /* memset(huffWeight, 0, hwSize); */   /* is not necessary, even though some analyzer complain ... */
-
-    if (iSize >= 128)  { /* special header */
-        if (iSize >= (242)) {  /* RLE */
-            static U32 l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };
-            oSize = l[iSize-242];
-            memset(huffWeight, 1, hwSize);
-            iSize = 0;
-        }
-        else {   /* Incompressible */
-            oSize = iSize - 127;
-            iSize = ((oSize+1)/2);
-            if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
-            if (oSize >= hwSize) return ERROR(corruption_detected);
-            ip += 1;
-            {   U32 n;
-                for (n=0; n<oSize; n+=2) {
-                    huffWeight[n]   = ip[n/2] >> 4;
-                    huffWeight[n+1] = ip[n/2] & 15;
-    }   }   }   }
-    else  {   /* header compressed with FSE (normal case) */
-        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
-        oSize = FSEv06_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */
-        if (FSEv06_isError(oSize)) return oSize;
-    }
-
-    /* collect weight stats */
-    memset(rankStats, 0, (HUFv06_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32));
-    weightTotal = 0;
-    {   U32 n; for (n=0; n<oSize; n++) {
-            if (huffWeight[n] >= HUFv06_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
-            rankStats[huffWeight[n]]++;
-            weightTotal += (1 << huffWeight[n]) >> 1;
-    }   }
+ 
+    if (iSize >= 128)  { /* special header */ 
+        if (iSize >= (242)) {  /* RLE */ 
+            static U32 l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 }; 
+            oSize = l[iSize-242]; 
+            memset(huffWeight, 1, hwSize); 
+            iSize = 0; 
+        } 
+        else {   /* Incompressible */ 
+            oSize = iSize - 127; 
+            iSize = ((oSize+1)/2); 
+            if (iSize+1 > srcSize) return ERROR(srcSize_wrong); 
+            if (oSize >= hwSize) return ERROR(corruption_detected); 
+            ip += 1; 
+            {   U32 n; 
+                for (n=0; n<oSize; n+=2) { 
+                    huffWeight[n]   = ip[n/2] >> 4; 
+                    huffWeight[n+1] = ip[n/2] & 15; 
+    }   }   }   } 
+    else  {   /* header compressed with FSE (normal case) */ 
+        if (iSize+1 > srcSize) return ERROR(srcSize_wrong); 
+        oSize = FSEv06_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */ 
+        if (FSEv06_isError(oSize)) return oSize; 
+    } 
+ 
+    /* collect weight stats */ 
+    memset(rankStats, 0, (HUFv06_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32)); 
+    weightTotal = 0; 
+    {   U32 n; for (n=0; n<oSize; n++) { 
+            if (huffWeight[n] >= HUFv06_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected); 
+            rankStats[huffWeight[n]]++; 
+            weightTotal += (1 << huffWeight[n]) >> 1; 
+    }   } 
     if (weightTotal == 0) return ERROR(corruption_detected);
-
-    /* get last non-null symbol weight (implied, total must be 2^n) */
-    {   U32 const tableLog = BITv06_highbit32(weightTotal) + 1;
-        if (tableLog > HUFv06_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);
-        *tableLogPtr = tableLog;
-        /* determine last weight */
-        {   U32 const total = 1 << tableLog;
-            U32 const rest = total - weightTotal;
-            U32 const verif = 1 << BITv06_highbit32(rest);
-            U32 const lastWeight = BITv06_highbit32(rest) + 1;
-            if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */
-            huffWeight[oSize] = (BYTE)lastWeight;
-            rankStats[lastWeight]++;
-    }   }
-
-    /* check tree construction validity */
-    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */
-
-    /* results */
-    *nbSymbolsPtr = (U32)(oSize+1);
-    return iSize+1;
-}
-
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* HUFv06_STATIC_H */
-/* ******************************************************************
-   Huffman decoder, part of New Generation Entropy library
-   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 :
-    - FSE+HUF 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 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#endif
-
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#define HUFv06_STATIC_ASSERT(c) { enum { HUFv06_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-
-
-
-/* *******************************************************
-*  HUF : Huffman block decompression
-*********************************************************/
-typedef struct { BYTE byte; BYTE nbBits; } HUFv06_DEltX2;   /* single-symbol decoding */
-
-typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUFv06_DEltX4;  /* double-symbols decoding */
-
-typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
-
-
-
-/*-***************************/
-/*  single-symbol decoding   */
-/*-***************************/
-
-size_t HUFv06_readDTableX2 (U16* DTable, const void* src, size_t srcSize)
-{
-    BYTE huffWeight[HUFv06_MAX_SYMBOL_VALUE + 1];
-    U32 rankVal[HUFv06_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;
-    HUFv06_DEltX2* const dt = (HUFv06_DEltX2*)dtPtr;
-
-    HUFv06_STATIC_ASSERT(sizeof(HUFv06_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */
+ 
+    /* get last non-null symbol weight (implied, total must be 2^n) */ 
+    {   U32 const tableLog = BITv06_highbit32(weightTotal) + 1; 
+        if (tableLog > HUFv06_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected); 
+        *tableLogPtr = tableLog; 
+        /* determine last weight */ 
+        {   U32 const total = 1 << tableLog; 
+            U32 const rest = total - weightTotal; 
+            U32 const verif = 1 << BITv06_highbit32(rest); 
+            U32 const lastWeight = BITv06_highbit32(rest) + 1; 
+            if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */ 
+            huffWeight[oSize] = (BYTE)lastWeight; 
+            rankStats[lastWeight]++; 
+    }   } 
+ 
+    /* check tree construction validity */ 
+    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */ 
+ 
+    /* results */ 
+    *nbSymbolsPtr = (U32)(oSize+1); 
+    return iSize+1; 
+} 
+ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* HUFv06_STATIC_H */ 
+/* ****************************************************************** 
+   Huffman decoder, part of New Generation Entropy library 
+   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 : 
+    - FSE+HUF 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 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#endif 
+ 
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#define HUFv06_STATIC_ASSERT(c) { enum { HUFv06_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */ 
+ 
+ 
+ 
+/* ******************************************************* 
+*  HUF : Huffman block decompression 
+*********************************************************/ 
+typedef struct { BYTE byte; BYTE nbBits; } HUFv06_DEltX2;   /* single-symbol decoding */ 
+ 
+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUFv06_DEltX4;  /* double-symbols decoding */ 
+ 
+typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t; 
+ 
+ 
+ 
+/*-***************************/ 
+/*  single-symbol decoding   */ 
+/*-***************************/ 
+ 
+size_t HUFv06_readDTableX2 (U16* DTable, const void* src, size_t srcSize) 
+{ 
+    BYTE huffWeight[HUFv06_MAX_SYMBOL_VALUE + 1]; 
+    U32 rankVal[HUFv06_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; 
+    HUFv06_DEltX2* const dt = (HUFv06_DEltX2*)dtPtr; 
+ 
+    HUFv06_STATIC_ASSERT(sizeof(HUFv06_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */ 
     /* memset(huffWeight, 0, sizeof(huffWeight)); */   /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUFv06_readStats(huffWeight, HUFv06_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
-    if (HUFv06_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+1; 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;
-        HUFv06_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 HUFv06_decodeSymbolX2(BITv06_DStream_t* Dstream, const HUFv06_DEltX2* dt, const U32 dtLog)
-{
-    const size_t val = BITv06_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
-    const BYTE c = dt[val].byte;
-    BITv06_skipBits(Dstream, dt[val].nbBits);
-    return c;
-}
-
-#define HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
-    *ptr++ = HUFv06_decodeSymbolX2(DStreamPtr, dt, dtLog)
-
-#define HUFv06_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
-    if (MEM_64bits() || (HUFv06_MAX_TABLELOG<=12)) \
-        HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
-
-#define HUFv06_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
-    if (MEM_64bits()) \
-        HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
-
-static inline size_t HUFv06_decodeStreamX2(BYTE* p, BITv06_DStream_t* const bitDPtr, BYTE* const pEnd, const HUFv06_DEltX2* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 4 symbols at a time */
-    while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p <= pEnd-4)) {
-        HUFv06_DECODE_SYMBOLX2_2(p, bitDPtr);
-        HUFv06_DECODE_SYMBOLX2_1(p, bitDPtr);
-        HUFv06_DECODE_SYMBOLX2_2(p, bitDPtr);
-        HUFv06_DECODE_SYMBOLX2_0(p, bitDPtr);
-    }
-
-    /* closer to the end */
-    while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p < pEnd))
-        HUFv06_DECODE_SYMBOLX2_0(p, bitDPtr);
-
-    /* no more data to retrieve from bitstream, hence no need to reload */
-    while (p < pEnd)
-        HUFv06_DECODE_SYMBOLX2_0(p, bitDPtr);
-
-    return pEnd-pStart;
-}
-
-size_t HUFv06_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;
-    const U32 dtLog = DTable[0];
-    const void* dtPtr = DTable;
-    const HUFv06_DEltX2* const dt = ((const HUFv06_DEltX2*)dtPtr)+1;
-    BITv06_DStream_t bitD;
-
-    { size_t const errorCode = BITv06_initDStream(&bitD, cSrc, cSrcSize);
-      if (HUFv06_isError(errorCode)) return errorCode; }
-
-    HUFv06_decodeStreamX2(op, &bitD, oend, dt, dtLog);
-
-    /* check */
-    if (!BITv06_endOfDStream(&bitD)) return ERROR(corruption_detected);
-
-    return dstSize;
-}
-
-size_t HUFv06_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUFv06_CREATE_STATIC_DTABLEX2(DTable, HUFv06_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t const errorCode = HUFv06_readDTableX2 (DTable, cSrc, cSrcSize);
-    if (HUFv06_isError(errorCode)) return errorCode;
-    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += errorCode;
-    cSrcSize -= errorCode;
-
-    return HUFv06_decompress1X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
-}
-
-
-size_t HUFv06_decompress4X2_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const U16* DTable)
-{
-    /* Check */
-    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 HUFv06_DEltX2* const dt = ((const HUFv06_DEltX2*)dtPtr) +1;
-        const U32 dtLog = DTable[0];
-        size_t errorCode;
-
-        /* Init */
-        BITv06_DStream_t bitD1;
-        BITv06_DStream_t bitD2;
-        BITv06_DStream_t bitD3;
-        BITv06_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 = BITv06_initDStream(&bitD1, istart1, length1);
-        if (HUFv06_isError(errorCode)) return errorCode;
-        errorCode = BITv06_initDStream(&bitD2, istart2, length2);
-        if (HUFv06_isError(errorCode)) return errorCode;
-        errorCode = BITv06_initDStream(&bitD3, istart3, length3);
-        if (HUFv06_isError(errorCode)) return errorCode;
-        errorCode = BITv06_initDStream(&bitD4, istart4, length4);
-        if (HUFv06_isError(errorCode)) return errorCode;
-
-        /* 16-32 symbols per loop (4-8 symbols per stream) */
-        endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_reloadDStream(&bitD4);
-        for ( ; (endSignal==BITv06_DStream_unfinished) && (op4<(oend-7)) ; ) {
-            HUFv06_DECODE_SYMBOLX2_2(op1, &bitD1);
-            HUFv06_DECODE_SYMBOLX2_2(op2, &bitD2);
-            HUFv06_DECODE_SYMBOLX2_2(op3, &bitD3);
-            HUFv06_DECODE_SYMBOLX2_2(op4, &bitD4);
-            HUFv06_DECODE_SYMBOLX2_1(op1, &bitD1);
-            HUFv06_DECODE_SYMBOLX2_1(op2, &bitD2);
-            HUFv06_DECODE_SYMBOLX2_1(op3, &bitD3);
-            HUFv06_DECODE_SYMBOLX2_1(op4, &bitD4);
-            HUFv06_DECODE_SYMBOLX2_2(op1, &bitD1);
-            HUFv06_DECODE_SYMBOLX2_2(op2, &bitD2);
-            HUFv06_DECODE_SYMBOLX2_2(op3, &bitD3);
-            HUFv06_DECODE_SYMBOLX2_2(op4, &bitD4);
-            HUFv06_DECODE_SYMBOLX2_0(op1, &bitD1);
-            HUFv06_DECODE_SYMBOLX2_0(op2, &bitD2);
-            HUFv06_DECODE_SYMBOLX2_0(op3, &bitD3);
-            HUFv06_DECODE_SYMBOLX2_0(op4, &bitD4);
-            endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_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 */
-        HUFv06_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
-        HUFv06_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
-        HUFv06_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
-        HUFv06_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
-
-        /* check */
-        endSignal = BITv06_endOfDStream(&bitD1) & BITv06_endOfDStream(&bitD2) & BITv06_endOfDStream(&bitD3) & BITv06_endOfDStream(&bitD4);
-        if (!endSignal) return ERROR(corruption_detected);
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
-
-size_t HUFv06_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUFv06_CREATE_STATIC_DTABLEX2(DTable, HUFv06_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t const errorCode = HUFv06_readDTableX2 (DTable, cSrc, cSrcSize);
-    if (HUFv06_isError(errorCode)) return errorCode;
-    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += errorCode;
-    cSrcSize -= errorCode;
-
-    return HUFv06_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
-}
-
-
-/* *************************/
-/* double-symbols decoding */
-/* *************************/
-
-static void HUFv06_fillDTableX4Level2(HUFv06_DEltX4* DTable, U32 sizeLog, const U32 consumed,
-                           const U32* rankValOrigin, const int minWeight,
-                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
-                           U32 nbBitsBaseline, U16 baseSeq)
-{
-    HUFv06_DEltX4 DElt;
-    U32 rankVal[HUFv06_ABSOLUTEMAX_TABLELOG + 1];
-
-    /* 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 */
-    { U32 s; 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[HUFv06_ABSOLUTEMAX_TABLELOG][HUFv06_ABSOLUTEMAX_TABLELOG + 1];
-
-static void HUFv06_fillDTableX4(HUFv06_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[HUFv06_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];
-            HUFv06_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,
-                           rankValOrigin[nbBits], minWeight,
-                           sortedList+sortedRank, sortedListSize-sortedRank,
-                           nbBitsBaseline, symbol);
-        } else {
-            HUFv06_DEltX4 DElt;
-            MEM_writeLE16(&(DElt.sequence), symbol);
-            DElt.nbBits = (BYTE)(nbBits);
-            DElt.length = 1;
-            {   U32 u;
-                const U32 end = start + length;
-                for (u = start; u < end; u++) DTable[u] = DElt;
-        }   }
-        rankVal[weight] += length;
-    }
-}
-
-size_t HUFv06_readDTableX4 (U32* DTable, const void* src, size_t srcSize)
-{
-    BYTE weightList[HUFv06_MAX_SYMBOL_VALUE + 1];
-    sortedSymbol_t sortedSymbol[HUFv06_MAX_SYMBOL_VALUE + 1];
-    U32 rankStats[HUFv06_ABSOLUTEMAX_TABLELOG + 1] = { 0 };
-    U32 rankStart0[HUFv06_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;
-    HUFv06_DEltX4* const dt = ((HUFv06_DEltX4*)dtPtr) + 1;
-
-    HUFv06_STATIC_ASSERT(sizeof(HUFv06_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */
-    if (memLog > HUFv06_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);
+ 
+    iSize = HUFv06_readStats(huffWeight, HUFv06_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize); 
+    if (HUFv06_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+1; 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; 
+        HUFv06_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 HUFv06_decodeSymbolX2(BITv06_DStream_t* Dstream, const HUFv06_DEltX2* dt, const U32 dtLog) 
+{ 
+    const size_t val = BITv06_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */ 
+    const BYTE c = dt[val].byte; 
+    BITv06_skipBits(Dstream, dt[val].nbBits); 
+    return c; 
+} 
+ 
+#define HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \ 
+    *ptr++ = HUFv06_decodeSymbolX2(DStreamPtr, dt, dtLog) 
+ 
+#define HUFv06_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \ 
+    if (MEM_64bits() || (HUFv06_MAX_TABLELOG<=12)) \ 
+        HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr) 
+ 
+#define HUFv06_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \ 
+    if (MEM_64bits()) \ 
+        HUFv06_DECODE_SYMBOLX2_0(ptr, DStreamPtr) 
+ 
+static inline size_t HUFv06_decodeStreamX2(BYTE* p, BITv06_DStream_t* const bitDPtr, BYTE* const pEnd, const HUFv06_DEltX2* const dt, const U32 dtLog) 
+{ 
+    BYTE* const pStart = p; 
+ 
+    /* up to 4 symbols at a time */ 
+    while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p <= pEnd-4)) { 
+        HUFv06_DECODE_SYMBOLX2_2(p, bitDPtr); 
+        HUFv06_DECODE_SYMBOLX2_1(p, bitDPtr); 
+        HUFv06_DECODE_SYMBOLX2_2(p, bitDPtr); 
+        HUFv06_DECODE_SYMBOLX2_0(p, bitDPtr); 
+    } 
+ 
+    /* closer to the end */ 
+    while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p < pEnd)) 
+        HUFv06_DECODE_SYMBOLX2_0(p, bitDPtr); 
+ 
+    /* no more data to retrieve from bitstream, hence no need to reload */ 
+    while (p < pEnd) 
+        HUFv06_DECODE_SYMBOLX2_0(p, bitDPtr); 
+ 
+    return pEnd-pStart; 
+} 
+ 
+size_t HUFv06_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; 
+    const U32 dtLog = DTable[0]; 
+    const void* dtPtr = DTable; 
+    const HUFv06_DEltX2* const dt = ((const HUFv06_DEltX2*)dtPtr)+1; 
+    BITv06_DStream_t bitD; 
+ 
+    { size_t const errorCode = BITv06_initDStream(&bitD, cSrc, cSrcSize); 
+      if (HUFv06_isError(errorCode)) return errorCode; } 
+ 
+    HUFv06_decodeStreamX2(op, &bitD, oend, dt, dtLog); 
+ 
+    /* check */ 
+    if (!BITv06_endOfDStream(&bitD)) return ERROR(corruption_detected); 
+ 
+    return dstSize; 
+} 
+ 
+size_t HUFv06_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUFv06_CREATE_STATIC_DTABLEX2(DTable, HUFv06_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
+    size_t const errorCode = HUFv06_readDTableX2 (DTable, cSrc, cSrcSize); 
+    if (HUFv06_isError(errorCode)) return errorCode; 
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += errorCode; 
+    cSrcSize -= errorCode; 
+ 
+    return HUFv06_decompress1X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable); 
+} 
+ 
+ 
+size_t HUFv06_decompress4X2_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const U16* DTable) 
+{ 
+    /* Check */ 
+    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 HUFv06_DEltX2* const dt = ((const HUFv06_DEltX2*)dtPtr) +1; 
+        const U32 dtLog = DTable[0]; 
+        size_t errorCode; 
+ 
+        /* Init */ 
+        BITv06_DStream_t bitD1; 
+        BITv06_DStream_t bitD2; 
+        BITv06_DStream_t bitD3; 
+        BITv06_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 = BITv06_initDStream(&bitD1, istart1, length1); 
+        if (HUFv06_isError(errorCode)) return errorCode; 
+        errorCode = BITv06_initDStream(&bitD2, istart2, length2); 
+        if (HUFv06_isError(errorCode)) return errorCode; 
+        errorCode = BITv06_initDStream(&bitD3, istart3, length3); 
+        if (HUFv06_isError(errorCode)) return errorCode; 
+        errorCode = BITv06_initDStream(&bitD4, istart4, length4); 
+        if (HUFv06_isError(errorCode)) return errorCode; 
+ 
+        /* 16-32 symbols per loop (4-8 symbols per stream) */ 
+        endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_reloadDStream(&bitD4); 
+        for ( ; (endSignal==BITv06_DStream_unfinished) && (op4<(oend-7)) ; ) { 
+            HUFv06_DECODE_SYMBOLX2_2(op1, &bitD1); 
+            HUFv06_DECODE_SYMBOLX2_2(op2, &bitD2); 
+            HUFv06_DECODE_SYMBOLX2_2(op3, &bitD3); 
+            HUFv06_DECODE_SYMBOLX2_2(op4, &bitD4); 
+            HUFv06_DECODE_SYMBOLX2_1(op1, &bitD1); 
+            HUFv06_DECODE_SYMBOLX2_1(op2, &bitD2); 
+            HUFv06_DECODE_SYMBOLX2_1(op3, &bitD3); 
+            HUFv06_DECODE_SYMBOLX2_1(op4, &bitD4); 
+            HUFv06_DECODE_SYMBOLX2_2(op1, &bitD1); 
+            HUFv06_DECODE_SYMBOLX2_2(op2, &bitD2); 
+            HUFv06_DECODE_SYMBOLX2_2(op3, &bitD3); 
+            HUFv06_DECODE_SYMBOLX2_2(op4, &bitD4); 
+            HUFv06_DECODE_SYMBOLX2_0(op1, &bitD1); 
+            HUFv06_DECODE_SYMBOLX2_0(op2, &bitD2); 
+            HUFv06_DECODE_SYMBOLX2_0(op3, &bitD3); 
+            HUFv06_DECODE_SYMBOLX2_0(op4, &bitD4); 
+            endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_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 */ 
+        HUFv06_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog); 
+        HUFv06_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog); 
+        HUFv06_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog); 
+        HUFv06_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog); 
+ 
+        /* check */ 
+        endSignal = BITv06_endOfDStream(&bitD1) & BITv06_endOfDStream(&bitD2) & BITv06_endOfDStream(&bitD3) & BITv06_endOfDStream(&bitD4); 
+        if (!endSignal) return ERROR(corruption_detected); 
+ 
+        /* decoded size */ 
+        return dstSize; 
+    } 
+} 
+ 
+ 
+size_t HUFv06_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUFv06_CREATE_STATIC_DTABLEX2(DTable, HUFv06_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
+    size_t const errorCode = HUFv06_readDTableX2 (DTable, cSrc, cSrcSize); 
+    if (HUFv06_isError(errorCode)) return errorCode; 
+    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += errorCode; 
+    cSrcSize -= errorCode; 
+ 
+    return HUFv06_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable); 
+} 
+ 
+ 
+/* *************************/ 
+/* double-symbols decoding */ 
+/* *************************/ 
+ 
+static void HUFv06_fillDTableX4Level2(HUFv06_DEltX4* DTable, U32 sizeLog, const U32 consumed, 
+                           const U32* rankValOrigin, const int minWeight, 
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize, 
+                           U32 nbBitsBaseline, U16 baseSeq) 
+{ 
+    HUFv06_DEltX4 DElt; 
+    U32 rankVal[HUFv06_ABSOLUTEMAX_TABLELOG + 1]; 
+ 
+    /* 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 */ 
+    { U32 s; 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[HUFv06_ABSOLUTEMAX_TABLELOG][HUFv06_ABSOLUTEMAX_TABLELOG + 1]; 
+ 
+static void HUFv06_fillDTableX4(HUFv06_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[HUFv06_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]; 
+            HUFv06_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits, 
+                           rankValOrigin[nbBits], minWeight, 
+                           sortedList+sortedRank, sortedListSize-sortedRank, 
+                           nbBitsBaseline, symbol); 
+        } else { 
+            HUFv06_DEltX4 DElt; 
+            MEM_writeLE16(&(DElt.sequence), symbol); 
+            DElt.nbBits = (BYTE)(nbBits); 
+            DElt.length = 1; 
+            {   U32 u; 
+                const U32 end = start + length; 
+                for (u = start; u < end; u++) DTable[u] = DElt; 
+        }   } 
+        rankVal[weight] += length; 
+    } 
+} 
+ 
+size_t HUFv06_readDTableX4 (U32* DTable, const void* src, size_t srcSize) 
+{ 
+    BYTE weightList[HUFv06_MAX_SYMBOL_VALUE + 1]; 
+    sortedSymbol_t sortedSymbol[HUFv06_MAX_SYMBOL_VALUE + 1]; 
+    U32 rankStats[HUFv06_ABSOLUTEMAX_TABLELOG + 1] = { 0 }; 
+    U32 rankStart0[HUFv06_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; 
+    HUFv06_DEltX4* const dt = ((HUFv06_DEltX4*)dtPtr) + 1; 
+ 
+    HUFv06_STATIC_ASSERT(sizeof(HUFv06_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */ 
+    if (memLog > HUFv06_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge); 
     /* memset(weightList, 0, sizeof(weightList)); */   /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUFv06_readStats(weightList, HUFv06_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
-    if (HUFv06_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+1; 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 const w = weightList[s];
-            U32 const 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 */
-    {   U32* const rankVal0 = rankVal[0];
-        {   int const rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */
-            U32 nextRankVal = 0;
-            U32 w;
-            for (w=1; w<maxW+1; w++) {
-                U32 current = nextRankVal;
-                nextRankVal += rankStats[w] << (w+rescale);
-                rankVal0[w] = current;
-        }   }
-        {   U32 const minBits = tableLog+1 - maxW;
-            U32 consumed;
-            for (consumed = minBits; consumed < memLog - minBits + 1; consumed++) {
-                U32* const rankValPtr = rankVal[consumed];
-                U32 w;
-                for (w = 1; w < maxW+1; w++) {
-                    rankValPtr[w] = rankVal0[w] >> consumed;
-    }   }   }   }
-
-    HUFv06_fillDTableX4(dt, memLog,
-                   sortedSymbol, sizeOfSort,
-                   rankStart0, rankVal, maxW,
-                   tableLog+1);
-
-    return iSize;
-}
-
-
-static U32 HUFv06_decodeSymbolX4(void* op, BITv06_DStream_t* DStream, const HUFv06_DEltX4* dt, const U32 dtLog)
-{
-    const size_t val = BITv06_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    memcpy(op, dt+val, 2);
-    BITv06_skipBits(DStream, dt[val].nbBits);
-    return dt[val].length;
-}
-
-static U32 HUFv06_decodeLastSymbolX4(void* op, BITv06_DStream_t* DStream, const HUFv06_DEltX4* dt, const U32 dtLog)
-{
-    const size_t val = BITv06_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    memcpy(op, dt+val, 1);
-    if (dt[val].length==1) BITv06_skipBits(DStream, dt[val].nbBits);
-    else {
-        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {
-            BITv06_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 HUFv06_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \
-    ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-#define HUFv06_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \
-    if (MEM_64bits() || (HUFv06_MAX_TABLELOG<=12)) \
-        ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-#define HUFv06_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \
-    if (MEM_64bits()) \
-        ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-static inline size_t HUFv06_decodeStreamX4(BYTE* p, BITv06_DStream_t* bitDPtr, BYTE* const pEnd, const HUFv06_DEltX4* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 8 symbols at a time */
-    while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p < pEnd-7)) {
-        HUFv06_DECODE_SYMBOLX4_2(p, bitDPtr);
-        HUFv06_DECODE_SYMBOLX4_1(p, bitDPtr);
-        HUFv06_DECODE_SYMBOLX4_2(p, bitDPtr);
-        HUFv06_DECODE_SYMBOLX4_0(p, bitDPtr);
-    }
-
-    /* closer to the end */
-    while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p <= pEnd-2))
-        HUFv06_DECODE_SYMBOLX4_0(p, bitDPtr);
-
-    while (p <= pEnd-2)
-        HUFv06_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
-
-    if (p < pEnd)
-        p += HUFv06_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);
-
-    return p-pStart;
-}
-
-
-size_t HUFv06_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 HUFv06_DEltX4* const dt = ((const HUFv06_DEltX4*)dtPtr) +1;
-
-    /* Init */
-    BITv06_DStream_t bitD;
-    { size_t const errorCode = BITv06_initDStream(&bitD, istart, cSrcSize);
-      if (HUFv06_isError(errorCode)) return errorCode; }
-
-    /* decode */
-    HUFv06_decodeStreamX4(ostart, &bitD, oend, dt, dtLog);
-
-    /* check */
-    if (!BITv06_endOfDStream(&bitD)) return ERROR(corruption_detected);
-
-    /* decoded size */
-    return dstSize;
-}
-
-size_t HUFv06_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUFv06_CREATE_STATIC_DTABLEX4(DTable, HUFv06_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t const hSize = HUFv06_readDTableX4 (DTable, cSrc, cSrcSize);
-    if (HUFv06_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize;
-    cSrcSize -= hSize;
-
-    return HUFv06_decompress1X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);
-}
-
-size_t HUFv06_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 HUFv06_DEltX4* const dt = ((const HUFv06_DEltX4*)dtPtr) +1;
-        const U32 dtLog = DTable[0];
-        size_t errorCode;
-
-        /* Init */
-        BITv06_DStream_t bitD1;
-        BITv06_DStream_t bitD2;
-        BITv06_DStream_t bitD3;
-        BITv06_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 = BITv06_initDStream(&bitD1, istart1, length1);
-        if (HUFv06_isError(errorCode)) return errorCode;
-        errorCode = BITv06_initDStream(&bitD2, istart2, length2);
-        if (HUFv06_isError(errorCode)) return errorCode;
-        errorCode = BITv06_initDStream(&bitD3, istart3, length3);
-        if (HUFv06_isError(errorCode)) return errorCode;
-        errorCode = BITv06_initDStream(&bitD4, istart4, length4);
-        if (HUFv06_isError(errorCode)) return errorCode;
-
-        /* 16-32 symbols per loop (4-8 symbols per stream) */
-        endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_reloadDStream(&bitD4);
-        for ( ; (endSignal==BITv06_DStream_unfinished) && (op4<(oend-7)) ; ) {
-            HUFv06_DECODE_SYMBOLX4_2(op1, &bitD1);
-            HUFv06_DECODE_SYMBOLX4_2(op2, &bitD2);
-            HUFv06_DECODE_SYMBOLX4_2(op3, &bitD3);
-            HUFv06_DECODE_SYMBOLX4_2(op4, &bitD4);
-            HUFv06_DECODE_SYMBOLX4_1(op1, &bitD1);
-            HUFv06_DECODE_SYMBOLX4_1(op2, &bitD2);
-            HUFv06_DECODE_SYMBOLX4_1(op3, &bitD3);
-            HUFv06_DECODE_SYMBOLX4_1(op4, &bitD4);
-            HUFv06_DECODE_SYMBOLX4_2(op1, &bitD1);
-            HUFv06_DECODE_SYMBOLX4_2(op2, &bitD2);
-            HUFv06_DECODE_SYMBOLX4_2(op3, &bitD3);
-            HUFv06_DECODE_SYMBOLX4_2(op4, &bitD4);
-            HUFv06_DECODE_SYMBOLX4_0(op1, &bitD1);
-            HUFv06_DECODE_SYMBOLX4_0(op2, &bitD2);
-            HUFv06_DECODE_SYMBOLX4_0(op3, &bitD3);
-            HUFv06_DECODE_SYMBOLX4_0(op4, &bitD4);
-
-            endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_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 */
-        HUFv06_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);
-        HUFv06_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);
-        HUFv06_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);
-        HUFv06_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog);
-
-        /* check */
-        endSignal = BITv06_endOfDStream(&bitD1) & BITv06_endOfDStream(&bitD2) & BITv06_endOfDStream(&bitD3) & BITv06_endOfDStream(&bitD4);
-        if (!endSignal) return ERROR(corruption_detected);
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
-
-size_t HUFv06_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUFv06_CREATE_STATIC_DTABLEX4(DTable, HUFv06_MAX_TABLELOG);
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t hSize = HUFv06_readDTableX4 (DTable, cSrc, cSrcSize);
-    if (HUFv06_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize;
-    cSrcSize -= hSize;
-
-    return HUFv06_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 HUFv06_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    static const decompressionAlgo decompress[3] = { HUFv06_decompress4X2, HUFv06_decompress4X4, NULL };
-    U32 Dtime[3];   /* decompression time estimation */
-
-    /* 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 */
-    {   U32 const Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */
-        U32 const D256 = (U32)(dstSize >> 8);
-        U32 n; 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 */
-
-    {   U32 algoNb = 0;
-        if (Dtime[1] < Dtime[0]) algoNb = 1;
+ 
+    iSize = HUFv06_readStats(weightList, HUFv06_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize); 
+    if (HUFv06_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+1; 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 const w = weightList[s]; 
+            U32 const 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 */ 
+    {   U32* const rankVal0 = rankVal[0]; 
+        {   int const rescale = (memLog-tableLog) - 1;   /* tableLog <= memLog */ 
+            U32 nextRankVal = 0; 
+            U32 w; 
+            for (w=1; w<maxW+1; w++) { 
+                U32 current = nextRankVal; 
+                nextRankVal += rankStats[w] << (w+rescale); 
+                rankVal0[w] = current; 
+        }   } 
+        {   U32 const minBits = tableLog+1 - maxW; 
+            U32 consumed; 
+            for (consumed = minBits; consumed < memLog - minBits + 1; consumed++) { 
+                U32* const rankValPtr = rankVal[consumed]; 
+                U32 w; 
+                for (w = 1; w < maxW+1; w++) { 
+                    rankValPtr[w] = rankVal0[w] >> consumed; 
+    }   }   }   } 
+ 
+    HUFv06_fillDTableX4(dt, memLog, 
+                   sortedSymbol, sizeOfSort, 
+                   rankStart0, rankVal, maxW, 
+                   tableLog+1); 
+ 
+    return iSize; 
+} 
+ 
+ 
+static U32 HUFv06_decodeSymbolX4(void* op, BITv06_DStream_t* DStream, const HUFv06_DEltX4* dt, const U32 dtLog) 
+{ 
+    const size_t val = BITv06_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    memcpy(op, dt+val, 2); 
+    BITv06_skipBits(DStream, dt[val].nbBits); 
+    return dt[val].length; 
+} 
+ 
+static U32 HUFv06_decodeLastSymbolX4(void* op, BITv06_DStream_t* DStream, const HUFv06_DEltX4* dt, const U32 dtLog) 
+{ 
+    const size_t val = BITv06_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    memcpy(op, dt+val, 1); 
+    if (dt[val].length==1) BITv06_skipBits(DStream, dt[val].nbBits); 
+    else { 
+        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) { 
+            BITv06_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 HUFv06_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \ 
+    ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+#define HUFv06_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \ 
+    if (MEM_64bits() || (HUFv06_MAX_TABLELOG<=12)) \ 
+        ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+#define HUFv06_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \ 
+    if (MEM_64bits()) \ 
+        ptr += HUFv06_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+static inline size_t HUFv06_decodeStreamX4(BYTE* p, BITv06_DStream_t* bitDPtr, BYTE* const pEnd, const HUFv06_DEltX4* const dt, const U32 dtLog) 
+{ 
+    BYTE* const pStart = p; 
+ 
+    /* up to 8 symbols at a time */ 
+    while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p < pEnd-7)) { 
+        HUFv06_DECODE_SYMBOLX4_2(p, bitDPtr); 
+        HUFv06_DECODE_SYMBOLX4_1(p, bitDPtr); 
+        HUFv06_DECODE_SYMBOLX4_2(p, bitDPtr); 
+        HUFv06_DECODE_SYMBOLX4_0(p, bitDPtr); 
+    } 
+ 
+    /* closer to the end */ 
+    while ((BITv06_reloadDStream(bitDPtr) == BITv06_DStream_unfinished) && (p <= pEnd-2)) 
+        HUFv06_DECODE_SYMBOLX4_0(p, bitDPtr); 
+ 
+    while (p <= pEnd-2) 
+        HUFv06_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */ 
+ 
+    if (p < pEnd) 
+        p += HUFv06_decodeLastSymbolX4(p, bitDPtr, dt, dtLog); 
+ 
+    return p-pStart; 
+} 
+ 
+ 
+size_t HUFv06_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 HUFv06_DEltX4* const dt = ((const HUFv06_DEltX4*)dtPtr) +1; 
+ 
+    /* Init */ 
+    BITv06_DStream_t bitD; 
+    { size_t const errorCode = BITv06_initDStream(&bitD, istart, cSrcSize); 
+      if (HUFv06_isError(errorCode)) return errorCode; } 
+ 
+    /* decode */ 
+    HUFv06_decodeStreamX4(ostart, &bitD, oend, dt, dtLog); 
+ 
+    /* check */ 
+    if (!BITv06_endOfDStream(&bitD)) return ERROR(corruption_detected); 
+ 
+    /* decoded size */ 
+    return dstSize; 
+} 
+ 
+size_t HUFv06_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUFv06_CREATE_STATIC_DTABLEX4(DTable, HUFv06_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
+    size_t const hSize = HUFv06_readDTableX4 (DTable, cSrc, cSrcSize); 
+    if (HUFv06_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; 
+    cSrcSize -= hSize; 
+ 
+    return HUFv06_decompress1X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable); 
+} 
+ 
+size_t HUFv06_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 HUFv06_DEltX4* const dt = ((const HUFv06_DEltX4*)dtPtr) +1; 
+        const U32 dtLog = DTable[0]; 
+        size_t errorCode; 
+ 
+        /* Init */ 
+        BITv06_DStream_t bitD1; 
+        BITv06_DStream_t bitD2; 
+        BITv06_DStream_t bitD3; 
+        BITv06_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 = BITv06_initDStream(&bitD1, istart1, length1); 
+        if (HUFv06_isError(errorCode)) return errorCode; 
+        errorCode = BITv06_initDStream(&bitD2, istart2, length2); 
+        if (HUFv06_isError(errorCode)) return errorCode; 
+        errorCode = BITv06_initDStream(&bitD3, istart3, length3); 
+        if (HUFv06_isError(errorCode)) return errorCode; 
+        errorCode = BITv06_initDStream(&bitD4, istart4, length4); 
+        if (HUFv06_isError(errorCode)) return errorCode; 
+ 
+        /* 16-32 symbols per loop (4-8 symbols per stream) */ 
+        endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_reloadDStream(&bitD4); 
+        for ( ; (endSignal==BITv06_DStream_unfinished) && (op4<(oend-7)) ; ) { 
+            HUFv06_DECODE_SYMBOLX4_2(op1, &bitD1); 
+            HUFv06_DECODE_SYMBOLX4_2(op2, &bitD2); 
+            HUFv06_DECODE_SYMBOLX4_2(op3, &bitD3); 
+            HUFv06_DECODE_SYMBOLX4_2(op4, &bitD4); 
+            HUFv06_DECODE_SYMBOLX4_1(op1, &bitD1); 
+            HUFv06_DECODE_SYMBOLX4_1(op2, &bitD2); 
+            HUFv06_DECODE_SYMBOLX4_1(op3, &bitD3); 
+            HUFv06_DECODE_SYMBOLX4_1(op4, &bitD4); 
+            HUFv06_DECODE_SYMBOLX4_2(op1, &bitD1); 
+            HUFv06_DECODE_SYMBOLX4_2(op2, &bitD2); 
+            HUFv06_DECODE_SYMBOLX4_2(op3, &bitD3); 
+            HUFv06_DECODE_SYMBOLX4_2(op4, &bitD4); 
+            HUFv06_DECODE_SYMBOLX4_0(op1, &bitD1); 
+            HUFv06_DECODE_SYMBOLX4_0(op2, &bitD2); 
+            HUFv06_DECODE_SYMBOLX4_0(op3, &bitD3); 
+            HUFv06_DECODE_SYMBOLX4_0(op4, &bitD4); 
+ 
+            endSignal = BITv06_reloadDStream(&bitD1) | BITv06_reloadDStream(&bitD2) | BITv06_reloadDStream(&bitD3) | BITv06_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 */ 
+        HUFv06_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog); 
+        HUFv06_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog); 
+        HUFv06_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog); 
+        HUFv06_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog); 
+ 
+        /* check */ 
+        endSignal = BITv06_endOfDStream(&bitD1) & BITv06_endOfDStream(&bitD2) & BITv06_endOfDStream(&bitD3) & BITv06_endOfDStream(&bitD4); 
+        if (!endSignal) return ERROR(corruption_detected); 
+ 
+        /* decoded size */ 
+        return dstSize; 
+    } 
+} 
+ 
+ 
+size_t HUFv06_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUFv06_CREATE_STATIC_DTABLEX4(DTable, HUFv06_MAX_TABLELOG); 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
+    size_t hSize = HUFv06_readDTableX4 (DTable, cSrc, cSrcSize); 
+    if (HUFv06_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; 
+    cSrcSize -= hSize; 
+ 
+    return HUFv06_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 HUFv06_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    static const decompressionAlgo decompress[3] = { HUFv06_decompress4X2, HUFv06_decompress4X4, NULL }; 
+    U32 Dtime[3];   /* decompression time estimation */ 
+ 
+    /* 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 */ 
+    {   U32 const Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */ 
+        U32 const D256 = (U32)(dstSize >> 8); 
+        U32 n; 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 */ 
+ 
+    {   U32 algoNb = 0; 
+        if (Dtime[1] < Dtime[0]) algoNb = 1; 
         /* if (Dtime[2] < Dtime[algoNb]) algoNb = 2; */   /* current speed of HUFv06_decompress4X6 is not good */
-        return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
-    }
-
+        return decompress[algoNb](dst, dstSize, cSrc, cSrcSize); 
+    } 
+ 
     /* return HUFv06_decompress4X2(dst, dstSize, cSrc, cSrcSize); */   /* multi-streams single-symbol decoding */
     /* return HUFv06_decompress4X4(dst, dstSize, cSrc, cSrcSize); */   /* multi-streams double-symbols decoding */
     /* return HUFv06_decompress4X6(dst, dstSize, cSrc, cSrcSize); */   /* multi-streams quad-symbols decoding */
-}
-/*
-    Common functions of Zstd compression library
-    Copyright (C) 2015-2016, Yann Collet.
-
-    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are
-    met:
-    * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-    copyright notice, this list of conditions and the following disclaimer
-    in the documentation and/or other materials provided with the
-    distribution.
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    You can contact the author at :
-    - zstd homepage : http://www.zstd.net/
-*/
-
-
-/*-****************************************
-*  Version
-******************************************/
-
-/*-****************************************
-*  ZSTD Error Management
-******************************************/
-/*! ZSTDv06_isError() :
-*   tells if a return value is an error code */
-unsigned ZSTDv06_isError(size_t code) { return ERR_isError(code); }
-
-/*! ZSTDv06_getErrorName() :
-*   provides error code string from function result (useful for debugging) */
-const char* ZSTDv06_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-
-/* **************************************************************
-*  ZBUFF Error Management
-****************************************************************/
-unsigned ZBUFFv06_isError(size_t errorCode) { return ERR_isError(errorCode); }
-
-const char* ZBUFFv06_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
-/*
-    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 ZSTDv06_decompress() will allocate memory,
- * in memory stack (0), or in memory heap (1, requires malloc())
- */
-#ifndef ZSTDv06_HEAPMODE
-#  define ZSTDv06_HEAPMODE 1
-#endif
-
-
-
-/*-*******************************************************
-*  Compiler specifics
-*********************************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  include <intrin.h>                    /* For Visual 2005 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
-#endif
-
-
-/*-*************************************
-*  Macros
-***************************************/
-#define ZSTDv06_isError ERR_isError   /* for inlining */
-#define FSEv06_isError  ERR_isError
-#define HUFv06_isError  ERR_isError
-
-
-/*_*******************************************************
-*  Memory operations
-**********************************************************/
-static void ZSTDv06_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
-
-
-/*-*************************************************************
-*   Context management
-***************************************************************/
-typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,
-               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock } ZSTDv06_dStage;
-
-struct ZSTDv06_DCtx_s
-{
-    FSEv06_DTable LLTable[FSEv06_DTABLE_SIZE_U32(LLFSELog)];
-    FSEv06_DTable OffTable[FSEv06_DTABLE_SIZE_U32(OffFSELog)];
-    FSEv06_DTable MLTable[FSEv06_DTABLE_SIZE_U32(MLFSELog)];
-    unsigned   hufTableX4[HUFv06_DTABLE_SIZE(HufLog)];
-    const void* previousDstEnd;
-    const void* base;
-    const void* vBase;
-    const void* dictEnd;
-    size_t expected;
-    size_t headerSize;
-    ZSTDv06_frameParams fParams;
-    blockType_t bType;   /* used in ZSTDv06_decompressContinue(), to transfer blockType between header decoding and block decoding stages */
-    ZSTDv06_dStage stage;
-    U32 flagRepeatTable;
-    const BYTE* litPtr;
-    size_t litSize;
-    BYTE litBuffer[ZSTDv06_BLOCKSIZE_MAX + WILDCOPY_OVERLENGTH];
-    BYTE headerBuffer[ZSTDv06_FRAMEHEADERSIZE_MAX];
-};  /* typedef'd to ZSTDv06_DCtx within "zstd_static.h" */
-
+} 
+/* 
+    Common functions of Zstd compression library 
+    Copyright (C) 2015-2016, Yann Collet. 
+ 
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+    Redistribution and use in source and binary forms, with or without 
+    modification, are permitted provided that the following conditions are 
+    met: 
+    * Redistributions of source code must retain the above copyright 
+    notice, this list of conditions and the following disclaimer. 
+    * Redistributions in binary form must reproduce the above 
+    copyright notice, this list of conditions and the following disclaimer 
+    in the documentation and/or other materials provided with the 
+    distribution. 
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+    You can contact the author at : 
+    - zstd homepage : http://www.zstd.net/ 
+*/ 
+ 
+ 
+/*-**************************************** 
+*  Version 
+******************************************/ 
+ 
+/*-**************************************** 
+*  ZSTD Error Management 
+******************************************/ 
+/*! ZSTDv06_isError() : 
+*   tells if a return value is an error code */ 
+unsigned ZSTDv06_isError(size_t code) { return ERR_isError(code); } 
+ 
+/*! ZSTDv06_getErrorName() : 
+*   provides error code string from function result (useful for debugging) */ 
+const char* ZSTDv06_getErrorName(size_t code) { return ERR_getErrorName(code); } 
+ 
+ 
+/* ************************************************************** 
+*  ZBUFF Error Management 
+****************************************************************/ 
+unsigned ZBUFFv06_isError(size_t errorCode) { return ERR_isError(errorCode); } 
+ 
+const char* ZBUFFv06_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); } 
+/* 
+    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 ZSTDv06_decompress() will allocate memory, 
+ * in memory stack (0), or in memory heap (1, requires malloc()) 
+ */ 
+#ifndef ZSTDv06_HEAPMODE 
+#  define ZSTDv06_HEAPMODE 1 
+#endif 
+ 
+ 
+ 
+/*-******************************************************* 
+*  Compiler specifics 
+*********************************************************/ 
+#ifdef _MSC_VER    /* Visual Studio */ 
+#  include <intrin.h>                    /* For Visual 2005 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */ 
+#endif 
+ 
+ 
+/*-************************************* 
+*  Macros 
+***************************************/ 
+#define ZSTDv06_isError ERR_isError   /* for inlining */ 
+#define FSEv06_isError  ERR_isError 
+#define HUFv06_isError  ERR_isError 
+ 
+ 
+/*_******************************************************* 
+*  Memory operations 
+**********************************************************/ 
+static void ZSTDv06_copy4(void* dst, const void* src) { memcpy(dst, src, 4); } 
+ 
+ 
+/*-************************************************************* 
+*   Context management 
+***************************************************************/ 
+typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader, 
+               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock } ZSTDv06_dStage; 
+ 
+struct ZSTDv06_DCtx_s 
+{ 
+    FSEv06_DTable LLTable[FSEv06_DTABLE_SIZE_U32(LLFSELog)]; 
+    FSEv06_DTable OffTable[FSEv06_DTABLE_SIZE_U32(OffFSELog)]; 
+    FSEv06_DTable MLTable[FSEv06_DTABLE_SIZE_U32(MLFSELog)]; 
+    unsigned   hufTableX4[HUFv06_DTABLE_SIZE(HufLog)]; 
+    const void* previousDstEnd; 
+    const void* base; 
+    const void* vBase; 
+    const void* dictEnd; 
+    size_t expected; 
+    size_t headerSize; 
+    ZSTDv06_frameParams fParams; 
+    blockType_t bType;   /* used in ZSTDv06_decompressContinue(), to transfer blockType between header decoding and block decoding stages */ 
+    ZSTDv06_dStage stage; 
+    U32 flagRepeatTable; 
+    const BYTE* litPtr; 
+    size_t litSize; 
+    BYTE litBuffer[ZSTDv06_BLOCKSIZE_MAX + WILDCOPY_OVERLENGTH]; 
+    BYTE headerBuffer[ZSTDv06_FRAMEHEADERSIZE_MAX]; 
+};  /* typedef'd to ZSTDv06_DCtx within "zstd_static.h" */ 
+ 
 size_t ZSTDv06_sizeofDCtx (void); /* Hidden declaration */
 size_t ZSTDv06_sizeofDCtx (void) { return sizeof(ZSTDv06_DCtx); }
-
-size_t ZSTDv06_decompressBegin(ZSTDv06_DCtx* dctx)
-{
-    dctx->expected = ZSTDv06_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;
-}
-
-ZSTDv06_DCtx* ZSTDv06_createDCtx(void)
-{
-    ZSTDv06_DCtx* dctx = (ZSTDv06_DCtx*)malloc(sizeof(ZSTDv06_DCtx));
-    if (dctx==NULL) return NULL;
-    ZSTDv06_decompressBegin(dctx);
-    return dctx;
-}
-
-size_t ZSTDv06_freeDCtx(ZSTDv06_DCtx* dctx)
-{
-    free(dctx);
-    return 0;   /* reserved as a potential error code in the future */
-}
-
-void ZSTDv06_copyDCtx(ZSTDv06_DCtx* dstDCtx, const ZSTDv06_DCtx* srcDCtx)
-{
-    memcpy(dstDCtx, srcDCtx,
-           sizeof(ZSTDv06_DCtx) - (ZSTDv06_BLOCKSIZE_MAX+WILDCOPY_OVERLENGTH + ZSTDv06_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 : ZSTDv06_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 - ZSTDv06_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
-*/
-
-/** ZSTDv06_frameHeaderSize() :
-*   srcSize must be >= ZSTDv06_frameHeaderSize_min.
-*   @return : size of the Frame Header */
-static size_t ZSTDv06_frameHeaderSize(const void* src, size_t srcSize)
-{
-    if (srcSize < ZSTDv06_frameHeaderSize_min) return ERROR(srcSize_wrong);
-    { U32 const fcsId = (((const BYTE*)src)[4]) >> 6;
-      return ZSTDv06_frameHeaderSize_min + ZSTDv06_fcs_fieldSize[fcsId]; }
-}
-
-
-/** ZSTDv06_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 ZSTDv06_isError() */
-size_t ZSTDv06_getFrameParams(ZSTDv06_frameParams* fparamsPtr, const void* src, size_t srcSize)
-{
-    const BYTE* ip = (const BYTE*)src;
-
-    if (srcSize < ZSTDv06_frameHeaderSize_min) return ZSTDv06_frameHeaderSize_min;
-    if (MEM_readLE32(src) != ZSTDv06_MAGICNUMBER) return ERROR(prefix_unknown);
-
-    /* ensure there is enough `srcSize` to fully read/decode frame header */
-    { size_t const fhsize = ZSTDv06_frameHeaderSize(src, srcSize);
-      if (srcSize < fhsize) return fhsize; }
-
-    memset(fparamsPtr, 0, sizeof(*fparamsPtr));
-    {   BYTE const frameDesc = ip[4];
-        fparamsPtr->windowLog = (frameDesc & 0xF) + ZSTDv06_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;
-}
-
-
-/** ZSTDv06_decodeFrameHeader() :
-*   `srcSize` must be the size provided by ZSTDv06_frameHeaderSize().
-*   @return : 0 if success, or an error code, which can be tested using ZSTDv06_isError() */
-static size_t ZSTDv06_decodeFrameHeader(ZSTDv06_DCtx* zc, const void* src, size_t srcSize)
-{
-    size_t const result = ZSTDv06_getFrameParams(&(zc->fParams), src, srcSize);
+ 
+size_t ZSTDv06_decompressBegin(ZSTDv06_DCtx* dctx) 
+{ 
+    dctx->expected = ZSTDv06_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; 
+} 
+ 
+ZSTDv06_DCtx* ZSTDv06_createDCtx(void) 
+{ 
+    ZSTDv06_DCtx* dctx = (ZSTDv06_DCtx*)malloc(sizeof(ZSTDv06_DCtx)); 
+    if (dctx==NULL) return NULL; 
+    ZSTDv06_decompressBegin(dctx); 
+    return dctx; 
+} 
+ 
+size_t ZSTDv06_freeDCtx(ZSTDv06_DCtx* dctx) 
+{ 
+    free(dctx); 
+    return 0;   /* reserved as a potential error code in the future */ 
+} 
+ 
+void ZSTDv06_copyDCtx(ZSTDv06_DCtx* dstDCtx, const ZSTDv06_DCtx* srcDCtx) 
+{ 
+    memcpy(dstDCtx, srcDCtx, 
+           sizeof(ZSTDv06_DCtx) - (ZSTDv06_BLOCKSIZE_MAX+WILDCOPY_OVERLENGTH + ZSTDv06_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 : ZSTDv06_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 - ZSTDv06_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 
+*/ 
+ 
+/** ZSTDv06_frameHeaderSize() : 
+*   srcSize must be >= ZSTDv06_frameHeaderSize_min. 
+*   @return : size of the Frame Header */ 
+static size_t ZSTDv06_frameHeaderSize(const void* src, size_t srcSize) 
+{ 
+    if (srcSize < ZSTDv06_frameHeaderSize_min) return ERROR(srcSize_wrong); 
+    { U32 const fcsId = (((const BYTE*)src)[4]) >> 6; 
+      return ZSTDv06_frameHeaderSize_min + ZSTDv06_fcs_fieldSize[fcsId]; } 
+} 
+ 
+ 
+/** ZSTDv06_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 ZSTDv06_isError() */ 
+size_t ZSTDv06_getFrameParams(ZSTDv06_frameParams* fparamsPtr, const void* src, size_t srcSize) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+ 
+    if (srcSize < ZSTDv06_frameHeaderSize_min) return ZSTDv06_frameHeaderSize_min; 
+    if (MEM_readLE32(src) != ZSTDv06_MAGICNUMBER) return ERROR(prefix_unknown); 
+ 
+    /* ensure there is enough `srcSize` to fully read/decode frame header */ 
+    { size_t const fhsize = ZSTDv06_frameHeaderSize(src, srcSize); 
+      if (srcSize < fhsize) return fhsize; } 
+ 
+    memset(fparamsPtr, 0, sizeof(*fparamsPtr)); 
+    {   BYTE const frameDesc = ip[4]; 
+        fparamsPtr->windowLog = (frameDesc & 0xF) + ZSTDv06_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; 
+} 
+ 
+ 
+/** ZSTDv06_decodeFrameHeader() : 
+*   `srcSize` must be the size provided by ZSTDv06_frameHeaderSize(). 
+*   @return : 0 if success, or an error code, which can be tested using ZSTDv06_isError() */ 
+static size_t ZSTDv06_decodeFrameHeader(ZSTDv06_DCtx* zc, const void* src, size_t srcSize) 
+{ 
+    size_t const result = ZSTDv06_getFrameParams(&(zc->fParams), src, srcSize); 
     if ((MEM_32bits()) && (zc->fParams.windowLog > 25)) return ERROR(frameParameter_unsupported);
-    return result;
-}
-
-
-typedef struct
-{
-    blockType_t blockType;
-    U32 origSize;
-} blockProperties_t;
-
-/*! ZSTDv06_getcBlockSize() :
-*   Provides the size of compressed block from block header `src` */
+    return result; 
+} 
+ 
+ 
+typedef struct 
+{ 
+    blockType_t blockType; 
+    U32 origSize; 
+} blockProperties_t; 
+ 
+/*! ZSTDv06_getcBlockSize() : 
+*   Provides the size of compressed block from block header `src` */ 
 static size_t ZSTDv06_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
-{
+{ 
     const BYTE* const in = (const BYTE*)src;
-    U32 cSize;
-
-    if (srcSize < ZSTDv06_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 ZSTDv06_copyRawBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
+    U32 cSize; 
+ 
+    if (srcSize < ZSTDv06_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 ZSTDv06_copyRawBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
     if (dst==NULL) return ERROR(dstSize_tooSmall);
-    if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall);
-    memcpy(dst, src, srcSize);
-    return srcSize;
-}
-
-
-/*! ZSTDv06_decodeLiteralsBlock() :
-    @return : nb of bytes read from src (< srcSize ) */
+    if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall); 
+    memcpy(dst, src, srcSize); 
+    return srcSize; 
+} 
+ 
+ 
+/*! ZSTDv06_decodeLiteralsBlock() : 
+    @return : nb of bytes read from src (< srcSize ) */ 
 static size_t ZSTDv06_decodeLiteralsBlock(ZSTDv06_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 > ZSTDv06_BLOCKSIZE_MAX) return ERROR(corruption_detected);
-            if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
-
-            if (HUFv06_isError(singleStream ?
-                            HUFv06_decompress1X2(dctx->litBuffer, litSize, istart+lhSize, litCSize) :
-                            HUFv06_decompress   (dctx->litBuffer, litSize, istart+lhSize, litCSize) ))
-                return ERROR(corruption_detected);
-
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litSize = litSize;
+                          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 > ZSTDv06_BLOCKSIZE_MAX) return ERROR(corruption_detected); 
+            if (litCSize + lhSize > srcSize) return ERROR(corruption_detected); 
+ 
+            if (HUFv06_isError(singleStream ? 
+                            HUFv06_decompress1X2(dctx->litBuffer, litSize, istart+lhSize, litCSize) : 
+                            HUFv06_decompress   (dctx->litBuffer, litSize, istart+lhSize, litCSize) )) 
+                return ERROR(corruption_detected); 
+ 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litSize = litSize; 
             memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
-            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];
+            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]; 
             if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
-
-            {   size_t const errorCode = HUFv06_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTableX4);
-                if (HUFv06_isError(errorCode)) return ERROR(corruption_detected);
-            }
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litSize = litSize;
+ 
+            {   size_t const errorCode = HUFv06_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTableX4); 
+                if (HUFv06_isError(errorCode)) return ERROR(corruption_detected); 
+            } 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litSize = litSize; 
             memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
-            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->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->litSize = litSize; 
                 memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
-                return lhSize+litSize;
-            }
-            /* direct reference into compressed stream */
-            dctx->litPtr = istart+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 > ZSTDv06_BLOCKSIZE_MAX) return ERROR(corruption_detected);
+                return lhSize+litSize; 
+            } 
+            /* direct reference into compressed stream */ 
+            dctx->litPtr = istart+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 > ZSTDv06_BLOCKSIZE_MAX) return ERROR(corruption_detected); 
             memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litSize = litSize;
-            return lhSize+1;
-        }
-    default:
-        return ERROR(corruption_detected);   /* impossible */
-    }
-}
-
-
-/*! ZSTDv06_buildSeqTable() :
-    @return : nb bytes read from src,
-              or an error code if it fails, testable with ZSTDv06_isError()
-*/
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litSize = litSize; 
+            return lhSize+1; 
+        } 
+    default: 
+        return ERROR(corruption_detected);   /* impossible */ 
+    } 
+} 
+ 
+ 
+/*! ZSTDv06_buildSeqTable() : 
+    @return : nb bytes read from src, 
+              or an error code if it fails, testable with ZSTDv06_isError() 
+*/ 
 static size_t ZSTDv06_buildSeqTable(FSEv06_DTable* DTable, U32 type, U32 max, U32 maxLog,
-                                 const void* src, size_t srcSize,
-                                 const S16* defaultNorm, U32 defaultLog, U32 flagRepeatTable)
-{
-    switch(type)
-    {
-    case FSEv06_ENCODING_RLE :
-        if (!srcSize) return ERROR(srcSize_wrong);
-        if ( (*(const BYTE*)src) > max) return ERROR(corruption_detected);
-        FSEv06_buildDTable_rle(DTable, *(const BYTE*)src);   /* if *src > max, data is corrupted */
-        return 1;
-    case FSEv06_ENCODING_RAW :
-        FSEv06_buildDTable(DTable, defaultNorm, max, defaultLog);
-        return 0;
-    case FSEv06_ENCODING_STATIC:
-        if (!flagRepeatTable) return ERROR(corruption_detected);
-        return 0;
-    default :   /* impossible */
-    case FSEv06_ENCODING_DYNAMIC :
-        {   U32 tableLog;
-            S16 norm[MaxSeq+1];
-            size_t const headerSize = FSEv06_readNCount(norm, &max, &tableLog, src, srcSize);
-            if (FSEv06_isError(headerSize)) return ERROR(corruption_detected);
-            if (tableLog > maxLog) return ERROR(corruption_detected);
-            FSEv06_buildDTable(DTable, norm, max, tableLog);
-            return headerSize;
-    }   }
-}
-
-
+                                 const void* src, size_t srcSize, 
+                                 const S16* defaultNorm, U32 defaultLog, U32 flagRepeatTable) 
+{ 
+    switch(type) 
+    { 
+    case FSEv06_ENCODING_RLE : 
+        if (!srcSize) return ERROR(srcSize_wrong); 
+        if ( (*(const BYTE*)src) > max) return ERROR(corruption_detected); 
+        FSEv06_buildDTable_rle(DTable, *(const BYTE*)src);   /* if *src > max, data is corrupted */ 
+        return 1; 
+    case FSEv06_ENCODING_RAW : 
+        FSEv06_buildDTable(DTable, defaultNorm, max, defaultLog); 
+        return 0; 
+    case FSEv06_ENCODING_STATIC: 
+        if (!flagRepeatTable) return ERROR(corruption_detected); 
+        return 0; 
+    default :   /* impossible */ 
+    case FSEv06_ENCODING_DYNAMIC : 
+        {   U32 tableLog; 
+            S16 norm[MaxSeq+1]; 
+            size_t const headerSize = FSEv06_readNCount(norm, &max, &tableLog, src, srcSize); 
+            if (FSEv06_isError(headerSize)) return ERROR(corruption_detected); 
+            if (tableLog > maxLog) return ERROR(corruption_detected); 
+            FSEv06_buildDTable(DTable, norm, max, tableLog); 
+            return headerSize; 
+    }   } 
+} 
+ 
+ 
 static size_t ZSTDv06_decodeSeqHeaders(int* nbSeqPtr,
-                             FSEv06_DTable* DTableLL, FSEv06_DTable* DTableML, FSEv06_DTable* DTableOffb, U32 flagRepeatTable,
-                             const void* src, size_t srcSize)
-{
+                             FSEv06_DTable* DTableLL, FSEv06_DTable* DTableML, FSEv06_DTable* DTableOffb, U32 flagRepeatTable, 
+                             const void* src, size_t srcSize) 
+{ 
     const BYTE* const istart = (const BYTE*)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) {
+    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) {
                 if (ip+2 > iend) return ERROR(srcSize_wrong);
-                nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2;
+                nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2; 
             } else {
                 if (ip >= iend) return ERROR(srcSize_wrong);
-                nbSeq = ((nbSeq-0x80)<<8) + *ip++;
+                nbSeq = ((nbSeq-0x80)<<8) + *ip++; 
             }
-        }
-        *nbSeqPtr = nbSeq;
-    }
-
-    /* FSE table descriptors */
+        } 
+        *nbSeqPtr = nbSeq; 
+    } 
+ 
+    /* FSE table descriptors */ 
     if (ip + 4 > iend) return ERROR(srcSize_wrong); /* min : header byte + all 3 are "raw", hence no header, but at least xxLog bits per type */
-    {   U32 const LLtype  = *ip >> 6;
-        U32 const Offtype = (*ip >> 4) & 3;
-        U32 const MLtype  = (*ip >> 2) & 3;
-        ip++;
-
-        /* Build DTables */
-        {   size_t const bhSize = ZSTDv06_buildSeqTable(DTableLL, LLtype, MaxLL, LLFSELog, ip, iend-ip, LL_defaultNorm, LL_defaultNormLog, flagRepeatTable);
-            if (ZSTDv06_isError(bhSize)) return ERROR(corruption_detected);
-            ip += bhSize;
-        }
-        {   size_t const bhSize = ZSTDv06_buildSeqTable(DTableOffb, Offtype, MaxOff, OffFSELog, ip, iend-ip, OF_defaultNorm, OF_defaultNormLog, flagRepeatTable);
-            if (ZSTDv06_isError(bhSize)) return ERROR(corruption_detected);
-            ip += bhSize;
-        }
-        {   size_t const bhSize = ZSTDv06_buildSeqTable(DTableML, MLtype, MaxML, MLFSELog, ip, iend-ip, ML_defaultNorm, ML_defaultNormLog, flagRepeatTable);
-            if (ZSTDv06_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 {
-    BITv06_DStream_t DStream;
-    FSEv06_DState_t stateLL;
-    FSEv06_DState_t stateOffb;
-    FSEv06_DState_t stateML;
-    size_t prevOffset[ZSTDv06_REP_INIT];
-} seqState_t;
-
-
-
-static void ZSTDv06_decodeSequence(seq_t* seq, seqState_t* seqState)
-{
-    /* Literal length */
-    U32 const llCode = FSEv06_peekSymbol(&(seqState->stateLL));
-    U32 const mlCode = FSEv06_peekSymbol(&(seqState->stateML));
-    U32 const ofCode = FSEv06_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] + BITv06_readBits(&(seqState->DStream), ofBits);   /* <=  26 bits */
-            if (MEM_32bits()) BITv06_reloadDStream(&(seqState->DStream));
-        }
-
-        if (offset < ZSTDv06_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 -= ZSTDv06_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) ? BITv06_readBits(&(seqState->DStream), mlBits) : 0);   /* <=  16 bits */
-    if (MEM_32bits() && (mlBits+llBits>24)) BITv06_reloadDStream(&(seqState->DStream));
-
-    seq->litLength = LL_base[llCode] + ((llCode>15) ? BITv06_readBits(&(seqState->DStream), llBits) : 0);   /* <=  16 bits */
-    if (MEM_32bits() ||
-       (totalBits > 64 - 7 - (LLFSELog+MLFSELog+OffFSELog)) ) BITv06_reloadDStream(&(seqState->DStream));
-
-    /* ANS state update */
-    FSEv06_updateState(&(seqState->stateLL), &(seqState->DStream));   /* <=  9 bits */
-    FSEv06_updateState(&(seqState->stateML), &(seqState->DStream));   /* <=  9 bits */
-    if (MEM_32bits()) BITv06_reloadDStream(&(seqState->DStream));     /* <= 18 bits */
-    FSEv06_updateState(&(seqState->stateOffb), &(seqState->DStream)); /* <=  8 bits */
-}
-
-
+    {   U32 const LLtype  = *ip >> 6; 
+        U32 const Offtype = (*ip >> 4) & 3; 
+        U32 const MLtype  = (*ip >> 2) & 3; 
+        ip++; 
+ 
+        /* Build DTables */ 
+        {   size_t const bhSize = ZSTDv06_buildSeqTable(DTableLL, LLtype, MaxLL, LLFSELog, ip, iend-ip, LL_defaultNorm, LL_defaultNormLog, flagRepeatTable); 
+            if (ZSTDv06_isError(bhSize)) return ERROR(corruption_detected); 
+            ip += bhSize; 
+        } 
+        {   size_t const bhSize = ZSTDv06_buildSeqTable(DTableOffb, Offtype, MaxOff, OffFSELog, ip, iend-ip, OF_defaultNorm, OF_defaultNormLog, flagRepeatTable); 
+            if (ZSTDv06_isError(bhSize)) return ERROR(corruption_detected); 
+            ip += bhSize; 
+        } 
+        {   size_t const bhSize = ZSTDv06_buildSeqTable(DTableML, MLtype, MaxML, MLFSELog, ip, iend-ip, ML_defaultNorm, ML_defaultNormLog, flagRepeatTable); 
+            if (ZSTDv06_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 { 
+    BITv06_DStream_t DStream; 
+    FSEv06_DState_t stateLL; 
+    FSEv06_DState_t stateOffb; 
+    FSEv06_DState_t stateML; 
+    size_t prevOffset[ZSTDv06_REP_INIT]; 
+} seqState_t; 
+ 
+ 
+ 
+static void ZSTDv06_decodeSequence(seq_t* seq, seqState_t* seqState) 
+{ 
+    /* Literal length */ 
+    U32 const llCode = FSEv06_peekSymbol(&(seqState->stateLL)); 
+    U32 const mlCode = FSEv06_peekSymbol(&(seqState->stateML)); 
+    U32 const ofCode = FSEv06_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] + BITv06_readBits(&(seqState->DStream), ofBits);   /* <=  26 bits */ 
+            if (MEM_32bits()) BITv06_reloadDStream(&(seqState->DStream)); 
+        } 
+ 
+        if (offset < ZSTDv06_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 -= ZSTDv06_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) ? BITv06_readBits(&(seqState->DStream), mlBits) : 0);   /* <=  16 bits */ 
+    if (MEM_32bits() && (mlBits+llBits>24)) BITv06_reloadDStream(&(seqState->DStream)); 
+ 
+    seq->litLength = LL_base[llCode] + ((llCode>15) ? BITv06_readBits(&(seqState->DStream), llBits) : 0);   /* <=  16 bits */ 
+    if (MEM_32bits() || 
+       (totalBits > 64 - 7 - (LLFSELog+MLFSELog+OffFSELog)) ) BITv06_reloadDStream(&(seqState->DStream)); 
+ 
+    /* ANS state update */ 
+    FSEv06_updateState(&(seqState->stateLL), &(seqState->DStream));   /* <=  9 bits */ 
+    FSEv06_updateState(&(seqState->stateML), &(seqState->DStream));   /* <=  9 bits */ 
+    if (MEM_32bits()) BITv06_reloadDStream(&(seqState->DStream));     /* <= 18 bits */ 
+    FSEv06_updateState(&(seqState->stateOffb), &(seqState->DStream)); /* <=  8 bits */ 
+} 
+ 
+ 
 static size_t ZSTDv06_execSequence(BYTE* op,
-                                BYTE* const oend, seq_t sequence,
+                                BYTE* const oend, seq_t sequence, 
                                 const BYTE** litPtr, const BYTE* const litLimit,
-                                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 */
+                                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) return ERROR(corruption_detected);   /* over-read beyond lit buffer */
-
-    /* copy Literals */
-    ZSTDv06_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;
+ 
+    /* copy Literals */ 
+    ZSTDv06_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; 
             if (op > oend_8 || sequence.matchLength < MINMATCH) {
               while (op < oMatchEnd) *op++ = *match++;
               return sequenceLength;
             }
-    }   }
+    }   } 
     /* Requirement: op <= oend_8 */
-
-    /* match within prefix */
-    if (sequence.offset < 8) {
-        /* close range match, overlap */
-        static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */
+ 
+    /* 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 };   /* subtracted */
-        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];
-        ZSTDv06_copy4(op+4, match);
-        match -= sub2;
-    } else {
-        ZSTDv06_copy8(op, match);
-    }
-    op += 8; match += 8;
-
-    if (oMatchEnd > oend-(16-MINMATCH)) {
-        if (op < oend_8) {
-            ZSTDv06_wildcopy(op, match, oend_8 - op);
-            match += oend_8 - op;
-            op = oend_8;
-        }
-        while (op < oMatchEnd) *op++ = *match++;
-    } else {
+        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]; 
+        ZSTDv06_copy4(op+4, match); 
+        match -= sub2; 
+    } else { 
+        ZSTDv06_copy8(op, match); 
+    } 
+    op += 8; match += 8; 
+ 
+    if (oMatchEnd > oend-(16-MINMATCH)) { 
+        if (op < oend_8) { 
+            ZSTDv06_wildcopy(op, match, oend_8 - op); 
+            match += oend_8 - op; 
+            op = oend_8; 
+        } 
+        while (op < oMatchEnd) *op++ = *match++; 
+    } else { 
         ZSTDv06_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8);   /* works even if matchLength < 8 */
-    }
-    return sequenceLength;
-}
-
-
-static size_t ZSTDv06_decompressSequences(
-                               ZSTDv06_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;
+    } 
+    return sequenceLength; 
+} 
+ 
+ 
+static size_t ZSTDv06_decompressSequences( 
+                               ZSTDv06_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*)dst;
-    BYTE* const oend = ostart + maxDstSize;
-    BYTE* op = ostart;
-    const BYTE* litPtr = dctx->litPtr;
-    const BYTE* const litEnd = litPtr + dctx->litSize;
-    FSEv06_DTable* DTableLL = dctx->LLTable;
-    FSEv06_DTable* DTableML = dctx->MLTable;
-    FSEv06_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 = ZSTDv06_decodeSeqHeaders(&nbSeq, DTableLL, DTableML, DTableOffb, dctx->flagRepeatTable, ip, seqSize);
-        if (ZSTDv06_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<ZSTDv06_REP_INIT; i++) seqState.prevOffset[i] = REPCODE_STARTVALUE; }
-        { size_t const errorCode = BITv06_initDStream(&(seqState.DStream), ip, iend-ip);
-          if (ERR_isError(errorCode)) return ERROR(corruption_detected); }
-        FSEv06_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
-        FSEv06_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
-        FSEv06_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
-
-        for ( ; (BITv06_reloadDStream(&(seqState.DStream)) <= BITv06_DStream_completed) && nbSeq ; ) {
-            nbSeq--;
-            ZSTDv06_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
-
+    BYTE* const oend = ostart + maxDstSize; 
+    BYTE* op = ostart; 
+    const BYTE* litPtr = dctx->litPtr; 
+    const BYTE* const litEnd = litPtr + dctx->litSize; 
+    FSEv06_DTable* DTableLL = dctx->LLTable; 
+    FSEv06_DTable* DTableML = dctx->MLTable; 
+    FSEv06_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 = ZSTDv06_decodeSeqHeaders(&nbSeq, DTableLL, DTableML, DTableOffb, dctx->flagRepeatTable, ip, seqSize); 
+        if (ZSTDv06_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<ZSTDv06_REP_INIT; i++) seqState.prevOffset[i] = REPCODE_STARTVALUE; } 
+        { size_t const errorCode = BITv06_initDStream(&(seqState.DStream), ip, iend-ip); 
+          if (ERR_isError(errorCode)) return ERROR(corruption_detected); } 
+        FSEv06_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL); 
+        FSEv06_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb); 
+        FSEv06_initDState(&(seqState.stateML), &(seqState.DStream), DTableML); 
+ 
+        for ( ; (BITv06_reloadDStream(&(seqState.DStream)) <= BITv06_DStream_completed) && nbSeq ; ) { 
+            nbSeq--; 
+            ZSTDv06_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 = ZSTDv06_execSequence(op, oend, sequence, &litPtr, litEnd, base, vBase, dictEnd);
-                if (ZSTDv06_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);
+                if (ZSTDv06_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); 
         if (lastLLSize > 0) {
             memcpy(op, litPtr, lastLLSize);
             op += lastLLSize;
         }
-    }
-
-    return op-ostart;
-}
-
-
-static void ZSTDv06_checkContinuity(ZSTDv06_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 ZSTDv06_decompressBlock_internal(ZSTDv06_DCtx* dctx,
-                            void* dst, size_t dstCapacity,
-                      const void* src, size_t srcSize)
-{   /* blockType == blockCompressed */
-    const BYTE* ip = (const BYTE*)src;
-
-    if (srcSize >= ZSTDv06_BLOCKSIZE_MAX) return ERROR(srcSize_wrong);
-
-    /* Decode literals sub-block */
-    {   size_t const litCSize = ZSTDv06_decodeLiteralsBlock(dctx, src, srcSize);
-        if (ZSTDv06_isError(litCSize)) return litCSize;
-        ip += litCSize;
-        srcSize -= litCSize;
-    }
-    return ZSTDv06_decompressSequences(dctx, dst, dstCapacity, ip, srcSize);
-}
-
-
-size_t ZSTDv06_decompressBlock(ZSTDv06_DCtx* dctx,
-                            void* dst, size_t dstCapacity,
-                      const void* src, size_t srcSize)
-{
-    ZSTDv06_checkContinuity(dctx, dst);
-    return ZSTDv06_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
-}
-
-
-/*! ZSTDv06_decompressFrame() :
-*   `dctx` must be properly initialized */
-static size_t ZSTDv06_decompressFrame(ZSTDv06_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;
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+static void ZSTDv06_checkContinuity(ZSTDv06_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 ZSTDv06_decompressBlock_internal(ZSTDv06_DCtx* dctx, 
+                            void* dst, size_t dstCapacity, 
+                      const void* src, size_t srcSize) 
+{   /* blockType == blockCompressed */ 
+    const BYTE* ip = (const BYTE*)src; 
+ 
+    if (srcSize >= ZSTDv06_BLOCKSIZE_MAX) return ERROR(srcSize_wrong); 
+ 
+    /* Decode literals sub-block */ 
+    {   size_t const litCSize = ZSTDv06_decodeLiteralsBlock(dctx, src, srcSize); 
+        if (ZSTDv06_isError(litCSize)) return litCSize; 
+        ip += litCSize; 
+        srcSize -= litCSize; 
+    } 
+    return ZSTDv06_decompressSequences(dctx, dst, dstCapacity, ip, srcSize); 
+} 
+ 
+ 
+size_t ZSTDv06_decompressBlock(ZSTDv06_DCtx* dctx, 
+                            void* dst, size_t dstCapacity, 
+                      const void* src, size_t srcSize) 
+{ 
+    ZSTDv06_checkContinuity(dctx, dst); 
+    return ZSTDv06_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize); 
+} 
+ 
+ 
+/*! ZSTDv06_decompressFrame() : 
+*   `dctx` must be properly initialized */ 
+static size_t ZSTDv06_decompressFrame(ZSTDv06_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*)dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + dstCapacity;
-    size_t remainingSize = srcSize;
-    blockProperties_t blockProperties = { bt_compressed, 0 };
-
-    /* check */
-    if (srcSize < ZSTDv06_frameHeaderSize_min+ZSTDv06_blockHeaderSize) return ERROR(srcSize_wrong);
-
-    /* Frame Header */
-    {   size_t const frameHeaderSize = ZSTDv06_frameHeaderSize(src, ZSTDv06_frameHeaderSize_min);
-        if (ZSTDv06_isError(frameHeaderSize)) return frameHeaderSize;
-        if (srcSize < frameHeaderSize+ZSTDv06_blockHeaderSize) return ERROR(srcSize_wrong);
-        if (ZSTDv06_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 = ZSTDv06_getcBlockSize(ip, iend-ip, &blockProperties);
-        if (ZSTDv06_isError(cBlockSize)) return cBlockSize;
-
-        ip += ZSTDv06_blockHeaderSize;
-        remainingSize -= ZSTDv06_blockHeaderSize;
-        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);
-
-        switch(blockProperties.blockType)
-        {
-        case bt_compressed:
-            decodedSize = ZSTDv06_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize);
-            break;
-        case bt_raw :
-            decodedSize = ZSTDv06_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 (ZSTDv06_isError(decodedSize)) return decodedSize;
-        op += decodedSize;
-        ip += cBlockSize;
-        remainingSize -= cBlockSize;
-    }
-
-    return op-ostart;
-}
-
-
-size_t ZSTDv06_decompress_usingPreparedDCtx(ZSTDv06_DCtx* dctx, const ZSTDv06_DCtx* refDCtx,
-                                         void* dst, size_t dstCapacity,
-                                   const void* src, size_t srcSize)
-{
-    ZSTDv06_copyDCtx(dctx, refDCtx);
-    ZSTDv06_checkContinuity(dctx, dst);
-    return ZSTDv06_decompressFrame(dctx, dst, dstCapacity, src, srcSize);
-}
-
-
-size_t ZSTDv06_decompress_usingDict(ZSTDv06_DCtx* dctx,
-                                 void* dst, size_t dstCapacity,
-                                 const void* src, size_t srcSize,
-                                 const void* dict, size_t dictSize)
-{
-    ZSTDv06_decompressBegin_usingDict(dctx, dict, dictSize);
-    ZSTDv06_checkContinuity(dctx, dst);
-    return ZSTDv06_decompressFrame(dctx, dst, dstCapacity, src, srcSize);
-}
-
-
-size_t ZSTDv06_decompressDCtx(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    return ZSTDv06_decompress_usingDict(dctx, dst, dstCapacity, src, srcSize, NULL, 0);
-}
-
-
-size_t ZSTDv06_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-#if defined(ZSTDv06_HEAPMODE) && (ZSTDv06_HEAPMODE==1)
-    size_t regenSize;
-    ZSTDv06_DCtx* dctx = ZSTDv06_createDCtx();
-    if (dctx==NULL) return ERROR(memory_allocation);
-    regenSize = ZSTDv06_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);
-    ZSTDv06_freeDCtx(dctx);
-    return regenSize;
-#else   /* stack mode */
-    ZSTDv06_DCtx dctx;
-    return ZSTDv06_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
-#endif
-}
-
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + dstCapacity; 
+    size_t remainingSize = srcSize; 
+    blockProperties_t blockProperties = { bt_compressed, 0 }; 
+ 
+    /* check */ 
+    if (srcSize < ZSTDv06_frameHeaderSize_min+ZSTDv06_blockHeaderSize) return ERROR(srcSize_wrong); 
+ 
+    /* Frame Header */ 
+    {   size_t const frameHeaderSize = ZSTDv06_frameHeaderSize(src, ZSTDv06_frameHeaderSize_min); 
+        if (ZSTDv06_isError(frameHeaderSize)) return frameHeaderSize; 
+        if (srcSize < frameHeaderSize+ZSTDv06_blockHeaderSize) return ERROR(srcSize_wrong); 
+        if (ZSTDv06_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 = ZSTDv06_getcBlockSize(ip, iend-ip, &blockProperties); 
+        if (ZSTDv06_isError(cBlockSize)) return cBlockSize; 
+ 
+        ip += ZSTDv06_blockHeaderSize; 
+        remainingSize -= ZSTDv06_blockHeaderSize; 
+        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong); 
+ 
+        switch(blockProperties.blockType) 
+        { 
+        case bt_compressed: 
+            decodedSize = ZSTDv06_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize); 
+            break; 
+        case bt_raw : 
+            decodedSize = ZSTDv06_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 (ZSTDv06_isError(decodedSize)) return decodedSize; 
+        op += decodedSize; 
+        ip += cBlockSize; 
+        remainingSize -= cBlockSize; 
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+size_t ZSTDv06_decompress_usingPreparedDCtx(ZSTDv06_DCtx* dctx, const ZSTDv06_DCtx* refDCtx, 
+                                         void* dst, size_t dstCapacity, 
+                                   const void* src, size_t srcSize) 
+{ 
+    ZSTDv06_copyDCtx(dctx, refDCtx); 
+    ZSTDv06_checkContinuity(dctx, dst); 
+    return ZSTDv06_decompressFrame(dctx, dst, dstCapacity, src, srcSize); 
+} 
+ 
+ 
+size_t ZSTDv06_decompress_usingDict(ZSTDv06_DCtx* dctx, 
+                                 void* dst, size_t dstCapacity, 
+                                 const void* src, size_t srcSize, 
+                                 const void* dict, size_t dictSize) 
+{ 
+    ZSTDv06_decompressBegin_usingDict(dctx, dict, dictSize); 
+    ZSTDv06_checkContinuity(dctx, dst); 
+    return ZSTDv06_decompressFrame(dctx, dst, dstCapacity, src, srcSize); 
+} 
+ 
+ 
+size_t ZSTDv06_decompressDCtx(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    return ZSTDv06_decompress_usingDict(dctx, dst, dstCapacity, src, srcSize, NULL, 0); 
+} 
+ 
+ 
+size_t ZSTDv06_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+#if defined(ZSTDv06_HEAPMODE) && (ZSTDv06_HEAPMODE==1) 
+    size_t regenSize; 
+    ZSTDv06_DCtx* dctx = ZSTDv06_createDCtx(); 
+    if (dctx==NULL) return ERROR(memory_allocation); 
+    regenSize = ZSTDv06_decompressDCtx(dctx, dst, dstCapacity, src, srcSize); 
+    ZSTDv06_freeDCtx(dctx); 
+    return regenSize; 
+#else   /* stack mode */ 
+    ZSTDv06_DCtx dctx; 
+    return ZSTDv06_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize); 
+#endif 
+} 
+ 
 /* ZSTD_errorFrameSizeInfoLegacy() :
    assumes `cSize` and `dBound` are _not_ NULL */
 static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)
@@ -3670,7 +3670,7 @@ void ZSTDv06_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cS
     size_t remainingSize = srcSize;
     size_t nbBlocks = 0;
     blockProperties_t blockProperties = { bt_compressed, 0 };
-
+ 
     /* Frame Header */
     {   size_t const frameHeaderSize = ZSTDv06_frameHeaderSize(src, srcSize);
         if (ZSTDv06_isError(frameHeaderSize)) {
@@ -3714,441 +3714,441 @@ void ZSTDv06_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cS
     *dBound = nbBlocks * ZSTDv06_BLOCKSIZE_MAX;
 }
 
-/*_******************************
-*  Streaming Decompression API
-********************************/
-size_t ZSTDv06_nextSrcSizeToDecompress(ZSTDv06_DCtx* dctx)
-{
-    return dctx->expected;
-}
-
-size_t ZSTDv06_decompressContinue(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    /* Sanity check */
-    if (srcSize != dctx->expected) return ERROR(srcSize_wrong);
-    if (dstCapacity) ZSTDv06_checkContinuity(dctx, dst);
-
-    /* Decompress : frame header; part 1 */
-    switch (dctx->stage)
-    {
-    case ZSTDds_getFrameHeaderSize :
-        if (srcSize != ZSTDv06_frameHeaderSize_min) return ERROR(srcSize_wrong);   /* impossible */
-        dctx->headerSize = ZSTDv06_frameHeaderSize(src, ZSTDv06_frameHeaderSize_min);
-        if (ZSTDv06_isError(dctx->headerSize)) return dctx->headerSize;
-        memcpy(dctx->headerBuffer, src, ZSTDv06_frameHeaderSize_min);
-        if (dctx->headerSize > ZSTDv06_frameHeaderSize_min) {
-            dctx->expected = dctx->headerSize - ZSTDv06_frameHeaderSize_min;
-            dctx->stage = ZSTDds_decodeFrameHeader;
-            return 0;
-        }
-        dctx->expected = 0;   /* not necessary to copy more */
+/*_****************************** 
+*  Streaming Decompression API 
+********************************/ 
+size_t ZSTDv06_nextSrcSizeToDecompress(ZSTDv06_DCtx* dctx) 
+{ 
+    return dctx->expected; 
+} 
+ 
+size_t ZSTDv06_decompressContinue(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    /* Sanity check */ 
+    if (srcSize != dctx->expected) return ERROR(srcSize_wrong); 
+    if (dstCapacity) ZSTDv06_checkContinuity(dctx, dst); 
+ 
+    /* Decompress : frame header; part 1 */ 
+    switch (dctx->stage) 
+    { 
+    case ZSTDds_getFrameHeaderSize : 
+        if (srcSize != ZSTDv06_frameHeaderSize_min) return ERROR(srcSize_wrong);   /* impossible */ 
+        dctx->headerSize = ZSTDv06_frameHeaderSize(src, ZSTDv06_frameHeaderSize_min); 
+        if (ZSTDv06_isError(dctx->headerSize)) return dctx->headerSize; 
+        memcpy(dctx->headerBuffer, src, ZSTDv06_frameHeaderSize_min); 
+        if (dctx->headerSize > ZSTDv06_frameHeaderSize_min) { 
+            dctx->expected = dctx->headerSize - ZSTDv06_frameHeaderSize_min; 
+            dctx->stage = ZSTDds_decodeFrameHeader; 
+            return 0; 
+        } 
+        dctx->expected = 0;   /* not necessary to copy more */ 
 	/* fall-through */
-    case ZSTDds_decodeFrameHeader:
-        {   size_t result;
-            memcpy(dctx->headerBuffer + ZSTDv06_frameHeaderSize_min, src, dctx->expected);
-            result = ZSTDv06_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize);
-            if (ZSTDv06_isError(result)) return result;
-            dctx->expected = ZSTDv06_blockHeaderSize;
-            dctx->stage = ZSTDds_decodeBlockHeader;
-            return 0;
-        }
-    case ZSTDds_decodeBlockHeader:
-        {   blockProperties_t bp;
-            size_t const cBlockSize = ZSTDv06_getcBlockSize(src, ZSTDv06_blockHeaderSize, &bp);
-            if (ZSTDv06_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:
-                rSize = ZSTDv06_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
-                break;
-            case bt_raw :
-                rSize = ZSTDv06_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 = ZSTDv06_blockHeaderSize;
-            dctx->previousDstEnd = (char*)dst + rSize;
-            return rSize;
-        }
-    default:
-        return ERROR(GENERIC);   /* impossible */
-    }
-}
-
-
-static void ZSTDv06_refDictContent(ZSTDv06_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 ZSTDv06_loadEntropy(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    size_t hSize, offcodeHeaderSize, matchlengthHeaderSize, litlengthHeaderSize;
-
-    hSize = HUFv06_readDTableX4(dctx->hufTableX4, dict, dictSize);
-    if (HUFv06_isError(hSize)) return ERROR(dictionary_corrupted);
-    dict = (const char*)dict + hSize;
-    dictSize -= hSize;
-
-    {   short offcodeNCount[MaxOff+1];
+    case ZSTDds_decodeFrameHeader: 
+        {   size_t result; 
+            memcpy(dctx->headerBuffer + ZSTDv06_frameHeaderSize_min, src, dctx->expected); 
+            result = ZSTDv06_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize); 
+            if (ZSTDv06_isError(result)) return result; 
+            dctx->expected = ZSTDv06_blockHeaderSize; 
+            dctx->stage = ZSTDds_decodeBlockHeader; 
+            return 0; 
+        } 
+    case ZSTDds_decodeBlockHeader: 
+        {   blockProperties_t bp; 
+            size_t const cBlockSize = ZSTDv06_getcBlockSize(src, ZSTDv06_blockHeaderSize, &bp); 
+            if (ZSTDv06_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: 
+                rSize = ZSTDv06_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize); 
+                break; 
+            case bt_raw : 
+                rSize = ZSTDv06_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 = ZSTDv06_blockHeaderSize; 
+            dctx->previousDstEnd = (char*)dst + rSize; 
+            return rSize; 
+        } 
+    default: 
+        return ERROR(GENERIC);   /* impossible */ 
+    } 
+} 
+ 
+ 
+static void ZSTDv06_refDictContent(ZSTDv06_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 ZSTDv06_loadEntropy(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
+    size_t hSize, offcodeHeaderSize, matchlengthHeaderSize, litlengthHeaderSize; 
+ 
+    hSize = HUFv06_readDTableX4(dctx->hufTableX4, dict, dictSize); 
+    if (HUFv06_isError(hSize)) return ERROR(dictionary_corrupted); 
+    dict = (const char*)dict + hSize; 
+    dictSize -= hSize; 
+ 
+    {   short offcodeNCount[MaxOff+1]; 
         U32 offcodeMaxValue=MaxOff, offcodeLog;
-        offcodeHeaderSize = FSEv06_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dict, dictSize);
-        if (FSEv06_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);
+        offcodeHeaderSize = FSEv06_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dict, dictSize); 
+        if (FSEv06_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted); 
         if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted);
-        { size_t const errorCode = FSEv06_buildDTable(dctx->OffTable, offcodeNCount, offcodeMaxValue, offcodeLog);
-          if (FSEv06_isError(errorCode)) return ERROR(dictionary_corrupted); }
-        dict = (const char*)dict + offcodeHeaderSize;
-        dictSize -= offcodeHeaderSize;
-    }
-
-    {   short matchlengthNCount[MaxML+1];
+        { size_t const errorCode = FSEv06_buildDTable(dctx->OffTable, offcodeNCount, offcodeMaxValue, offcodeLog); 
+          if (FSEv06_isError(errorCode)) return ERROR(dictionary_corrupted); } 
+        dict = (const char*)dict + offcodeHeaderSize; 
+        dictSize -= offcodeHeaderSize; 
+    } 
+ 
+    {   short matchlengthNCount[MaxML+1]; 
         unsigned matchlengthMaxValue = MaxML, matchlengthLog;
-        matchlengthHeaderSize = FSEv06_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dict, dictSize);
-        if (FSEv06_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted);
+        matchlengthHeaderSize = FSEv06_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dict, dictSize); 
+        if (FSEv06_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted); 
         if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted);
-        { size_t const errorCode = FSEv06_buildDTable(dctx->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog);
-          if (FSEv06_isError(errorCode)) return ERROR(dictionary_corrupted); }
-        dict = (const char*)dict + matchlengthHeaderSize;
-        dictSize -= matchlengthHeaderSize;
-    }
-
-    {   short litlengthNCount[MaxLL+1];
+        { size_t const errorCode = FSEv06_buildDTable(dctx->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog); 
+          if (FSEv06_isError(errorCode)) return ERROR(dictionary_corrupted); } 
+        dict = (const char*)dict + matchlengthHeaderSize; 
+        dictSize -= matchlengthHeaderSize; 
+    } 
+ 
+    {   short litlengthNCount[MaxLL+1]; 
         unsigned litlengthMaxValue = MaxLL, litlengthLog;
-        litlengthHeaderSize = FSEv06_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dict, dictSize);
-        if (FSEv06_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted);
+        litlengthHeaderSize = FSEv06_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dict, dictSize); 
+        if (FSEv06_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted); 
         if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted);
-        { size_t const errorCode = FSEv06_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog);
-          if (FSEv06_isError(errorCode)) return ERROR(dictionary_corrupted); }
-    }
-
-    dctx->flagRepeatTable = 1;
-    return hSize + offcodeHeaderSize + matchlengthHeaderSize + litlengthHeaderSize;
-}
-
-static size_t ZSTDv06_decompress_insertDictionary(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    size_t eSize;
-    U32 const magic = MEM_readLE32(dict);
-    if (magic != ZSTDv06_DICT_MAGIC) {
-        /* pure content mode */
-        ZSTDv06_refDictContent(dctx, dict, dictSize);
-        return 0;
-    }
-    /* load entropy tables */
-    dict = (const char*)dict + 4;
-    dictSize -= 4;
-    eSize = ZSTDv06_loadEntropy(dctx, dict, dictSize);
-    if (ZSTDv06_isError(eSize)) return ERROR(dictionary_corrupted);
-
-    /* reference dictionary content */
-    dict = (const char*)dict + eSize;
-    dictSize -= eSize;
-    ZSTDv06_refDictContent(dctx, dict, dictSize);
-
-    return 0;
-}
-
-
-size_t ZSTDv06_decompressBegin_usingDict(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    { size_t const errorCode = ZSTDv06_decompressBegin(dctx);
-      if (ZSTDv06_isError(errorCode)) return errorCode; }
-
-    if (dict && dictSize) {
-        size_t const errorCode = ZSTDv06_decompress_insertDictionary(dctx, dict, dictSize);
-        if (ZSTDv06_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 homepage : http://www.zstd.net/
-*/
-
-
-/*-***************************************************************************
-*  Streaming decompression howto
-*
-*  A ZBUFFv06_DCtx object is required to track streaming operations.
-*  Use ZBUFFv06_createDCtx() and ZBUFFv06_freeDCtx() to create/release resources.
-*  Use ZBUFFv06_decompressInit() to start a new decompression operation,
-*   or ZBUFFv06_decompressInitDictionary() if decompression requires a dictionary.
-*  Note that ZBUFFv06_DCtx objects can be re-init multiple times.
-*
-*  Use ZBUFFv06_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 ZBUFFv06_isError().
-*
-*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv06_recommendedDInSize() and ZBUFFv06_recommendedDOutSize()
-*  output : ZBUFFv06_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
-*  input  : ZBUFFv06_recommendedDInSize == 128KB + 3;
-*           just follow indications from ZBUFFv06_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
-* *******************************************************************************/
-
-typedef enum { ZBUFFds_init, ZBUFFds_loadHeader,
-               ZBUFFds_read, ZBUFFds_load, ZBUFFds_flush } ZBUFFv06_dStage;
-
-/* *** Resource management *** */
-struct ZBUFFv06_DCtx_s {
-    ZSTDv06_DCtx* zd;
-    ZSTDv06_frameParams fParams;
-    ZBUFFv06_dStage stage;
-    char*  inBuff;
-    size_t inBuffSize;
-    size_t inPos;
-    char*  outBuff;
-    size_t outBuffSize;
-    size_t outStart;
-    size_t outEnd;
-    size_t blockSize;
-    BYTE headerBuffer[ZSTDv06_FRAMEHEADERSIZE_MAX];
-    size_t lhSize;
-};   /* typedef'd to ZBUFFv06_DCtx within "zstd_buffered.h" */
-
-
-ZBUFFv06_DCtx* ZBUFFv06_createDCtx(void)
-{
-    ZBUFFv06_DCtx* zbd = (ZBUFFv06_DCtx*)malloc(sizeof(ZBUFFv06_DCtx));
-    if (zbd==NULL) return NULL;
-    memset(zbd, 0, sizeof(*zbd));
-    zbd->zd = ZSTDv06_createDCtx();
-    zbd->stage = ZBUFFds_init;
-    return zbd;
-}
-
-size_t ZBUFFv06_freeDCtx(ZBUFFv06_DCtx* zbd)
-{
-    if (zbd==NULL) return 0;   /* support free on null */
-    ZSTDv06_freeDCtx(zbd->zd);
-    free(zbd->inBuff);
-    free(zbd->outBuff);
-    free(zbd);
-    return 0;
-}
-
-
-/* *** Initialization *** */
-
-size_t ZBUFFv06_decompressInitDictionary(ZBUFFv06_DCtx* zbd, const void* dict, size_t dictSize)
-{
-    zbd->stage = ZBUFFds_loadHeader;
-    zbd->lhSize = zbd->inPos = zbd->outStart = zbd->outEnd = 0;
-    return ZSTDv06_decompressBegin_usingDict(zbd->zd, dict, dictSize);
-}
-
-size_t ZBUFFv06_decompressInit(ZBUFFv06_DCtx* zbd)
-{
-    return ZBUFFv06_decompressInitDictionary(zbd, NULL, 0);
-}
-
-
-
-MEM_STATIC size_t ZBUFFv06_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    size_t length = MIN(dstCapacity, srcSize);
+        { size_t const errorCode = FSEv06_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog); 
+          if (FSEv06_isError(errorCode)) return ERROR(dictionary_corrupted); } 
+    } 
+ 
+    dctx->flagRepeatTable = 1; 
+    return hSize + offcodeHeaderSize + matchlengthHeaderSize + litlengthHeaderSize; 
+} 
+ 
+static size_t ZSTDv06_decompress_insertDictionary(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
+    size_t eSize; 
+    U32 const magic = MEM_readLE32(dict); 
+    if (magic != ZSTDv06_DICT_MAGIC) { 
+        /* pure content mode */ 
+        ZSTDv06_refDictContent(dctx, dict, dictSize); 
+        return 0; 
+    } 
+    /* load entropy tables */ 
+    dict = (const char*)dict + 4; 
+    dictSize -= 4; 
+    eSize = ZSTDv06_loadEntropy(dctx, dict, dictSize); 
+    if (ZSTDv06_isError(eSize)) return ERROR(dictionary_corrupted); 
+ 
+    /* reference dictionary content */ 
+    dict = (const char*)dict + eSize; 
+    dictSize -= eSize; 
+    ZSTDv06_refDictContent(dctx, dict, dictSize); 
+ 
+    return 0; 
+} 
+ 
+ 
+size_t ZSTDv06_decompressBegin_usingDict(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
+    { size_t const errorCode = ZSTDv06_decompressBegin(dctx); 
+      if (ZSTDv06_isError(errorCode)) return errorCode; } 
+ 
+    if (dict && dictSize) { 
+        size_t const errorCode = ZSTDv06_decompress_insertDictionary(dctx, dict, dictSize); 
+        if (ZSTDv06_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 homepage : http://www.zstd.net/ 
+*/ 
+ 
+ 
+/*-*************************************************************************** 
+*  Streaming decompression howto 
+* 
+*  A ZBUFFv06_DCtx object is required to track streaming operations. 
+*  Use ZBUFFv06_createDCtx() and ZBUFFv06_freeDCtx() to create/release resources. 
+*  Use ZBUFFv06_decompressInit() to start a new decompression operation, 
+*   or ZBUFFv06_decompressInitDictionary() if decompression requires a dictionary. 
+*  Note that ZBUFFv06_DCtx objects can be re-init multiple times. 
+* 
+*  Use ZBUFFv06_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 ZBUFFv06_isError(). 
+* 
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv06_recommendedDInSize() and ZBUFFv06_recommendedDOutSize() 
+*  output : ZBUFFv06_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded. 
+*  input  : ZBUFFv06_recommendedDInSize == 128KB + 3; 
+*           just follow indications from ZBUFFv06_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 . 
+* *******************************************************************************/ 
+ 
+typedef enum { ZBUFFds_init, ZBUFFds_loadHeader, 
+               ZBUFFds_read, ZBUFFds_load, ZBUFFds_flush } ZBUFFv06_dStage; 
+ 
+/* *** Resource management *** */ 
+struct ZBUFFv06_DCtx_s { 
+    ZSTDv06_DCtx* zd; 
+    ZSTDv06_frameParams fParams; 
+    ZBUFFv06_dStage stage; 
+    char*  inBuff; 
+    size_t inBuffSize; 
+    size_t inPos; 
+    char*  outBuff; 
+    size_t outBuffSize; 
+    size_t outStart; 
+    size_t outEnd; 
+    size_t blockSize; 
+    BYTE headerBuffer[ZSTDv06_FRAMEHEADERSIZE_MAX]; 
+    size_t lhSize; 
+};   /* typedef'd to ZBUFFv06_DCtx within "zstd_buffered.h" */ 
+ 
+ 
+ZBUFFv06_DCtx* ZBUFFv06_createDCtx(void) 
+{ 
+    ZBUFFv06_DCtx* zbd = (ZBUFFv06_DCtx*)malloc(sizeof(ZBUFFv06_DCtx)); 
+    if (zbd==NULL) return NULL; 
+    memset(zbd, 0, sizeof(*zbd)); 
+    zbd->zd = ZSTDv06_createDCtx(); 
+    zbd->stage = ZBUFFds_init; 
+    return zbd; 
+} 
+ 
+size_t ZBUFFv06_freeDCtx(ZBUFFv06_DCtx* zbd) 
+{ 
+    if (zbd==NULL) return 0;   /* support free on null */ 
+    ZSTDv06_freeDCtx(zbd->zd); 
+    free(zbd->inBuff); 
+    free(zbd->outBuff); 
+    free(zbd); 
+    return 0; 
+} 
+ 
+ 
+/* *** Initialization *** */ 
+ 
+size_t ZBUFFv06_decompressInitDictionary(ZBUFFv06_DCtx* zbd, const void* dict, size_t dictSize) 
+{ 
+    zbd->stage = ZBUFFds_loadHeader; 
+    zbd->lhSize = zbd->inPos = zbd->outStart = zbd->outEnd = 0; 
+    return ZSTDv06_decompressBegin_usingDict(zbd->zd, dict, dictSize); 
+} 
+ 
+size_t ZBUFFv06_decompressInit(ZBUFFv06_DCtx* zbd) 
+{ 
+    return ZBUFFv06_decompressInitDictionary(zbd, NULL, 0); 
+} 
+ 
+ 
+ 
+MEM_STATIC size_t ZBUFFv06_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    size_t length = MIN(dstCapacity, srcSize); 
     if (length > 0) {
         memcpy(dst, src, length);
     }
-    return length;
-}
-
-
-/* *** Decompression *** */
-
-size_t ZBUFFv06_decompressContinue(ZBUFFv06_DCtx* zbd,
-                                void* dst, size_t* dstCapacityPtr,
-                          const void* src, size_t* srcSizePtr)
-{
-    const char* const istart = (const char*)src;
-    const char* const iend = istart + *srcSizePtr;
-    const char* ip = istart;
-    char* const ostart = (char*)dst;
-    char* const oend = ostart + *dstCapacityPtr;
-    char* op = ostart;
-    U32 notDone = 1;
-
-    while (notDone) {
-        switch(zbd->stage)
-        {
-        case ZBUFFds_init :
-            return ERROR(init_missing);
-
-        case ZBUFFds_loadHeader :
-            {   size_t const hSize = ZSTDv06_getFrameParams(&(zbd->fParams), zbd->headerBuffer, zbd->lhSize);
-                if (hSize != 0) {
-                    size_t const toLoad = hSize - zbd->lhSize;   /* if hSize!=0, hSize > zbd->lhSize */
-                    if (ZSTDv06_isError(hSize)) return hSize;
-                    if (toLoad > (size_t)(iend-ip)) {   /* not enough input to load full header */
-                        memcpy(zbd->headerBuffer + zbd->lhSize, ip, iend-ip);
+    return length; 
+} 
+ 
+ 
+/* *** Decompression *** */ 
+ 
+size_t ZBUFFv06_decompressContinue(ZBUFFv06_DCtx* zbd, 
+                                void* dst, size_t* dstCapacityPtr, 
+                          const void* src, size_t* srcSizePtr) 
+{ 
+    const char* const istart = (const char*)src; 
+    const char* const iend = istart + *srcSizePtr; 
+    const char* ip = istart; 
+    char* const ostart = (char*)dst; 
+    char* const oend = ostart + *dstCapacityPtr; 
+    char* op = ostart; 
+    U32 notDone = 1; 
+ 
+    while (notDone) { 
+        switch(zbd->stage) 
+        { 
+        case ZBUFFds_init : 
+            return ERROR(init_missing); 
+ 
+        case ZBUFFds_loadHeader : 
+            {   size_t const hSize = ZSTDv06_getFrameParams(&(zbd->fParams), zbd->headerBuffer, zbd->lhSize); 
+                if (hSize != 0) { 
+                    size_t const toLoad = hSize - zbd->lhSize;   /* if hSize!=0, hSize > zbd->lhSize */ 
+                    if (ZSTDv06_isError(hSize)) return hSize; 
+                    if (toLoad > (size_t)(iend-ip)) {   /* not enough input to load full header */ 
+                        memcpy(zbd->headerBuffer + zbd->lhSize, ip, iend-ip); 
                         zbd->lhSize += iend-ip;
-                        *dstCapacityPtr = 0;
-                        return (hSize - zbd->lhSize) + ZSTDv06_blockHeaderSize;   /* remaining header bytes + next block header */
-                    }
-                    memcpy(zbd->headerBuffer + zbd->lhSize, ip, toLoad); zbd->lhSize = hSize; ip += toLoad;
-                    break;
-            }   }
-
-            /* Consume header */
-            {   size_t const h1Size = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);  /* == ZSTDv06_frameHeaderSize_min */
-                size_t const h1Result = ZSTDv06_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer, h1Size);
-                if (ZSTDv06_isError(h1Result)) return h1Result;
-                if (h1Size < zbd->lhSize) {   /* long header */
-                    size_t const h2Size = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);
-                    size_t const h2Result = ZSTDv06_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer+h1Size, h2Size);
-                    if (ZSTDv06_isError(h2Result)) return h2Result;
-            }   }
-
-            /* Frame header instruct buffer sizes */
-            {   size_t const blockSize = MIN(1 << zbd->fParams.windowLog, ZSTDv06_BLOCKSIZE_MAX);
-                zbd->blockSize = blockSize;
-                if (zbd->inBuffSize < blockSize) {
-                    free(zbd->inBuff);
-                    zbd->inBuffSize = blockSize;
-                    zbd->inBuff = (char*)malloc(blockSize);
-                    if (zbd->inBuff == NULL) return ERROR(memory_allocation);
-                }
+                        *dstCapacityPtr = 0; 
+                        return (hSize - zbd->lhSize) + ZSTDv06_blockHeaderSize;   /* remaining header bytes + next block header */ 
+                    } 
+                    memcpy(zbd->headerBuffer + zbd->lhSize, ip, toLoad); zbd->lhSize = hSize; ip += toLoad; 
+                    break; 
+            }   } 
+ 
+            /* Consume header */ 
+            {   size_t const h1Size = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);  /* == ZSTDv06_frameHeaderSize_min */ 
+                size_t const h1Result = ZSTDv06_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer, h1Size); 
+                if (ZSTDv06_isError(h1Result)) return h1Result; 
+                if (h1Size < zbd->lhSize) {   /* long header */ 
+                    size_t const h2Size = ZSTDv06_nextSrcSizeToDecompress(zbd->zd); 
+                    size_t const h2Result = ZSTDv06_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer+h1Size, h2Size); 
+                    if (ZSTDv06_isError(h2Result)) return h2Result; 
+            }   } 
+ 
+            /* Frame header instruct buffer sizes */ 
+            {   size_t const blockSize = MIN(1 << zbd->fParams.windowLog, ZSTDv06_BLOCKSIZE_MAX); 
+                zbd->blockSize = blockSize; 
+                if (zbd->inBuffSize < blockSize) { 
+                    free(zbd->inBuff); 
+                    zbd->inBuffSize = blockSize; 
+                    zbd->inBuff = (char*)malloc(blockSize); 
+                    if (zbd->inBuff == NULL) return ERROR(memory_allocation); 
+                } 
                 {   size_t const neededOutSize = ((size_t)1 << zbd->fParams.windowLog) + blockSize + WILDCOPY_OVERLENGTH * 2;
-                    if (zbd->outBuffSize < neededOutSize) {
-                        free(zbd->outBuff);
-                        zbd->outBuffSize = neededOutSize;
-                        zbd->outBuff = (char*)malloc(neededOutSize);
-                        if (zbd->outBuff == NULL) return ERROR(memory_allocation);
-            }   }   }
-            zbd->stage = ZBUFFds_read;
+                    if (zbd->outBuffSize < neededOutSize) { 
+                        free(zbd->outBuff); 
+                        zbd->outBuffSize = neededOutSize; 
+                        zbd->outBuff = (char*)malloc(neededOutSize); 
+                        if (zbd->outBuff == NULL) return ERROR(memory_allocation); 
+            }   }   } 
+            zbd->stage = ZBUFFds_read; 
 	    /* fall-through */
-        case ZBUFFds_read:
-            {   size_t const neededInSize = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);
-                if (neededInSize==0) {  /* end of frame */
-                    zbd->stage = ZBUFFds_init;
-                    notDone = 0;
-                    break;
-                }
-                if ((size_t)(iend-ip) >= neededInSize) {  /* decode directly from src */
-                    size_t const decodedSize = ZSTDv06_decompressContinue(zbd->zd,
-                        zbd->outBuff + zbd->outStart, zbd->outBuffSize - zbd->outStart,
-                        ip, neededInSize);
-                    if (ZSTDv06_isError(decodedSize)) return decodedSize;
-                    ip += neededInSize;
-                    if (!decodedSize) break;   /* this was just a header */
-                    zbd->outEnd = zbd->outStart +  decodedSize;
-                    zbd->stage = ZBUFFds_flush;
-                    break;
-                }
-                if (ip==iend) { notDone = 0; break; }   /* no more input */
-                zbd->stage = ZBUFFds_load;
-            }
+        case ZBUFFds_read: 
+            {   size_t const neededInSize = ZSTDv06_nextSrcSizeToDecompress(zbd->zd); 
+                if (neededInSize==0) {  /* end of frame */ 
+                    zbd->stage = ZBUFFds_init; 
+                    notDone = 0; 
+                    break; 
+                } 
+                if ((size_t)(iend-ip) >= neededInSize) {  /* decode directly from src */ 
+                    size_t const decodedSize = ZSTDv06_decompressContinue(zbd->zd, 
+                        zbd->outBuff + zbd->outStart, zbd->outBuffSize - zbd->outStart, 
+                        ip, neededInSize); 
+                    if (ZSTDv06_isError(decodedSize)) return decodedSize; 
+                    ip += neededInSize; 
+                    if (!decodedSize) break;   /* this was just a header */ 
+                    zbd->outEnd = zbd->outStart +  decodedSize; 
+                    zbd->stage = ZBUFFds_flush; 
+                    break; 
+                } 
+                if (ip==iend) { notDone = 0; break; }   /* no more input */ 
+                zbd->stage = ZBUFFds_load; 
+            } 
 	    /* fall-through */
-        case ZBUFFds_load:
-            {   size_t const neededInSize = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);
-                size_t const toLoad = neededInSize - zbd->inPos;   /* should always be <= remaining space within inBuff */
-                size_t loadedSize;
-                if (toLoad > zbd->inBuffSize - zbd->inPos) return ERROR(corruption_detected);   /* should never happen */
-                loadedSize = ZBUFFv06_limitCopy(zbd->inBuff + zbd->inPos, toLoad, ip, iend-ip);
-                ip += loadedSize;
-                zbd->inPos += loadedSize;
-                if (loadedSize < toLoad) { notDone = 0; break; }   /* not enough input, wait for more */
-
-                /* decode loaded input */
-                {   size_t const decodedSize = ZSTDv06_decompressContinue(zbd->zd,
-                        zbd->outBuff + zbd->outStart, zbd->outBuffSize - zbd->outStart,
-                        zbd->inBuff, neededInSize);
-                    if (ZSTDv06_isError(decodedSize)) return decodedSize;
-                    zbd->inPos = 0;   /* input is consumed */
-                    if (!decodedSize) { zbd->stage = ZBUFFds_read; break; }   /* this was just a header */
-                    zbd->outEnd = zbd->outStart +  decodedSize;
-                    zbd->stage = ZBUFFds_flush;
+        case ZBUFFds_load: 
+            {   size_t const neededInSize = ZSTDv06_nextSrcSizeToDecompress(zbd->zd); 
+                size_t const toLoad = neededInSize - zbd->inPos;   /* should always be <= remaining space within inBuff */ 
+                size_t loadedSize; 
+                if (toLoad > zbd->inBuffSize - zbd->inPos) return ERROR(corruption_detected);   /* should never happen */ 
+                loadedSize = ZBUFFv06_limitCopy(zbd->inBuff + zbd->inPos, toLoad, ip, iend-ip); 
+                ip += loadedSize; 
+                zbd->inPos += loadedSize; 
+                if (loadedSize < toLoad) { notDone = 0; break; }   /* not enough input, wait for more */ 
+ 
+                /* decode loaded input */ 
+                {   size_t const decodedSize = ZSTDv06_decompressContinue(zbd->zd, 
+                        zbd->outBuff + zbd->outStart, zbd->outBuffSize - zbd->outStart, 
+                        zbd->inBuff, neededInSize); 
+                    if (ZSTDv06_isError(decodedSize)) return decodedSize; 
+                    zbd->inPos = 0;   /* input is consumed */ 
+                    if (!decodedSize) { zbd->stage = ZBUFFds_read; break; }   /* this was just a header */ 
+                    zbd->outEnd = zbd->outStart +  decodedSize; 
+                    zbd->stage = ZBUFFds_flush; 
                     /* break; */ /* ZBUFFds_flush follows */
                 }
 	    }
 	    /* fall-through */
-        case ZBUFFds_flush:
-            {   size_t const toFlushSize = zbd->outEnd - zbd->outStart;
-                size_t const flushedSize = ZBUFFv06_limitCopy(op, oend-op, zbd->outBuff + zbd->outStart, toFlushSize);
-                op += flushedSize;
-                zbd->outStart += flushedSize;
-                if (flushedSize == toFlushSize) {
-                    zbd->stage = ZBUFFds_read;
-                    if (zbd->outStart + zbd->blockSize > zbd->outBuffSize)
-                        zbd->outStart = zbd->outEnd = 0;
-                    break;
-                }
-                /* cannot flush everything */
-                notDone = 0;
-                break;
-            }
-        default: return ERROR(GENERIC);   /* impossible */
-    }   }
-
-    /* result */
-    *srcSizePtr = ip-istart;
-    *dstCapacityPtr = op-ostart;
-    {   size_t nextSrcSizeHint = ZSTDv06_nextSrcSizeToDecompress(zbd->zd);
-        if (nextSrcSizeHint > ZSTDv06_blockHeaderSize) nextSrcSizeHint+= ZSTDv06_blockHeaderSize;   /* get following block header too */
-        nextSrcSizeHint -= zbd->inPos;   /* already loaded*/
-        return nextSrcSizeHint;
-    }
-}
-
-
-
-/* *************************************
-*  Tool functions
-***************************************/
-size_t ZBUFFv06_recommendedDInSize(void)  { return ZSTDv06_BLOCKSIZE_MAX + ZSTDv06_blockHeaderSize /* block header size*/ ; }
-size_t ZBUFFv06_recommendedDOutSize(void) { return ZSTDv06_BLOCKSIZE_MAX; }
+        case ZBUFFds_flush: 
+            {   size_t const toFlushSize = zbd->outEnd - zbd->outStart; 
+                size_t const flushedSize = ZBUFFv06_limitCopy(op, oend-op, zbd->outBuff + zbd->outStart, toFlushSize); 
+                op += flushedSize; 
+                zbd->outStart += flushedSize; 
+                if (flushedSize == toFlushSize) { 
+                    zbd->stage = ZBUFFds_read; 
+                    if (zbd->outStart + zbd->blockSize > zbd->outBuffSize) 
+                        zbd->outStart = zbd->outEnd = 0; 
+                    break; 
+                } 
+                /* cannot flush everything */ 
+                notDone = 0; 
+                break; 
+            } 
+        default: return ERROR(GENERIC);   /* impossible */ 
+    }   } 
+ 
+    /* result */ 
+    *srcSizePtr = ip-istart; 
+    *dstCapacityPtr = op-ostart; 
+    {   size_t nextSrcSizeHint = ZSTDv06_nextSrcSizeToDecompress(zbd->zd); 
+        if (nextSrcSizeHint > ZSTDv06_blockHeaderSize) nextSrcSizeHint+= ZSTDv06_blockHeaderSize;   /* get following block header too */ 
+        nextSrcSizeHint -= zbd->inPos;   /* already loaded*/ 
+        return nextSrcSizeHint; 
+    } 
+} 
+ 
+ 
+ 
+/* ************************************* 
+*  Tool functions 
+***************************************/ 
+size_t ZBUFFv06_recommendedDInSize(void)  { return ZSTDv06_BLOCKSIZE_MAX + ZSTDv06_blockHeaderSize /* block header size*/ ; } 
+size_t ZBUFFv06_recommendedDOutSize(void) { return ZSTDv06_BLOCKSIZE_MAX; } 
diff --git a/contrib/libs/zstd/lib/legacy/zstd_v06.h b/contrib/libs/zstd/lib/legacy/zstd_v06.h
index 9e32b76e08..3eeb7f6ac1 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_v06.h
+++ b/contrib/libs/zstd/lib/legacy/zstd_v06.h
@@ -7,41 +7,41 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-#ifndef ZSTDv06_H
-#define ZSTDv06_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
+ 
+#ifndef ZSTDv06_H 
+#define ZSTDv06_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
 /*======  Dependency  ======*/
-#include <stddef.h>   /* size_t */
-
-
+#include <stddef.h>   /* size_t */ 
+ 
+ 
 /*======  Export for Windows  ======*/
-/*!
-*  ZSTDv06_DLL_EXPORT :
-*  Enable exporting of functions when building a Windows DLL
-*/
-#if defined(_WIN32) && defined(ZSTDv06_DLL_EXPORT) && (ZSTDv06_DLL_EXPORT==1)
+/*! 
+*  ZSTDv06_DLL_EXPORT : 
+*  Enable exporting of functions when building a Windows DLL 
+*/ 
+#if defined(_WIN32) && defined(ZSTDv06_DLL_EXPORT) && (ZSTDv06_DLL_EXPORT==1) 
 #  define ZSTDLIBv06_API __declspec(dllexport)
-#else
+#else 
 #  define ZSTDLIBv06_API
-#endif
-
-
-/* *************************************
-*  Simple functions
-***************************************/
-/*! ZSTDv06_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 ZSTDv06_isError()) */
+#endif 
+ 
+ 
+/* ************************************* 
+*  Simple functions 
+***************************************/ 
+/*! ZSTDv06_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 ZSTDv06_isError()) */ 
 ZSTDLIBv06_API size_t ZSTDv06_decompress( void* dst, size_t dstCapacity,
                                     const void* src, size_t compressedSize);
-
+ 
 /**
 ZSTDv06_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.6.x format
     srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
@@ -54,119 +54,119 @@ ZSTDv06_findFrameSizeInfoLegacy() : get the source length and decompressed bound
 */
 void ZSTDv06_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
                                      size_t* cSize, unsigned long long* dBound);
-
-/* *************************************
-*  Helper functions
-***************************************/
+ 
+/* ************************************* 
+*  Helper functions 
+***************************************/ 
 ZSTDLIBv06_API size_t      ZSTDv06_compressBound(size_t srcSize); /*!< maximum compressed size (worst case scenario) */
-
-/* Error Management */
+ 
+/* Error Management */ 
 ZSTDLIBv06_API unsigned    ZSTDv06_isError(size_t code);          /*!< tells if a `size_t` function result is an error code */
 ZSTDLIBv06_API const char* ZSTDv06_getErrorName(size_t code);     /*!< provides readable string for an error code */
-
-
-/* *************************************
-*  Explicit memory management
-***************************************/
-/** Decompression context */
-typedef struct ZSTDv06_DCtx_s ZSTDv06_DCtx;
+ 
+ 
+/* ************************************* 
+*  Explicit memory management 
+***************************************/ 
+/** Decompression context */ 
+typedef struct ZSTDv06_DCtx_s ZSTDv06_DCtx; 
 ZSTDLIBv06_API ZSTDv06_DCtx* ZSTDv06_createDCtx(void);
 ZSTDLIBv06_API size_t     ZSTDv06_freeDCtx(ZSTDv06_DCtx* dctx);      /*!< @return : errorCode */
-
-/** ZSTDv06_decompressDCtx() :
-*   Same as ZSTDv06_decompress(), but requires an already allocated ZSTDv06_DCtx (see ZSTDv06_createDCtx()) */
+ 
+/** ZSTDv06_decompressDCtx() : 
+*   Same as ZSTDv06_decompress(), but requires an already allocated ZSTDv06_DCtx (see ZSTDv06_createDCtx()) */ 
 ZSTDLIBv06_API size_t ZSTDv06_decompressDCtx(ZSTDv06_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-
-/*-***********************
-*  Dictionary API
-*************************/
-/*! ZSTDv06_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 ZSTDv06_decompressDCtx() */
+ 
+ 
+/*-*********************** 
+*  Dictionary API 
+*************************/ 
+/*! ZSTDv06_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 ZSTDv06_decompressDCtx() */ 
 ZSTDLIBv06_API size_t ZSTDv06_decompress_usingDict(ZSTDv06_DCtx* dctx,
                                                    void* dst, size_t dstCapacity,
                                              const void* src, size_t srcSize,
                                              const void* dict,size_t dictSize);
-
-
-/*-************************
-*  Advanced Streaming API
-***************************/
-struct ZSTDv06_frameParams_s { unsigned long long frameContentSize; unsigned windowLog; };
-typedef struct ZSTDv06_frameParams_s ZSTDv06_frameParams;
-
+ 
+ 
+/*-************************ 
+*  Advanced Streaming API 
+***************************/ 
+struct ZSTDv06_frameParams_s { unsigned long long frameContentSize; unsigned windowLog; }; 
+typedef struct ZSTDv06_frameParams_s ZSTDv06_frameParams; 
+ 
 ZSTDLIBv06_API size_t ZSTDv06_getFrameParams(ZSTDv06_frameParams* fparamsPtr, const void* src, size_t srcSize);   /**< doesn't consume input */
 ZSTDLIBv06_API size_t ZSTDv06_decompressBegin_usingDict(ZSTDv06_DCtx* dctx, const void* dict, size_t dictSize);
 ZSTDLIBv06_API void   ZSTDv06_copyDCtx(ZSTDv06_DCtx* dctx, const ZSTDv06_DCtx* preparedDCtx);
-
+ 
 ZSTDLIBv06_API size_t ZSTDv06_nextSrcSizeToDecompress(ZSTDv06_DCtx* dctx);
 ZSTDLIBv06_API size_t ZSTDv06_decompressContinue(ZSTDv06_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-
-
-/* *************************************
-*  ZBUFF API
-***************************************/
-
-typedef struct ZBUFFv06_DCtx_s ZBUFFv06_DCtx;
+ 
+ 
+ 
+/* ************************************* 
+*  ZBUFF API 
+***************************************/ 
+ 
+typedef struct ZBUFFv06_DCtx_s ZBUFFv06_DCtx; 
 ZSTDLIBv06_API ZBUFFv06_DCtx* ZBUFFv06_createDCtx(void);
 ZSTDLIBv06_API size_t         ZBUFFv06_freeDCtx(ZBUFFv06_DCtx* dctx);
-
+ 
 ZSTDLIBv06_API size_t ZBUFFv06_decompressInit(ZBUFFv06_DCtx* dctx);
 ZSTDLIBv06_API size_t ZBUFFv06_decompressInitDictionary(ZBUFFv06_DCtx* dctx, const void* dict, size_t dictSize);
-
+ 
 ZSTDLIBv06_API size_t ZBUFFv06_decompressContinue(ZBUFFv06_DCtx* dctx,
                                                   void* dst, size_t* dstCapacityPtr,
                                             const void* src, size_t* srcSizePtr);
-
-/*-***************************************************************************
-*  Streaming decompression howto
-*
-*  A ZBUFFv06_DCtx object is required to track streaming operations.
-*  Use ZBUFFv06_createDCtx() and ZBUFFv06_freeDCtx() to create/release resources.
-*  Use ZBUFFv06_decompressInit() to start a new decompression operation,
-*   or ZBUFFv06_decompressInitDictionary() if decompression requires a dictionary.
-*  Note that ZBUFFv06_DCtx objects can be re-init multiple times.
-*
-*  Use ZBUFFv06_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 ZBUFFv06_isError().
-*
-*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv06_recommendedDInSize() and ZBUFFv06_recommendedDOutSize()
-*  output : ZBUFFv06_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
-*  input  : ZBUFFv06_recommendedDInSize == 128KB + 3;
-*           just follow indications from ZBUFFv06_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
-* *******************************************************************************/
-
-
-/* *************************************
-*  Tool functions
-***************************************/
+ 
+/*-*************************************************************************** 
+*  Streaming decompression howto 
+* 
+*  A ZBUFFv06_DCtx object is required to track streaming operations. 
+*  Use ZBUFFv06_createDCtx() and ZBUFFv06_freeDCtx() to create/release resources. 
+*  Use ZBUFFv06_decompressInit() to start a new decompression operation, 
+*   or ZBUFFv06_decompressInitDictionary() if decompression requires a dictionary. 
+*  Note that ZBUFFv06_DCtx objects can be re-init multiple times. 
+* 
+*  Use ZBUFFv06_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 ZBUFFv06_isError(). 
+* 
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv06_recommendedDInSize() and ZBUFFv06_recommendedDOutSize() 
+*  output : ZBUFFv06_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded. 
+*  input  : ZBUFFv06_recommendedDInSize == 128KB + 3; 
+*           just follow indications from ZBUFFv06_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 . 
+* *******************************************************************************/ 
+ 
+ 
+/* ************************************* 
+*  Tool functions 
+***************************************/ 
 ZSTDLIBv06_API unsigned ZBUFFv06_isError(size_t errorCode);
 ZSTDLIBv06_API const char* ZBUFFv06_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 */
+ 
+/** Functions below provide recommended buffer sizes for Compression or Decompression operations. 
+*   These sizes are just hints, they tend to offer better latency */ 
 ZSTDLIBv06_API size_t ZBUFFv06_recommendedDInSize(void);
 ZSTDLIBv06_API size_t ZBUFFv06_recommendedDOutSize(void);
-
-
-/*-*************************************
-*  Constants
-***************************************/
-#define ZSTDv06_MAGICNUMBER 0xFD2FB526   /* v0.6 */
-
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* ZSTDv06_BUFFERED_H */
+ 
+ 
+/*-************************************* 
+*  Constants 
+***************************************/ 
+#define ZSTDv06_MAGICNUMBER 0xFD2FB526   /* v0.6 */ 
+ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* ZSTDv06_BUFFERED_H */ 
diff --git a/contrib/libs/zstd/lib/legacy/zstd_v07.c b/contrib/libs/zstd/lib/legacy/zstd_v07.c
index 189f6ede69..be7f90c1b6 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_v07.c
+++ b/contrib/libs/zstd/lib/legacy/zstd_v07.c
@@ -7,570 +7,570 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-
-/*- Dependencies -*/
-#include <stddef.h>     /* size_t, ptrdiff_t */
-#include <string.h>     /* memcpy */
-#include <stdlib.h>     /* malloc, free, qsort */
-
+ 
+ 
+/*- Dependencies -*/ 
+#include <stddef.h>     /* size_t, ptrdiff_t */ 
+#include <string.h>     /* memcpy */ 
+#include <stdlib.h>     /* malloc, free, qsort */ 
+ 
 #ifndef XXH_STATIC_LINKING_ONLY
 #  define XXH_STATIC_LINKING_ONLY    /* XXH64_state_t */
 #endif
 #include <contrib/libs/xxhash/xxhash.h>                  /* XXH64_* */
-#include "zstd_v07.h"
-
+#include "zstd_v07.h" 
+ 
 #define FSEv07_STATIC_LINKING_ONLY   /* FSEv07_MIN_TABLELOG */
 #define HUFv07_STATIC_LINKING_ONLY   /* HUFv07_TABLELOG_ABSOLUTEMAX */
-#define ZSTDv07_STATIC_LINKING_ONLY
-
+#define ZSTDv07_STATIC_LINKING_ONLY 
+ 
 #include "../common/error_private.h"
-
-
-#ifdef ZSTDv07_STATIC_LINKING_ONLY
-
-/* ====================================================================================
- * The definitions in this section are considered experimental.
- * They should never be used with a dynamic library, as they may change in the future.
- * They are provided for advanced usages.
- * Use them only in association with static linking.
- * ==================================================================================== */
-
-/*--- Constants ---*/
-#define ZSTDv07_MAGIC_SKIPPABLE_START  0x184D2A50U
-
-#define ZSTDv07_WINDOWLOG_MAX_32  25
-#define ZSTDv07_WINDOWLOG_MAX_64  27
-#define ZSTDv07_WINDOWLOG_MAX    ((U32)(MEM_32bits() ? ZSTDv07_WINDOWLOG_MAX_32 : ZSTDv07_WINDOWLOG_MAX_64))
-#define ZSTDv07_WINDOWLOG_MIN     18
-#define ZSTDv07_CHAINLOG_MAX     (ZSTDv07_WINDOWLOG_MAX+1)
-#define ZSTDv07_CHAINLOG_MIN       4
-#define ZSTDv07_HASHLOG_MAX       ZSTDv07_WINDOWLOG_MAX
-#define ZSTDv07_HASHLOG_MIN       12
-#define ZSTDv07_HASHLOG3_MAX      17
-#define ZSTDv07_SEARCHLOG_MAX    (ZSTDv07_WINDOWLOG_MAX-1)
-#define ZSTDv07_SEARCHLOG_MIN      1
-#define ZSTDv07_SEARCHLENGTH_MAX   7
-#define ZSTDv07_SEARCHLENGTH_MIN   3
-#define ZSTDv07_TARGETLENGTH_MIN   4
-#define ZSTDv07_TARGETLENGTH_MAX 999
-
-#define ZSTDv07_FRAMEHEADERSIZE_MAX 18    /* for static allocation */
-static const size_t ZSTDv07_frameHeaderSize_min = 5;
-static const size_t ZSTDv07_frameHeaderSize_max = ZSTDv07_FRAMEHEADERSIZE_MAX;
-static const size_t ZSTDv07_skippableHeaderSize = 8;  /* magic number + skippable frame length */
-
-
-/* custom memory allocation functions */
-typedef void* (*ZSTDv07_allocFunction) (void* opaque, size_t size);
-typedef void  (*ZSTDv07_freeFunction) (void* opaque, void* address);
-typedef struct { ZSTDv07_allocFunction customAlloc; ZSTDv07_freeFunction customFree; void* opaque; } ZSTDv07_customMem;
-
-
-/*--- Advanced Decompression functions ---*/
-
-/*! ZSTDv07_estimateDCtxSize() :
- *  Gives the potential amount of memory allocated to create a ZSTDv07_DCtx */
+ 
+
+#ifdef ZSTDv07_STATIC_LINKING_ONLY 
+ 
+/* ==================================================================================== 
+ * The definitions in this section are considered experimental. 
+ * They should never be used with a dynamic library, as they may change in the future. 
+ * They are provided for advanced usages. 
+ * Use them only in association with static linking. 
+ * ==================================================================================== */ 
+ 
+/*--- Constants ---*/ 
+#define ZSTDv07_MAGIC_SKIPPABLE_START  0x184D2A50U 
+ 
+#define ZSTDv07_WINDOWLOG_MAX_32  25 
+#define ZSTDv07_WINDOWLOG_MAX_64  27 
+#define ZSTDv07_WINDOWLOG_MAX    ((U32)(MEM_32bits() ? ZSTDv07_WINDOWLOG_MAX_32 : ZSTDv07_WINDOWLOG_MAX_64)) 
+#define ZSTDv07_WINDOWLOG_MIN     18 
+#define ZSTDv07_CHAINLOG_MAX     (ZSTDv07_WINDOWLOG_MAX+1) 
+#define ZSTDv07_CHAINLOG_MIN       4 
+#define ZSTDv07_HASHLOG_MAX       ZSTDv07_WINDOWLOG_MAX 
+#define ZSTDv07_HASHLOG_MIN       12 
+#define ZSTDv07_HASHLOG3_MAX      17 
+#define ZSTDv07_SEARCHLOG_MAX    (ZSTDv07_WINDOWLOG_MAX-1) 
+#define ZSTDv07_SEARCHLOG_MIN      1 
+#define ZSTDv07_SEARCHLENGTH_MAX   7 
+#define ZSTDv07_SEARCHLENGTH_MIN   3 
+#define ZSTDv07_TARGETLENGTH_MIN   4 
+#define ZSTDv07_TARGETLENGTH_MAX 999 
+ 
+#define ZSTDv07_FRAMEHEADERSIZE_MAX 18    /* for static allocation */ 
+static const size_t ZSTDv07_frameHeaderSize_min = 5; 
+static const size_t ZSTDv07_frameHeaderSize_max = ZSTDv07_FRAMEHEADERSIZE_MAX; 
+static const size_t ZSTDv07_skippableHeaderSize = 8;  /* magic number + skippable frame length */ 
+ 
+ 
+/* custom memory allocation functions */ 
+typedef void* (*ZSTDv07_allocFunction) (void* opaque, size_t size); 
+typedef void  (*ZSTDv07_freeFunction) (void* opaque, void* address); 
+typedef struct { ZSTDv07_allocFunction customAlloc; ZSTDv07_freeFunction customFree; void* opaque; } ZSTDv07_customMem; 
+ 
+ 
+/*--- Advanced Decompression functions ---*/ 
+ 
+/*! ZSTDv07_estimateDCtxSize() : 
+ *  Gives the potential amount of memory allocated to create a ZSTDv07_DCtx */ 
 ZSTDLIBv07_API size_t ZSTDv07_estimateDCtxSize(void);
-
-/*! ZSTDv07_createDCtx_advanced() :
- *  Create a ZSTD decompression context using external alloc and free functions */
+ 
+/*! ZSTDv07_createDCtx_advanced() : 
+ *  Create a ZSTD decompression context using external alloc and free functions */ 
 ZSTDLIBv07_API ZSTDv07_DCtx* ZSTDv07_createDCtx_advanced(ZSTDv07_customMem customMem);
-
-/*! ZSTDv07_sizeofDCtx() :
- *  Gives the amount of memory used by a given ZSTDv07_DCtx */
+ 
+/*! ZSTDv07_sizeofDCtx() : 
+ *  Gives the amount of memory used by a given ZSTDv07_DCtx */ 
 ZSTDLIBv07_API size_t ZSTDv07_sizeofDCtx(const ZSTDv07_DCtx* dctx);
-
-
-/* ******************************************************************
-*  Buffer-less streaming functions (synchronous mode)
-********************************************************************/
-
+ 
+ 
+/* ****************************************************************** 
+*  Buffer-less streaming functions (synchronous mode) 
+********************************************************************/ 
+ 
 ZSTDLIBv07_API size_t ZSTDv07_decompressBegin(ZSTDv07_DCtx* dctx);
 ZSTDLIBv07_API size_t ZSTDv07_decompressBegin_usingDict(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize);
 ZSTDLIBv07_API void   ZSTDv07_copyDCtx(ZSTDv07_DCtx* dctx, const ZSTDv07_DCtx* preparedDCtx);
-
+ 
 ZSTDLIBv07_API size_t ZSTDv07_nextSrcSizeToDecompress(ZSTDv07_DCtx* dctx);
 ZSTDLIBv07_API size_t ZSTDv07_decompressContinue(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-/*
-  Buffer-less streaming decompression (synchronous mode)
-
-  A ZSTDv07_DCtx object is required to track streaming operations.
-  Use ZSTDv07_createDCtx() / ZSTDv07_freeDCtx() to manage it.
-  A ZSTDv07_DCtx object can be re-used multiple times.
-
-  First optional operation is to retrieve frame parameters, using ZSTDv07_getFrameParams(), which doesn't consume the input.
-  It can provide the minimum size of rolling buffer required to properly decompress data (`windowSize`),
-  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 ZSTDv07_frameHeaderSize_min to ZSTDv07_frameHeaderSize_max (so if `srcSize` >= ZSTDv07_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 ZSTDv07_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 ZSTDv07_isError()
-
-  Start decompression, with ZSTDv07_decompressBegin() or ZSTDv07_decompressBegin_usingDict().
-  Alternatively, you can copy a prepared context, using ZSTDv07_copyDCtx().
-
-  Then use ZSTDv07_nextSrcSizeToDecompress() and ZSTDv07_decompressContinue() alternatively.
-  ZSTDv07_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTDv07_decompressContinue().
-  ZSTDv07_decompressContinue() requires this exact amount of bytes, or it will fail.
-
-  @result of ZSTDv07_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity).
-  It can be zero, which is not an error; it just means ZSTDv07_decompressContinue() has decoded some header.
-
-  ZSTDv07_decompressContinue() needs previous data blocks during decompression, up to `windowSize`.
-  They should preferably be located contiguously, prior to current block.
-  Alternatively, a round buffer of sufficient size is also possible. Sufficient size is determined by frame parameters.
-  ZSTDv07_decompressContinue() is very sensitive to contiguity,
-  if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,
-    or that previous contiguous segment is large enough to properly handle maximum back-reference.
-
-  A frame is fully decoded when ZSTDv07_nextSrcSizeToDecompress() returns zero.
-  Context can then be reset to start a new decompression.
-
-
-  == Special case : skippable frames ==
-
-  Skippable frames allow the integration of user-defined data into a flow of concatenated frames.
-  Skippable frames will be ignored (skipped) by a decompressor. The format of skippable frame is following:
-  a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F
-  b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits
-  c) Frame Content - any content (User Data) of length equal to Frame Size
-  For skippable frames ZSTDv07_decompressContinue() always returns 0.
-  For skippable frames ZSTDv07_getFrameParams() returns fparamsPtr->windowLog==0 what means that a frame is skippable.
-  It also returns Frame Size as fparamsPtr->frameContentSize.
-*/
-
-
-/* **************************************
-*  Block functions
-****************************************/
-/*! Block functions produce and decode raw zstd blocks, without frame metadata.
-    Frame metadata cost is typically ~18 bytes, which can be non-negligible for very small blocks (< 100 bytes).
-    User will have to take in charge required information to regenerate data, such as compressed and content sizes.
-
-    A few rules to respect :
-    - Compressing and decompressing require a context structure
-      + Use ZSTDv07_createCCtx() and ZSTDv07_createDCtx()
-    - It is necessary to init context before starting
-      + compression : ZSTDv07_compressBegin()
-      + decompression : ZSTDv07_decompressBegin()
-      + variants _usingDict() are also allowed
-      + copyCCtx() and copyDCtx() work too
-    - Block size is limited, it must be <= ZSTDv07_getBlockSizeMax()
-      + If you need to compress more, cut data into multiple blocks
-      + Consider using the regular ZSTDv07_compress() instead, as frame metadata costs become negligible when source size is large.
-    - When a block is considered not compressible enough, ZSTDv07_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
-      + ZSTDv07_decompressBlock() doesn't accept uncompressed data as input !!!
-      + In case of multiple successive blocks, decoder must be informed of uncompressed block existence to follow proper history.
-        Use ZSTDv07_insertBlock() in such a case.
-*/
-
-#define ZSTDv07_BLOCKSIZE_ABSOLUTEMAX (128 * 1024)   /* define, for static allocation */
+ 
+/* 
+  Buffer-less streaming decompression (synchronous mode) 
+ 
+  A ZSTDv07_DCtx object is required to track streaming operations. 
+  Use ZSTDv07_createDCtx() / ZSTDv07_freeDCtx() to manage it. 
+  A ZSTDv07_DCtx object can be re-used multiple times. 
+ 
+  First optional operation is to retrieve frame parameters, using ZSTDv07_getFrameParams(), which doesn't consume the input. 
+  It can provide the minimum size of rolling buffer required to properly decompress data (`windowSize`), 
+  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 ZSTDv07_frameHeaderSize_min to ZSTDv07_frameHeaderSize_max (so if `srcSize` >= ZSTDv07_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 ZSTDv07_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 ZSTDv07_isError() 
+ 
+  Start decompression, with ZSTDv07_decompressBegin() or ZSTDv07_decompressBegin_usingDict(). 
+  Alternatively, you can copy a prepared context, using ZSTDv07_copyDCtx(). 
+ 
+  Then use ZSTDv07_nextSrcSizeToDecompress() and ZSTDv07_decompressContinue() alternatively. 
+  ZSTDv07_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTDv07_decompressContinue(). 
+  ZSTDv07_decompressContinue() requires this exact amount of bytes, or it will fail. 
+ 
+  @result of ZSTDv07_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity). 
+  It can be zero, which is not an error; it just means ZSTDv07_decompressContinue() has decoded some header. 
+ 
+  ZSTDv07_decompressContinue() needs previous data blocks during decompression, up to `windowSize`. 
+  They should preferably be located contiguously, prior to current block. 
+  Alternatively, a round buffer of sufficient size is also possible. Sufficient size is determined by frame parameters. 
+  ZSTDv07_decompressContinue() is very sensitive to contiguity, 
+  if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place, 
+    or that previous contiguous segment is large enough to properly handle maximum back-reference. 
+ 
+  A frame is fully decoded when ZSTDv07_nextSrcSizeToDecompress() returns zero. 
+  Context can then be reset to start a new decompression. 
+ 
+ 
+  == Special case : skippable frames == 
+ 
+  Skippable frames allow the integration of user-defined data into a flow of concatenated frames. 
+  Skippable frames will be ignored (skipped) by a decompressor. The format of skippable frame is following: 
+  a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F 
+  b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits 
+  c) Frame Content - any content (User Data) of length equal to Frame Size 
+  For skippable frames ZSTDv07_decompressContinue() always returns 0. 
+  For skippable frames ZSTDv07_getFrameParams() returns fparamsPtr->windowLog==0 what means that a frame is skippable. 
+  It also returns Frame Size as fparamsPtr->frameContentSize. 
+*/ 
+ 
+ 
+/* ************************************** 
+*  Block functions 
+****************************************/ 
+/*! Block functions produce and decode raw zstd blocks, without frame metadata. 
+    Frame metadata cost is typically ~18 bytes, which can be non-negligible for very small blocks (< 100 bytes). 
+    User will have to take in charge required information to regenerate data, such as compressed and content sizes. 
+ 
+    A few rules to respect : 
+    - Compressing and decompressing require a context structure 
+      + Use ZSTDv07_createCCtx() and ZSTDv07_createDCtx() 
+    - It is necessary to init context before starting 
+      + compression : ZSTDv07_compressBegin() 
+      + decompression : ZSTDv07_decompressBegin() 
+      + variants _usingDict() are also allowed 
+      + copyCCtx() and copyDCtx() work too 
+    - Block size is limited, it must be <= ZSTDv07_getBlockSizeMax() 
+      + If you need to compress more, cut data into multiple blocks 
+      + Consider using the regular ZSTDv07_compress() instead, as frame metadata costs become negligible when source size is large. 
+    - When a block is considered not compressible enough, ZSTDv07_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 
+      + ZSTDv07_decompressBlock() doesn't accept uncompressed data as input !!! 
+      + In case of multiple successive blocks, decoder must be informed of uncompressed block existence to follow proper history. 
+        Use ZSTDv07_insertBlock() in such a case. 
+*/ 
+ 
+#define ZSTDv07_BLOCKSIZE_ABSOLUTEMAX (128 * 1024)   /* define, for static allocation */ 
 ZSTDLIBv07_API size_t ZSTDv07_decompressBlock(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
 ZSTDLIBv07_API size_t ZSTDv07_insertBlock(ZSTDv07_DCtx* dctx, const void* blockStart, size_t blockSize);  /**< insert block into `dctx` history. Useful for uncompressed blocks */
-
-
-#endif   /* ZSTDv07_STATIC_LINKING_ONLY */
-
-
-/* ******************************************************************
-   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
-
-/*-****************************************
-*  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
-
-
-/*-**************************************************************
-*  Basic Types
-*****************************************************************/
-#if  !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+ 
+ 
+#endif   /* ZSTDv07_STATIC_LINKING_ONLY */ 
+ 
+ 
+/* ****************************************************************** 
+   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 
+ 
+/*-**************************************** 
+*  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 
+ 
+ 
+/*-************************************************************** 
+*  Basic Types 
+*****************************************************************/ 
+#if  !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) ) 
 # if defined(_AIX)
 #  include <inttypes.h>
 # else
 #  include <stdint.h> /* intptr_t */
 # endif
-  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 */
+  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(__INTEL_COMPILER) || defined(__GNUC__) || defined(__ICCARM__)
-#    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 void MEM_write16(void* memPtr, U16 value) { *(U16*)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; }
-
-#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));
-}
-
-#endif /* MEM_FORCE_MEMORY_ACCESS */
-
-MEM_STATIC U32 MEM_swap32(U32 in)
-{
-#if defined(_MSC_VER)     /* Visual Studio */
-    return _byteswap_ulong(in);
+#    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 void MEM_write16(void* memPtr, U16 value) { *(U16*)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; } 
+ 
+#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)); 
+} 
+ 
+#endif /* MEM_FORCE_MEMORY_ACCESS */ 
+ 
+MEM_STATIC U32 MEM_swap32(U32 in) 
+{ 
+#if defined(_MSC_VER)     /* Visual Studio */ 
+    return _byteswap_ulong(in); 
 #elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)
-    return __builtin_bswap32(in);
-#else
-    return  ((in << 24) & 0xff000000 ) |
-            ((in <<  8) & 0x00ff0000 ) |
-            ((in >>  8) & 0x0000ff00 ) |
-            ((in >> 24) & 0x000000ff );
-#endif
-}
-
-MEM_STATIC U64 MEM_swap64(U64 in)
-{
-#if defined(_MSC_VER)     /* Visual Studio */
-    return _byteswap_uint64(in);
+    return __builtin_bswap32(in); 
+#else 
+    return  ((in << 24) & 0xff000000 ) | 
+            ((in <<  8) & 0x00ff0000 ) | 
+            ((in >>  8) & 0x0000ff00 ) | 
+            ((in >> 24) & 0x000000ff ); 
+#endif 
+} 
+ 
+MEM_STATIC U64 MEM_swap64(U64 in) 
+{ 
+#if defined(_MSC_VER)     /* Visual Studio */ 
+    return _byteswap_uint64(in); 
 #elif defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)
-    return __builtin_bswap64(in);
-#else
-    return  ((in << 56) & 0xff00000000000000ULL) |
-            ((in << 40) & 0x00ff000000000000ULL) |
-            ((in << 24) & 0x0000ff0000000000ULL) |
-            ((in << 8)  & 0x000000ff00000000ULL) |
-            ((in >> 8)  & 0x00000000ff000000ULL) |
-            ((in >> 24) & 0x0000000000ff0000ULL) |
-            ((in >> 40) & 0x000000000000ff00ULL) |
-            ((in >> 56) & 0x00000000000000ffULL);
-#endif
-}
-
-
-/*=== 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 U32 MEM_readLE32(const void* memPtr)
-{
-    if (MEM_isLittleEndian())
-        return MEM_read32(memPtr);
-    else
-        return MEM_swap32(MEM_read32(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 size_t MEM_readLEST(const void* memPtr)
-{
-    if (MEM_32bits())
-        return (size_t)MEM_readLE32(memPtr);
-    else
-        return (size_t)MEM_readLE64(memPtr);
-}
-
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* MEM_H_MODULE */
-/* ******************************************************************
-   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.
-*/
-
-
-/*=========================================
-*  Target specific
-=========================================*/
-#if defined(__BMI__) && defined(__GNUC__)
-#  include <immintrin.h>   /* support for bextr (experimental) */
-#endif
-
-/*-********************************************
-*  bitStream decoding API (read backward)
-**********************************************/
-typedef struct
-{
-    size_t   bitContainer;
-    unsigned bitsConsumed;
-    const char* ptr;
-    const char* start;
-} BITv07_DStream_t;
-
-typedef enum { BITv07_DStream_unfinished = 0,
-               BITv07_DStream_endOfBuffer = 1,
-               BITv07_DStream_completed = 2,
-               BITv07_DStream_overflow = 3 } BITv07_DStream_status;  /* result of BITv07_reloadDStream() */
-               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */
-
-MEM_STATIC size_t   BITv07_initDStream(BITv07_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
-MEM_STATIC size_t   BITv07_readBits(BITv07_DStream_t* bitD, unsigned nbBits);
-MEM_STATIC BITv07_DStream_status BITv07_reloadDStream(BITv07_DStream_t* bitD);
-MEM_STATIC unsigned BITv07_endOfDStream(const BITv07_DStream_t* bitD);
-
-
-
-/*-****************************************
-*  unsafe API
-******************************************/
-MEM_STATIC size_t BITv07_readBitsFast(BITv07_DStream_t* bitD, unsigned nbBits);
-/* faster, but works only if nbBits >= 1 */
-
-
-
-/*-**************************************************************
-*  Internal functions
-****************************************************************/
+    return __builtin_bswap64(in); 
+#else 
+    return  ((in << 56) & 0xff00000000000000ULL) | 
+            ((in << 40) & 0x00ff000000000000ULL) | 
+            ((in << 24) & 0x0000ff0000000000ULL) | 
+            ((in << 8)  & 0x000000ff00000000ULL) | 
+            ((in >> 8)  & 0x00000000ff000000ULL) | 
+            ((in >> 24) & 0x0000000000ff0000ULL) | 
+            ((in >> 40) & 0x000000000000ff00ULL) | 
+            ((in >> 56) & 0x00000000000000ffULL); 
+#endif 
+} 
+ 
+ 
+/*=== 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 U32 MEM_readLE32(const void* memPtr) 
+{ 
+    if (MEM_isLittleEndian()) 
+        return MEM_read32(memPtr); 
+    else 
+        return MEM_swap32(MEM_read32(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 size_t MEM_readLEST(const void* memPtr) 
+{ 
+    if (MEM_32bits()) 
+        return (size_t)MEM_readLE32(memPtr); 
+    else 
+        return (size_t)MEM_readLE64(memPtr); 
+} 
+ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif /* MEM_H_MODULE */ 
+/* ****************************************************************** 
+   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. 
+*/ 
+ 
+ 
+/*========================================= 
+*  Target specific 
+=========================================*/ 
+#if defined(__BMI__) && defined(__GNUC__) 
+#  include <immintrin.h>   /* support for bextr (experimental) */ 
+#endif 
+ 
+/*-******************************************** 
+*  bitStream decoding API (read backward) 
+**********************************************/ 
+typedef struct 
+{ 
+    size_t   bitContainer; 
+    unsigned bitsConsumed; 
+    const char* ptr; 
+    const char* start; 
+} BITv07_DStream_t; 
+ 
+typedef enum { BITv07_DStream_unfinished = 0, 
+               BITv07_DStream_endOfBuffer = 1, 
+               BITv07_DStream_completed = 2, 
+               BITv07_DStream_overflow = 3 } BITv07_DStream_status;  /* result of BITv07_reloadDStream() */ 
+               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */ 
+ 
+MEM_STATIC size_t   BITv07_initDStream(BITv07_DStream_t* bitD, const void* srcBuffer, size_t srcSize); 
+MEM_STATIC size_t   BITv07_readBits(BITv07_DStream_t* bitD, unsigned nbBits); 
+MEM_STATIC BITv07_DStream_status BITv07_reloadDStream(BITv07_DStream_t* bitD); 
+MEM_STATIC unsigned BITv07_endOfDStream(const BITv07_DStream_t* bitD); 
+ 
+ 
+ 
+/*-**************************************** 
+*  unsafe API 
+******************************************/ 
+MEM_STATIC size_t BITv07_readBitsFast(BITv07_DStream_t* bitD, unsigned nbBits); 
+/* faster, but works only if nbBits >= 1 */ 
+ 
+ 
+ 
+/*-************************************************************** 
+*  Internal functions 
+****************************************************************/ 
 MEM_STATIC unsigned BITv07_highbit32 (U32 val)
-{
-#   if defined(_MSC_VER)   /* Visual */
+{ 
+#   if defined(_MSC_VER)   /* Visual */ 
     unsigned long r;
     return _BitScanReverse(&r, val) ? (unsigned)r : 0;
-#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */
+#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */ 
     return __builtin_clz (val) ^ 31;
-#   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;
-    v |= v >> 1;
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-    return DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];
-#   endif
-}
-
-
-
-/*-********************************************************
-* bitStream decoding
-**********************************************************/
-/*! BITv07_initDStream() :
-*   Initialize a BITv07_DStream_t.
-*   `bitD` : a pointer to an already allocated BITv07_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 BITv07_initDStream(BITv07_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->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);
-        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
-          bitD->bitsConsumed = lastByte ? 8 - BITv07_highbit32(lastByte) : 0;
-          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
-    } else {
-        bitD->start = (const char*)srcBuffer;
-        bitD->ptr   = bitD->start;
-        bitD->bitContainer = *(const BYTE*)(bitD->start);
-        switch(srcSize)
-        {
+#   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; 
+    v |= v >> 1; 
+    v |= v >> 2; 
+    v |= v >> 4; 
+    v |= v >> 8; 
+    v |= v >> 16; 
+    return DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27]; 
+#   endif 
+} 
+ 
+ 
+ 
+/*-******************************************************** 
+* bitStream decoding 
+**********************************************************/ 
+/*! BITv07_initDStream() : 
+*   Initialize a BITv07_DStream_t. 
+*   `bitD` : a pointer to an already allocated BITv07_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 BITv07_initDStream(BITv07_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->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer); 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr); 
+        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; 
+          bitD->bitsConsumed = lastByte ? 8 - BITv07_highbit32(lastByte) : 0; 
+          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ } 
+    } 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);/* fall-through */
             case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);/* fall-through */
             case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);/* fall-through */
@@ -578,3329 +578,3329 @@ MEM_STATIC size_t BITv07_initDStream(BITv07_DStream_t* bitD, const void* srcBuff
             case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16; /* fall-through */
             case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) <<  8; /* fall-through */
             default: break;
-        }
-        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
-          bitD->bitsConsumed = lastByte ? 8 - BITv07_highbit32(lastByte) : 0;
-          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
-        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
-    }
-
-    return srcSize;
-}
-
-
- MEM_STATIC size_t BITv07_lookBits(const BITv07_DStream_t* bitD, U32 nbBits)
-{
-    U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1;
-    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);
-}
-
-/*! BITv07_lookBitsFast() :
-*   unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BITv07_lookBitsFast(const BITv07_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 BITv07_skipBits(BITv07_DStream_t* bitD, U32 nbBits)
-{
-    bitD->bitsConsumed += nbBits;
-}
-
-MEM_STATIC size_t BITv07_readBits(BITv07_DStream_t* bitD, U32 nbBits)
-{
-    size_t const value = BITv07_lookBits(bitD, nbBits);
-    BITv07_skipBits(bitD, nbBits);
-    return value;
-}
-
-/*! BITv07_readBitsFast() :
-*   unsafe version; only works only if nbBits >= 1 */
-MEM_STATIC size_t BITv07_readBitsFast(BITv07_DStream_t* bitD, U32 nbBits)
-{
-    size_t const value = BITv07_lookBitsFast(bitD, nbBits);
-    BITv07_skipBits(bitD, nbBits);
-    return value;
-}
-
-MEM_STATIC BITv07_DStream_status BITv07_reloadDStream(BITv07_DStream_t* bitD)
-{
+        } 
+        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1]; 
+          bitD->bitsConsumed = lastByte ? 8 - BITv07_highbit32(lastByte) : 0; 
+          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ } 
+        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8; 
+    } 
+ 
+    return srcSize; 
+} 
+ 
+ 
+ MEM_STATIC size_t BITv07_lookBits(const BITv07_DStream_t* bitD, U32 nbBits) 
+{ 
+    U32 const bitMask = sizeof(bitD->bitContainer)*8 - 1; 
+    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask); 
+} 
+ 
+/*! BITv07_lookBitsFast() : 
+*   unsafe version; only works only if nbBits >= 1 */ 
+MEM_STATIC size_t BITv07_lookBitsFast(const BITv07_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 BITv07_skipBits(BITv07_DStream_t* bitD, U32 nbBits) 
+{ 
+    bitD->bitsConsumed += nbBits; 
+} 
+ 
+MEM_STATIC size_t BITv07_readBits(BITv07_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t const value = BITv07_lookBits(bitD, nbBits); 
+    BITv07_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+/*! BITv07_readBitsFast() : 
+*   unsafe version; only works only if nbBits >= 1 */ 
+MEM_STATIC size_t BITv07_readBitsFast(BITv07_DStream_t* bitD, U32 nbBits) 
+{ 
+    size_t const value = BITv07_lookBitsFast(bitD, nbBits); 
+    BITv07_skipBits(bitD, nbBits); 
+    return value; 
+} 
+ 
+MEM_STATIC BITv07_DStream_status BITv07_reloadDStream(BITv07_DStream_t* bitD) 
+{ 
     if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should not happen => corruption detected */
         return BITv07_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 BITv07_DStream_unfinished;
-    }
-    if (bitD->ptr == bitD->start) {
-        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BITv07_DStream_endOfBuffer;
-        return BITv07_DStream_completed;
-    }
-    {   U32 nbBytes = bitD->bitsConsumed >> 3;
-        BITv07_DStream_status result = BITv07_DStream_unfinished;
-        if (bitD->ptr - nbBytes < bitD->start) {
-            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
-            result = BITv07_DStream_endOfBuffer;
-        }
-        bitD->ptr -= nbBytes;
-        bitD->bitsConsumed -= nbBytes*8;
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */
-        return result;
-    }
-}
-
-/*! BITv07_endOfDStream() :
-*   @return Tells if DStream has exactly reached its end (all bits consumed).
-*/
-MEM_STATIC unsigned BITv07_endOfDStream(const BITv07_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 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 FSEv07_H
-#define FSEv07_H
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-
-/*-****************************************
-*  FSE simple functions
-******************************************/
-
-/*! FSEv07_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 FSEv07_isError() .
-
-    ** Important ** : FSEv07_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 FSEv07_decompress(void* dst,  size_t dstCapacity,
-                const void* cSrc, size_t cSrcSize);
-
-
-/* Error Management */
-unsigned    FSEv07_isError(size_t code);        /* tells if a return value is an error code */
-const char* FSEv07_getErrorName(size_t code);   /* provides error code string (useful for debugging) */
-
-
-/*-*****************************************
-*  FSE detailed API
-******************************************/
-/*!
-FSEv07_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 *** */
-
-/*! FSEv07_readNCount():
-    Read compactly saved 'normalizedCounter' from 'rBuffer'.
-    @return : size read from 'rBuffer',
-              or an errorCode, which can be tested using FSEv07_isError().
-              maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */
-size_t FSEv07_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize);
-
-/*! Constructor and Destructor of FSEv07_DTable.
-    Note that its size depends on 'tableLog' */
-typedef unsigned FSEv07_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */
-FSEv07_DTable* FSEv07_createDTable(unsigned tableLog);
-void        FSEv07_freeDTable(FSEv07_DTable* dt);
-
-/*! FSEv07_buildDTable():
-    Builds 'dt', which must be already allocated, using FSEv07_createDTable().
-    return : 0, or an errorCode, which can be tested using FSEv07_isError() */
-size_t FSEv07_buildDTable (FSEv07_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);
-
-/*! FSEv07_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 FSEv07_isError() */
-size_t FSEv07_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSEv07_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 FSEv07_readNCount() if it was saved using FSEv07_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).
-FSEv07_readNCount() will provide 'tableLog' and 'maxSymbolValue'.
-The result of FSEv07_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 FSEv07_isError().
-
-The next step is to build the decompression tables 'FSEv07_DTable' from 'normalizedCounter'.
-This is performed by the function FSEv07_buildDTable().
-The space required by 'FSEv07_DTable' must be already allocated using FSEv07_createDTable().
-If there is an error, the function will return an error code, which can be tested using FSEv07_isError().
-
-`FSEv07_DTable` can then be used to decompress `cSrc`, with FSEv07_decompress_usingDTable().
-`cSrcSize` must be strictly correct, otherwise decompression will fail.
-FSEv07_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 FSEv07_isError(). (ex: dst buffer too small)
-*/
-
-
-#ifdef FSEv07_STATIC_LINKING_ONLY
-
-
-/* *****************************************
-*  Static allocation
-*******************************************/
-/* FSE buffer bounds */
-#define FSEv07_NCOUNTBOUND 512
-#define FSEv07_BLOCKBOUND(size) (size + (size>>7))
-
-/* It is possible to statically allocate FSE CTable/DTable as a table of unsigned using below macros */
-#define FSEv07_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog))
-
-
-/* *****************************************
-*  FSE advanced API
-*******************************************/
-size_t FSEv07_countFast(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize);
-/**< same as FSEv07_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr  */
-
-unsigned FSEv07_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus);
-/**< same as FSEv07_optimalTableLog(), which used `minus==2` */
-
-size_t FSEv07_buildDTable_raw (FSEv07_DTable* dt, unsigned nbBits);
-/**< build a fake FSEv07_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */
-
-size_t FSEv07_buildDTable_rle (FSEv07_DTable* dt, unsigned char symbolValue);
-/**< build a fake FSEv07_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 */
-} FSEv07_DState_t;
-
-
-static void     FSEv07_initDState(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD, const FSEv07_DTable* dt);
-
-static unsigned char FSEv07_decodeSymbol(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD);
-
-
-
-/* *****************************************
-*  FSE unsafe API
-*******************************************/
-static unsigned char FSEv07_decodeSymbolFast(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD);
-/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
-
-
+ 
+    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer)) { 
+        bitD->ptr -= bitD->bitsConsumed >> 3; 
+        bitD->bitsConsumed &= 7; 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr); 
+        return BITv07_DStream_unfinished; 
+    } 
+    if (bitD->ptr == bitD->start) { 
+        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BITv07_DStream_endOfBuffer; 
+        return BITv07_DStream_completed; 
+    } 
+    {   U32 nbBytes = bitD->bitsConsumed >> 3; 
+        BITv07_DStream_status result = BITv07_DStream_unfinished; 
+        if (bitD->ptr - nbBytes < bitD->start) { 
+            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */ 
+            result = BITv07_DStream_endOfBuffer; 
+        } 
+        bitD->ptr -= nbBytes; 
+        bitD->bitsConsumed -= nbBytes*8; 
+        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */ 
+        return result; 
+    } 
+} 
+ 
+/*! BITv07_endOfDStream() : 
+*   @return Tells if DStream has exactly reached its end (all bits consumed). 
+*/ 
+MEM_STATIC unsigned BITv07_endOfDStream(const BITv07_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 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 FSEv07_H 
+#define FSEv07_H 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+ 
+/*-**************************************** 
+*  FSE simple functions 
+******************************************/ 
+ 
+/*! FSEv07_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 FSEv07_isError() . 
+ 
+    ** Important ** : FSEv07_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 FSEv07_decompress(void* dst,  size_t dstCapacity, 
+                const void* cSrc, size_t cSrcSize); 
+ 
+ 
+/* Error Management */ 
+unsigned    FSEv07_isError(size_t code);        /* tells if a return value is an error code */ 
+const char* FSEv07_getErrorName(size_t code);   /* provides error code string (useful for debugging) */ 
+ 
+ 
+/*-***************************************** 
+*  FSE detailed API 
+******************************************/ 
+/*! 
+FSEv07_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 *** */ 
+ 
+/*! FSEv07_readNCount(): 
+    Read compactly saved 'normalizedCounter' from 'rBuffer'. 
+    @return : size read from 'rBuffer', 
+              or an errorCode, which can be tested using FSEv07_isError(). 
+              maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */ 
+size_t FSEv07_readNCount (short* normalizedCounter, unsigned* maxSymbolValuePtr, unsigned* tableLogPtr, const void* rBuffer, size_t rBuffSize); 
+ 
+/*! Constructor and Destructor of FSEv07_DTable. 
+    Note that its size depends on 'tableLog' */ 
+typedef unsigned FSEv07_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */ 
+FSEv07_DTable* FSEv07_createDTable(unsigned tableLog); 
+void        FSEv07_freeDTable(FSEv07_DTable* dt); 
+ 
+/*! FSEv07_buildDTable(): 
+    Builds 'dt', which must be already allocated, using FSEv07_createDTable(). 
+    return : 0, or an errorCode, which can be tested using FSEv07_isError() */ 
+size_t FSEv07_buildDTable (FSEv07_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog); 
+ 
+/*! FSEv07_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 FSEv07_isError() */ 
+size_t FSEv07_decompress_usingDTable(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, const FSEv07_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 FSEv07_readNCount() if it was saved using FSEv07_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). 
+FSEv07_readNCount() will provide 'tableLog' and 'maxSymbolValue'. 
+The result of FSEv07_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 FSEv07_isError(). 
+ 
+The next step is to build the decompression tables 'FSEv07_DTable' from 'normalizedCounter'. 
+This is performed by the function FSEv07_buildDTable(). 
+The space required by 'FSEv07_DTable' must be already allocated using FSEv07_createDTable(). 
+If there is an error, the function will return an error code, which can be tested using FSEv07_isError(). 
+ 
+`FSEv07_DTable` can then be used to decompress `cSrc`, with FSEv07_decompress_usingDTable(). 
+`cSrcSize` must be strictly correct, otherwise decompression will fail. 
+FSEv07_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 FSEv07_isError(). (ex: dst buffer too small) 
+*/ 
+ 
+ 
+#ifdef FSEv07_STATIC_LINKING_ONLY 
+ 
+ 
+/* ***************************************** 
+*  Static allocation 
+*******************************************/ 
+/* FSE buffer bounds */ 
+#define FSEv07_NCOUNTBOUND 512 
+#define FSEv07_BLOCKBOUND(size) (size + (size>>7)) 
+ 
+/* It is possible to statically allocate FSE CTable/DTable as a table of unsigned using below macros */ 
+#define FSEv07_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<maxTableLog)) 
+ 
+ 
+/* ***************************************** 
+*  FSE advanced API 
+*******************************************/ 
+size_t FSEv07_countFast(unsigned* count, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize); 
+/**< same as FSEv07_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr  */ 
+ 
+unsigned FSEv07_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus); 
+/**< same as FSEv07_optimalTableLog(), which used `minus==2` */ 
+ 
+size_t FSEv07_buildDTable_raw (FSEv07_DTable* dt, unsigned nbBits); 
+/**< build a fake FSEv07_DTable, designed to read an uncompressed bitstream where each symbol uses nbBits */ 
+ 
+size_t FSEv07_buildDTable_rle (FSEv07_DTable* dt, unsigned char symbolValue); 
+/**< build a fake FSEv07_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 */ 
+} FSEv07_DState_t; 
+ 
+ 
+static void     FSEv07_initDState(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD, const FSEv07_DTable* dt); 
+ 
+static unsigned char FSEv07_decodeSymbol(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD); 
+ 
+ 
+ 
+/* ***************************************** 
+*  FSE unsafe API 
+*******************************************/ 
+static unsigned char FSEv07_decodeSymbolFast(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD); 
+/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */ 
+ 
+ 
 /* ======    Decompression    ====== */
-
-typedef struct {
-    U16 tableLog;
-    U16 fastMode;
-} FSEv07_DTableHeader;   /* sizeof U32 */
-
-typedef struct
-{
-    unsigned short newState;
-    unsigned char  symbol;
-    unsigned char  nbBits;
-} FSEv07_decode_t;   /* size == U32 */
-
-MEM_STATIC void FSEv07_initDState(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD, const FSEv07_DTable* dt)
-{
-    const void* ptr = dt;
-    const FSEv07_DTableHeader* const DTableH = (const FSEv07_DTableHeader*)ptr;
-    DStatePtr->state = BITv07_readBits(bitD, DTableH->tableLog);
-    BITv07_reloadDStream(bitD);
-    DStatePtr->table = dt + 1;
-}
-
-MEM_STATIC BYTE FSEv07_peekSymbol(const FSEv07_DState_t* DStatePtr)
-{
-    FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    return DInfo.symbol;
-}
-
-MEM_STATIC void FSEv07_updateState(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD)
-{
-    FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    U32 const nbBits = DInfo.nbBits;
-    size_t const lowBits = BITv07_readBits(bitD, nbBits);
-    DStatePtr->state = DInfo.newState + lowBits;
-}
-
-MEM_STATIC BYTE FSEv07_decodeSymbol(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD)
-{
-    FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    U32 const nbBits = DInfo.nbBits;
-    BYTE const symbol = DInfo.symbol;
-    size_t const lowBits = BITv07_readBits(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-/*! FSEv07_decodeSymbolFast() :
-    unsafe, only works if no symbol has a probability > 50% */
-MEM_STATIC BYTE FSEv07_decodeSymbolFast(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD)
-{
-    FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state];
-    U32 const nbBits = DInfo.nbBits;
-    BYTE const symbol = DInfo.symbol;
-    size_t const lowBits = BITv07_readBitsFast(bitD, nbBits);
-
-    DStatePtr->state = DInfo.newState + lowBits;
-    return symbol;
-}
-
-
-
-#ifndef FSEv07_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 FSEv07_MAX_MEMORY_USAGE 14
-#define FSEv07_DEFAULT_MEMORY_USAGE 13
-
-/*!FSEv07_MAX_SYMBOL_VALUE :
-*  Maximum symbol value authorized.
-*  Required for proper stack allocation */
-#define FSEv07_MAX_SYMBOL_VALUE 255
-
-
-/* **************************************************************
-*  template functions type & suffix
-****************************************************************/
-#define FSEv07_FUNCTION_TYPE BYTE
-#define FSEv07_FUNCTION_EXTENSION
-#define FSEv07_DECODE_TYPE FSEv07_decode_t
-
-
-#endif   /* !FSEv07_COMMONDEFS_ONLY */
-
-
-/* ***************************************************************
-*  Constants
-*****************************************************************/
-#define FSEv07_MAX_TABLELOG  (FSEv07_MAX_MEMORY_USAGE-2)
-#define FSEv07_MAX_TABLESIZE (1U<<FSEv07_MAX_TABLELOG)
-#define FSEv07_MAXTABLESIZE_MASK (FSEv07_MAX_TABLESIZE-1)
-#define FSEv07_DEFAULT_TABLELOG (FSEv07_DEFAULT_MEMORY_USAGE-2)
-#define FSEv07_MIN_TABLELOG 5
-
-#define FSEv07_TABLELOG_ABSOLUTE_MAX 15
-#if FSEv07_MAX_TABLELOG > FSEv07_TABLELOG_ABSOLUTE_MAX
-#  error "FSEv07_MAX_TABLELOG > FSEv07_TABLELOG_ABSOLUTE_MAX is not supported"
-#endif
-
-#define FSEv07_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3)
-
-
-#endif /* FSEv07_STATIC_LINKING_ONLY */
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* FSEv07_H */
-/* ******************************************************************
-   Huffman coder, part of New Generation Entropy library
-   header file
-   Copyright (C) 2013-2016, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
-****************************************************************** */
-#ifndef HUFv07_H_298734234
-#define HUFv07_H_298734234
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-
-/* *** simple functions *** */
-/**
-HUFv07_decompress() :
-    Decompress HUF data from buffer 'cSrc', of size 'cSrcSize',
-    into already allocated buffer 'dst', of minimum size 'dstSize'.
-    `dstSize` : **must** be the ***exact*** size of original (uncompressed) data.
-    Note : in contrast with FSE, HUFv07_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 HUFv07_isError()
-*/
-size_t HUFv07_decompress(void* dst,  size_t dstSize,
-                const void* cSrc, size_t cSrcSize);
-
-
-/* ****************************************
-*  Tool functions
-******************************************/
-#define HUFv07_BLOCKSIZE_MAX (128 * 1024)
-
-/* Error Management */
-unsigned    HUFv07_isError(size_t code);        /**< tells if a return value is an error code */
-const char* HUFv07_getErrorName(size_t code);   /**< provides error code string (useful for debugging) */
-
-
-/* *** Advanced function *** */
-
-
-#ifdef HUFv07_STATIC_LINKING_ONLY
-
-
-/* *** Constants *** */
-#define HUFv07_TABLELOG_ABSOLUTEMAX  16   /* absolute limit of HUFv07_MAX_TABLELOG. Beyond that value, code does not work */
-#define HUFv07_TABLELOG_MAX  12           /* max configured tableLog (for static allocation); can be modified up to HUFv07_ABSOLUTEMAX_TABLELOG */
-#define HUFv07_TABLELOG_DEFAULT  11       /* tableLog by default, when not specified */
-#define HUFv07_SYMBOLVALUE_MAX 255
-#if (HUFv07_TABLELOG_MAX > HUFv07_TABLELOG_ABSOLUTEMAX)
-#  error "HUFv07_TABLELOG_MAX is too large !"
-#endif
-
-
-/* ****************************************
-*  Static allocation
-******************************************/
-/* HUF buffer bounds */
-#define HUFv07_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true if incompressible pre-filtered with fast heuristic */
-
-/* static allocation of HUF's DTable */
-typedef U32 HUFv07_DTable;
-#define HUFv07_DTABLE_SIZE(maxTableLog)   (1 + (1<<(maxTableLog)))
-#define HUFv07_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
-        HUFv07_DTable DTable[HUFv07_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1)*0x1000001) }
-#define HUFv07_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \
-        HUFv07_DTable DTable[HUFv07_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog)*0x1000001) }
-
-
-/* ****************************************
-*  Advanced decompression functions
-******************************************/
-size_t HUFv07_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */
-size_t HUFv07_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */
-
-size_t HUFv07_decompress4X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< decodes RLE and uncompressed */
-size_t HUFv07_decompress4X_hufOnly(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */
-size_t HUFv07_decompress4X2_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */
-size_t HUFv07_decompress4X4_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */
-
-size_t HUFv07_decompress1X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
-size_t HUFv07_decompress1X2_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */
-size_t HUFv07_decompress1X4_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */
-
-
-/* ****************************************
-*  HUF detailed API
-******************************************/
-/*!
-The following API allows targeting specific sub-functions for advanced tasks.
-For example, it's possible to compress several blocks using the same 'CTable',
-or to save and regenerate 'CTable' using external methods.
-*/
-/* FSEv07_count() : find it within "fse.h" */
-
-/*! HUFv07_readStats() :
-    Read compact Huffman tree, saved by HUFv07_writeCTable().
-    `huffWeight` is destination buffer.
-    @return : size read from `src` , or an error Code .
-    Note : Needed by HUFv07_readCTable() and HUFv07_readDTableXn() . */
-size_t HUFv07_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                     U32* nbSymbolsPtr, U32* tableLogPtr,
-                     const void* src, size_t srcSize);
-
-
-/*
-HUFv07_decompress() does the following:
-1. select the decompression algorithm (X2, X4) based on pre-computed heuristics
-2. build Huffman table from save, using HUFv07_readDTableXn()
-3. decode 1 or 4 segments in parallel using HUFv07_decompressSXn_usingDTable
-*/
-
-/** HUFv07_selectDecoder() :
-*   Tells which decoder is likely to decode faster,
-*   based on a set of pre-determined metrics.
-*   @return : 0==HUFv07_decompress4X2, 1==HUFv07_decompress4X4 .
-*   Assumption : 0 < cSrcSize < dstSize <= 128 KB */
-U32 HUFv07_selectDecoder (size_t dstSize, size_t cSrcSize);
-
-size_t HUFv07_readDTableX2 (HUFv07_DTable* DTable, const void* src, size_t srcSize);
-size_t HUFv07_readDTableX4 (HUFv07_DTable* DTable, const void* src, size_t srcSize);
-
-size_t HUFv07_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);
-size_t HUFv07_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);
-size_t HUFv07_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);
-
-
-/* single stream variants */
-size_t HUFv07_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */
-size_t HUFv07_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */
-
-size_t HUFv07_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);
-size_t HUFv07_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);
-size_t HUFv07_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable);
-
-
-#endif /* HUFv07_STATIC_LINKING_ONLY */
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif   /* HUFv07_H_298734234 */
-/*
-   Common functions of New Generation Entropy library
-   Copyright (C) 2016, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    You can contact the author at :
-    - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy
-    - Public forum : https://groups.google.com/forum/#!forum/lz4c
-*************************************************************************** */
-
-
-
-/*-****************************************
-*  FSE Error Management
-******************************************/
-unsigned FSEv07_isError(size_t code) { return ERR_isError(code); }
-
-const char* FSEv07_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-
-/* **************************************************************
-*  HUF Error Management
-****************************************************************/
-unsigned HUFv07_isError(size_t code) { return ERR_isError(code); }
-
-const char* HUFv07_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-
-/*-**************************************************************
-*  FSE NCount encoding-decoding
-****************************************************************/
-static short FSEv07_abs(short a) { return (short)(a<0 ? -a : a); }
-
-size_t FSEv07_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) + FSEv07_MIN_TABLELOG;   /* extract tableLog */
-    if (nbBits > FSEv07_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);
-    bitStream >>= 4;
-    bitCount = 4;
-    *tableLogPtr = nbBits;
-    remaining = (1<<nbBits)+1;
-    threshold = 1<<nbBits;
-    nbBits++;
-
-    while ((remaining>1) && (charnum<=*maxSVPtr)) {
-        if (previous0) {
-            unsigned n0 = charnum;
-            while ((bitStream & 0xFFFF) == 0xFFFF) {
-                n0+=24;
-                if (ip < iend-5) {
-                    ip+=2;
-                    bitStream = MEM_readLE32(ip) >> bitCount;
-                } else {
-                    bitStream >>= 16;
-                    bitCount+=16;
-            }   }
-            while ((bitStream & 3) == 3) {
-                n0+=3;
-                bitStream>>=2;
-                bitCount+=2;
-            }
-            n0 += bitStream & 3;
-            bitCount += 2;
-            if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);
-            while (charnum < n0) normalizedCounter[charnum++] = 0;
-            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
-                ip += bitCount>>3;
-                bitCount &= 7;
-                bitStream = MEM_readLE32(ip) >> bitCount;
-            }
-            else
-                bitStream >>= 2;
-        }
-        {   short const max = (short)((2*threshold-1)-remaining);
-            short count;
-
-            if ((bitStream & (threshold-1)) < (U32)max) {
-                count = (short)(bitStream & (threshold-1));
-                bitCount   += nbBits-1;
-            } else {
-                count = (short)(bitStream & (2*threshold-1));
-                if (count >= threshold) count -= max;
-                bitCount   += nbBits;
-            }
-
-            count--;   /* extra accuracy */
-            remaining -= FSEv07_abs(count);
-            normalizedCounter[charnum++] = count;
-            previous0 = !count;
-            while (remaining < threshold) {
-                nbBits--;
-                threshold >>= 1;
-            }
-
-            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {
-                ip += bitCount>>3;
-                bitCount &= 7;
-            } else {
-                bitCount -= (int)(8 * (iend - 4 - ip));
-                ip = iend - 4;
-            }
-            bitStream = MEM_readLE32(ip) >> (bitCount & 31);
-    }   }   /* while ((remaining>1) && (charnum<=*maxSVPtr)) */
-    if (remaining != 1) return ERROR(GENERIC);
-    *maxSVPtr = charnum-1;
-
-    ip += (bitCount+7)>>3;
-    if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);
-    return ip-istart;
-}
-
-
-/*! HUFv07_readStats() :
-    Read compact Huffman tree, saved by HUFv07_writeCTable().
-    `huffWeight` is destination buffer.
-    @return : size read from `src` , or an error Code .
-    Note : Needed by HUFv07_readCTable() and HUFv07_readDTableXn() .
-*/
-size_t HUFv07_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,
-                     U32* nbSymbolsPtr, U32* tableLogPtr,
-                     const void* src, size_t srcSize)
-{
-    U32 weightTotal;
-    const BYTE* ip = (const BYTE*) src;
+ 
+typedef struct { 
+    U16 tableLog; 
+    U16 fastMode; 
+} FSEv07_DTableHeader;   /* sizeof U32 */ 
+ 
+typedef struct 
+{ 
+    unsigned short newState; 
+    unsigned char  symbol; 
+    unsigned char  nbBits; 
+} FSEv07_decode_t;   /* size == U32 */ 
+ 
+MEM_STATIC void FSEv07_initDState(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD, const FSEv07_DTable* dt) 
+{ 
+    const void* ptr = dt; 
+    const FSEv07_DTableHeader* const DTableH = (const FSEv07_DTableHeader*)ptr; 
+    DStatePtr->state = BITv07_readBits(bitD, DTableH->tableLog); 
+    BITv07_reloadDStream(bitD); 
+    DStatePtr->table = dt + 1; 
+} 
+ 
+MEM_STATIC BYTE FSEv07_peekSymbol(const FSEv07_DState_t* DStatePtr) 
+{ 
+    FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    return DInfo.symbol; 
+} 
+ 
+MEM_STATIC void FSEv07_updateState(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD) 
+{ 
+    FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    U32 const nbBits = DInfo.nbBits; 
+    size_t const lowBits = BITv07_readBits(bitD, nbBits); 
+    DStatePtr->state = DInfo.newState + lowBits; 
+} 
+ 
+MEM_STATIC BYTE FSEv07_decodeSymbol(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD) 
+{ 
+    FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    U32 const nbBits = DInfo.nbBits; 
+    BYTE const symbol = DInfo.symbol; 
+    size_t const lowBits = BITv07_readBits(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+/*! FSEv07_decodeSymbolFast() : 
+    unsafe, only works if no symbol has a probability > 50% */ 
+MEM_STATIC BYTE FSEv07_decodeSymbolFast(FSEv07_DState_t* DStatePtr, BITv07_DStream_t* bitD) 
+{ 
+    FSEv07_decode_t const DInfo = ((const FSEv07_decode_t*)(DStatePtr->table))[DStatePtr->state]; 
+    U32 const nbBits = DInfo.nbBits; 
+    BYTE const symbol = DInfo.symbol; 
+    size_t const lowBits = BITv07_readBitsFast(bitD, nbBits); 
+ 
+    DStatePtr->state = DInfo.newState + lowBits; 
+    return symbol; 
+} 
+ 
+ 
+ 
+#ifndef FSEv07_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 FSEv07_MAX_MEMORY_USAGE 14 
+#define FSEv07_DEFAULT_MEMORY_USAGE 13 
+ 
+/*!FSEv07_MAX_SYMBOL_VALUE : 
+*  Maximum symbol value authorized. 
+*  Required for proper stack allocation */ 
+#define FSEv07_MAX_SYMBOL_VALUE 255 
+ 
+ 
+/* ************************************************************** 
+*  template functions type & suffix 
+****************************************************************/ 
+#define FSEv07_FUNCTION_TYPE BYTE 
+#define FSEv07_FUNCTION_EXTENSION 
+#define FSEv07_DECODE_TYPE FSEv07_decode_t 
+ 
+ 
+#endif   /* !FSEv07_COMMONDEFS_ONLY */ 
+ 
+ 
+/* *************************************************************** 
+*  Constants 
+*****************************************************************/ 
+#define FSEv07_MAX_TABLELOG  (FSEv07_MAX_MEMORY_USAGE-2) 
+#define FSEv07_MAX_TABLESIZE (1U<<FSEv07_MAX_TABLELOG) 
+#define FSEv07_MAXTABLESIZE_MASK (FSEv07_MAX_TABLESIZE-1) 
+#define FSEv07_DEFAULT_TABLELOG (FSEv07_DEFAULT_MEMORY_USAGE-2) 
+#define FSEv07_MIN_TABLELOG 5 
+ 
+#define FSEv07_TABLELOG_ABSOLUTE_MAX 15 
+#if FSEv07_MAX_TABLELOG > FSEv07_TABLELOG_ABSOLUTE_MAX 
+#  error "FSEv07_MAX_TABLELOG > FSEv07_TABLELOG_ABSOLUTE_MAX is not supported" 
+#endif 
+ 
+#define FSEv07_TABLESTEP(tableSize) ((tableSize>>1) + (tableSize>>3) + 3) 
+ 
+ 
+#endif /* FSEv07_STATIC_LINKING_ONLY */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* FSEv07_H */ 
+/* ****************************************************************** 
+   Huffman coder, part of New Generation Entropy library 
+   header file 
+   Copyright (C) 2013-2016, Yann Collet. 
+ 
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+   Redistribution and use in source and binary forms, with or without 
+   modification, are permitted provided that the following conditions are 
+   met: 
+ 
+       * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer. 
+       * Redistributions in binary form must reproduce the above 
+   copyright notice, this list of conditions and the following disclaimer 
+   in the documentation and/or other materials provided with the 
+   distribution. 
+ 
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+   You can contact the author at : 
+   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+****************************************************************** */ 
+#ifndef HUFv07_H_298734234 
+#define HUFv07_H_298734234 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+ 
+ 
+/* *** simple functions *** */ 
+/** 
+HUFv07_decompress() : 
+    Decompress HUF data from buffer 'cSrc', of size 'cSrcSize', 
+    into already allocated buffer 'dst', of minimum size 'dstSize'. 
+    `dstSize` : **must** be the ***exact*** size of original (uncompressed) data. 
+    Note : in contrast with FSE, HUFv07_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 HUFv07_isError() 
+*/ 
+size_t HUFv07_decompress(void* dst,  size_t dstSize, 
+                const void* cSrc, size_t cSrcSize); 
+ 
+ 
+/* **************************************** 
+*  Tool functions 
+******************************************/ 
+#define HUFv07_BLOCKSIZE_MAX (128 * 1024) 
+ 
+/* Error Management */ 
+unsigned    HUFv07_isError(size_t code);        /**< tells if a return value is an error code */ 
+const char* HUFv07_getErrorName(size_t code);   /**< provides error code string (useful for debugging) */ 
+ 
+ 
+/* *** Advanced function *** */ 
+ 
+ 
+#ifdef HUFv07_STATIC_LINKING_ONLY 
+ 
+ 
+/* *** Constants *** */ 
+#define HUFv07_TABLELOG_ABSOLUTEMAX  16   /* absolute limit of HUFv07_MAX_TABLELOG. Beyond that value, code does not work */ 
+#define HUFv07_TABLELOG_MAX  12           /* max configured tableLog (for static allocation); can be modified up to HUFv07_ABSOLUTEMAX_TABLELOG */ 
+#define HUFv07_TABLELOG_DEFAULT  11       /* tableLog by default, when not specified */ 
+#define HUFv07_SYMBOLVALUE_MAX 255 
+#if (HUFv07_TABLELOG_MAX > HUFv07_TABLELOG_ABSOLUTEMAX) 
+#  error "HUFv07_TABLELOG_MAX is too large !" 
+#endif 
+ 
+ 
+/* **************************************** 
+*  Static allocation 
+******************************************/ 
+/* HUF buffer bounds */ 
+#define HUFv07_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true if incompressible pre-filtered with fast heuristic */ 
+ 
+/* static allocation of HUF's DTable */ 
+typedef U32 HUFv07_DTable; 
+#define HUFv07_DTABLE_SIZE(maxTableLog)   (1 + (1<<(maxTableLog))) 
+#define HUFv07_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \ 
+        HUFv07_DTable DTable[HUFv07_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1)*0x1000001) } 
+#define HUFv07_CREATE_STATIC_DTABLEX4(DTable, maxTableLog) \ 
+        HUFv07_DTable DTable[HUFv07_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog)*0x1000001) } 
+ 
+ 
+/* **************************************** 
+*  Advanced decompression functions 
+******************************************/ 
+size_t HUFv07_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */ 
+size_t HUFv07_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */ 
+ 
+size_t HUFv07_decompress4X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< decodes RLE and uncompressed */ 
+size_t HUFv07_decompress4X_hufOnly(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); /**< considers RLE and uncompressed as errors */ 
+size_t HUFv07_decompress4X2_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */ 
+size_t HUFv07_decompress4X4_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */ 
+ 
+size_t HUFv07_decompress1X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); 
+size_t HUFv07_decompress1X2_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< single-symbol decoder */ 
+size_t HUFv07_decompress1X4_DCtx(HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /**< double-symbols decoder */ 
+ 
+ 
+/* **************************************** 
+*  HUF detailed API 
+******************************************/ 
+/*! 
+The following API allows targeting specific sub-functions for advanced tasks. 
+For example, it's possible to compress several blocks using the same 'CTable', 
+or to save and regenerate 'CTable' using external methods. 
+*/ 
+/* FSEv07_count() : find it within "fse.h" */ 
+ 
+/*! HUFv07_readStats() : 
+    Read compact Huffman tree, saved by HUFv07_writeCTable(). 
+    `huffWeight` is destination buffer. 
+    @return : size read from `src` , or an error Code . 
+    Note : Needed by HUFv07_readCTable() and HUFv07_readDTableXn() . */ 
+size_t HUFv07_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats, 
+                     U32* nbSymbolsPtr, U32* tableLogPtr, 
+                     const void* src, size_t srcSize); 
+ 
+ 
+/* 
+HUFv07_decompress() does the following: 
+1. select the decompression algorithm (X2, X4) based on pre-computed heuristics 
+2. build Huffman table from save, using HUFv07_readDTableXn() 
+3. decode 1 or 4 segments in parallel using HUFv07_decompressSXn_usingDTable 
+*/ 
+ 
+/** HUFv07_selectDecoder() : 
+*   Tells which decoder is likely to decode faster, 
+*   based on a set of pre-determined metrics. 
+*   @return : 0==HUFv07_decompress4X2, 1==HUFv07_decompress4X4 . 
+*   Assumption : 0 < cSrcSize < dstSize <= 128 KB */ 
+U32 HUFv07_selectDecoder (size_t dstSize, size_t cSrcSize); 
+ 
+size_t HUFv07_readDTableX2 (HUFv07_DTable* DTable, const void* src, size_t srcSize); 
+size_t HUFv07_readDTableX4 (HUFv07_DTable* DTable, const void* src, size_t srcSize); 
+ 
+size_t HUFv07_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable); 
+size_t HUFv07_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable); 
+size_t HUFv07_decompress4X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable); 
+ 
+ 
+/* single stream variants */ 
+size_t HUFv07_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* single-symbol decoder */ 
+size_t HUFv07_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);   /* double-symbol decoder */ 
+ 
+size_t HUFv07_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable); 
+size_t HUFv07_decompress1X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable); 
+size_t HUFv07_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUFv07_DTable* DTable); 
+ 
+ 
+#endif /* HUFv07_STATIC_LINKING_ONLY */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif   /* HUFv07_H_298734234 */ 
+/* 
+   Common functions of New Generation Entropy library 
+   Copyright (C) 2016, Yann Collet. 
+ 
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+   Redistribution and use in source and binary forms, with or without 
+   modification, are permitted provided that the following conditions are 
+   met: 
+ 
+       * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer. 
+       * Redistributions in binary form must reproduce the above 
+   copyright notice, this list of conditions and the following disclaimer 
+   in the documentation and/or other materials provided with the 
+   distribution. 
+ 
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+    You can contact the author at : 
+    - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+*************************************************************************** */ 
+ 
+ 
+ 
+/*-**************************************** 
+*  FSE Error Management 
+******************************************/ 
+unsigned FSEv07_isError(size_t code) { return ERR_isError(code); } 
+ 
+const char* FSEv07_getErrorName(size_t code) { return ERR_getErrorName(code); } 
+ 
+ 
+/* ************************************************************** 
+*  HUF Error Management 
+****************************************************************/ 
+unsigned HUFv07_isError(size_t code) { return ERR_isError(code); } 
+ 
+const char* HUFv07_getErrorName(size_t code) { return ERR_getErrorName(code); } 
+ 
+ 
+/*-************************************************************** 
+*  FSE NCount encoding-decoding 
+****************************************************************/ 
+static short FSEv07_abs(short a) { return (short)(a<0 ? -a : a); } 
+ 
+size_t FSEv07_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) + FSEv07_MIN_TABLELOG;   /* extract tableLog */ 
+    if (nbBits > FSEv07_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge); 
+    bitStream >>= 4; 
+    bitCount = 4; 
+    *tableLogPtr = nbBits; 
+    remaining = (1<<nbBits)+1; 
+    threshold = 1<<nbBits; 
+    nbBits++; 
+ 
+    while ((remaining>1) && (charnum<=*maxSVPtr)) { 
+        if (previous0) { 
+            unsigned n0 = charnum; 
+            while ((bitStream & 0xFFFF) == 0xFFFF) { 
+                n0+=24; 
+                if (ip < iend-5) { 
+                    ip+=2; 
+                    bitStream = MEM_readLE32(ip) >> bitCount; 
+                } else { 
+                    bitStream >>= 16; 
+                    bitCount+=16; 
+            }   } 
+            while ((bitStream & 3) == 3) { 
+                n0+=3; 
+                bitStream>>=2; 
+                bitCount+=2; 
+            } 
+            n0 += bitStream & 3; 
+            bitCount += 2; 
+            if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall); 
+            while (charnum < n0) normalizedCounter[charnum++] = 0; 
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { 
+                ip += bitCount>>3; 
+                bitCount &= 7; 
+                bitStream = MEM_readLE32(ip) >> bitCount; 
+            } 
+            else 
+                bitStream >>= 2; 
+        } 
+        {   short const max = (short)((2*threshold-1)-remaining); 
+            short count; 
+ 
+            if ((bitStream & (threshold-1)) < (U32)max) { 
+                count = (short)(bitStream & (threshold-1)); 
+                bitCount   += nbBits-1; 
+            } else { 
+                count = (short)(bitStream & (2*threshold-1)); 
+                if (count >= threshold) count -= max; 
+                bitCount   += nbBits; 
+            } 
+ 
+            count--;   /* extra accuracy */ 
+            remaining -= FSEv07_abs(count); 
+            normalizedCounter[charnum++] = count; 
+            previous0 = !count; 
+            while (remaining < threshold) { 
+                nbBits--; 
+                threshold >>= 1; 
+            } 
+ 
+            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) { 
+                ip += bitCount>>3; 
+                bitCount &= 7; 
+            } else { 
+                bitCount -= (int)(8 * (iend - 4 - ip)); 
+                ip = iend - 4; 
+            } 
+            bitStream = MEM_readLE32(ip) >> (bitCount & 31); 
+    }   }   /* while ((remaining>1) && (charnum<=*maxSVPtr)) */ 
+    if (remaining != 1) return ERROR(GENERIC); 
+    *maxSVPtr = charnum-1; 
+ 
+    ip += (bitCount+7)>>3; 
+    if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong); 
+    return ip-istart; 
+} 
+ 
+ 
+/*! HUFv07_readStats() : 
+    Read compact Huffman tree, saved by HUFv07_writeCTable(). 
+    `huffWeight` is destination buffer. 
+    @return : size read from `src` , or an error Code . 
+    Note : Needed by HUFv07_readCTable() and HUFv07_readDTableXn() . 
+*/ 
+size_t HUFv07_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats, 
+                     U32* nbSymbolsPtr, U32* tableLogPtr, 
+                     const void* src, size_t srcSize) 
+{ 
+    U32 weightTotal; 
+    const BYTE* ip = (const BYTE*) src; 
     size_t iSize;
-    size_t oSize;
-
+    size_t oSize; 
+ 
     if (!srcSize) return ERROR(srcSize_wrong);
     iSize = ip[0];
     /* memset(huffWeight, 0, hwSize); */   /* is not necessary, even though some analyzer complain ... */
-
-    if (iSize >= 128)  { /* special header */
-        if (iSize >= (242)) {  /* RLE */
-            static U32 l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };
-            oSize = l[iSize-242];
-            memset(huffWeight, 1, hwSize);
-            iSize = 0;
-        }
-        else {   /* Incompressible */
-            oSize = iSize - 127;
-            iSize = ((oSize+1)/2);
-            if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
-            if (oSize >= hwSize) return ERROR(corruption_detected);
-            ip += 1;
-            {   U32 n;
-                for (n=0; n<oSize; n+=2) {
-                    huffWeight[n]   = ip[n/2] >> 4;
-                    huffWeight[n+1] = ip[n/2] & 15;
-    }   }   }   }
-    else  {   /* header compressed with FSE (normal case) */
-        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);
-        oSize = FSEv07_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */
-        if (FSEv07_isError(oSize)) return oSize;
-    }
-
-    /* collect weight stats */
-    memset(rankStats, 0, (HUFv07_TABLELOG_ABSOLUTEMAX + 1) * sizeof(U32));
-    weightTotal = 0;
-    {   U32 n; for (n=0; n<oSize; n++) {
-            if (huffWeight[n] >= HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(corruption_detected);
-            rankStats[huffWeight[n]]++;
-            weightTotal += (1 << huffWeight[n]) >> 1;
-    }   }
+ 
+    if (iSize >= 128)  { /* special header */ 
+        if (iSize >= (242)) {  /* RLE */ 
+            static U32 l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 }; 
+            oSize = l[iSize-242]; 
+            memset(huffWeight, 1, hwSize); 
+            iSize = 0; 
+        } 
+        else {   /* Incompressible */ 
+            oSize = iSize - 127; 
+            iSize = ((oSize+1)/2); 
+            if (iSize+1 > srcSize) return ERROR(srcSize_wrong); 
+            if (oSize >= hwSize) return ERROR(corruption_detected); 
+            ip += 1; 
+            {   U32 n; 
+                for (n=0; n<oSize; n+=2) { 
+                    huffWeight[n]   = ip[n/2] >> 4; 
+                    huffWeight[n+1] = ip[n/2] & 15; 
+    }   }   }   } 
+    else  {   /* header compressed with FSE (normal case) */ 
+        if (iSize+1 > srcSize) return ERROR(srcSize_wrong); 
+        oSize = FSEv07_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */ 
+        if (FSEv07_isError(oSize)) return oSize; 
+    } 
+ 
+    /* collect weight stats */ 
+    memset(rankStats, 0, (HUFv07_TABLELOG_ABSOLUTEMAX + 1) * sizeof(U32)); 
+    weightTotal = 0; 
+    {   U32 n; for (n=0; n<oSize; n++) { 
+            if (huffWeight[n] >= HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(corruption_detected); 
+            rankStats[huffWeight[n]]++; 
+            weightTotal += (1 << huffWeight[n]) >> 1; 
+    }   } 
     if (weightTotal == 0) return ERROR(corruption_detected);
-
-    /* get last non-null symbol weight (implied, total must be 2^n) */
-    {   U32 const tableLog = BITv07_highbit32(weightTotal) + 1;
-        if (tableLog > HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(corruption_detected);
-        *tableLogPtr = tableLog;
-        /* determine last weight */
-        {   U32 const total = 1 << tableLog;
-            U32 const rest = total - weightTotal;
-            U32 const verif = 1 << BITv07_highbit32(rest);
-            U32 const lastWeight = BITv07_highbit32(rest) + 1;
-            if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */
-            huffWeight[oSize] = (BYTE)lastWeight;
-            rankStats[lastWeight]++;
-    }   }
-
-    /* check tree construction validity */
-    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */
-
-    /* results */
-    *nbSymbolsPtr = (U32)(oSize+1);
-    return iSize+1;
-}
-/* ******************************************************************
-   FSE : Finite State Entropy decoder
-   Copyright (C) 2013-2015, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    You can contact the author at :
-    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
-    - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-
-
-/* **************************************************************
-*  Compiler specifics
-****************************************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  define FORCE_INLINE static __forceinline
-#  include <intrin.h>                    /* For Visual 2005 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
-#else
+ 
+    /* get last non-null symbol weight (implied, total must be 2^n) */ 
+    {   U32 const tableLog = BITv07_highbit32(weightTotal) + 1; 
+        if (tableLog > HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(corruption_detected); 
+        *tableLogPtr = tableLog; 
+        /* determine last weight */ 
+        {   U32 const total = 1 << tableLog; 
+            U32 const rest = total - weightTotal; 
+            U32 const verif = 1 << BITv07_highbit32(rest); 
+            U32 const lastWeight = BITv07_highbit32(rest) + 1; 
+            if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */ 
+            huffWeight[oSize] = (BYTE)lastWeight; 
+            rankStats[lastWeight]++; 
+    }   } 
+ 
+    /* check tree construction validity */ 
+    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */ 
+ 
+    /* results */ 
+    *nbSymbolsPtr = (U32)(oSize+1); 
+    return iSize+1; 
+} 
+/* ****************************************************************** 
+   FSE : Finite State Entropy decoder 
+   Copyright (C) 2013-2015, Yann Collet. 
+ 
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+   Redistribution and use in source and binary forms, with or without 
+   modification, are permitted provided that the following conditions are 
+   met: 
+ 
+       * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer. 
+       * Redistributions in binary form must reproduce the above 
+   copyright notice, this list of conditions and the following disclaimer 
+   in the documentation and/or other materials provided with the 
+   distribution. 
+ 
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+    You can contact the author at : 
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+ 
+ 
+/* ************************************************************** 
+*  Compiler specifics 
+****************************************************************/ 
+#ifdef _MSC_VER    /* Visual Studio */ 
+#  define FORCE_INLINE static __forceinline 
+#  include <intrin.h>                    /* For Visual 2005 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */ 
+#else 
 #  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
 #    ifdef __GNUC__
 #      define FORCE_INLINE static inline __attribute__((always_inline))
 #    else
 #      define FORCE_INLINE static inline
 #    endif
-#  else
+#  else 
 #    define FORCE_INLINE static
 #  endif /* __STDC_VERSION__ */
-#endif
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#define FSEv07_isError ERR_isError
-#define FSEv07_STATIC_ASSERT(c) { enum { FSEv07_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-
-
-/* **************************************************************
-*  Complex types
-****************************************************************/
-typedef U32 DTable_max_t[FSEv07_DTABLE_SIZE_U32(FSEv07_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 FSEv07_FUNCTION_EXTENSION
-#  error "FSEv07_FUNCTION_EXTENSION must be defined"
-#endif
-#ifndef FSEv07_FUNCTION_TYPE
-#  error "FSEv07_FUNCTION_TYPE must be defined"
-#endif
-
-/* Function names */
-#define FSEv07_CAT(X,Y) X##Y
-#define FSEv07_FUNCTION_NAME(X,Y) FSEv07_CAT(X,Y)
-#define FSEv07_TYPE_NAME(X,Y) FSEv07_CAT(X,Y)
-
-
-/* Function templates */
-FSEv07_DTable* FSEv07_createDTable (unsigned tableLog)
-{
-    if (tableLog > FSEv07_TABLELOG_ABSOLUTE_MAX) tableLog = FSEv07_TABLELOG_ABSOLUTE_MAX;
-    return (FSEv07_DTable*)malloc( FSEv07_DTABLE_SIZE_U32(tableLog) * sizeof (U32) );
-}
-
-void FSEv07_freeDTable (FSEv07_DTable* dt)
-{
-    free(dt);
-}
-
-size_t FSEv07_buildDTable(FSEv07_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
-{
-    void* const tdPtr = dt+1;   /* because *dt is unsigned, 32-bits aligned on 32-bits */
-    FSEv07_DECODE_TYPE* const tableDecode = (FSEv07_DECODE_TYPE*) (tdPtr);
-    U16 symbolNext[FSEv07_MAX_SYMBOL_VALUE+1];
-
-    U32 const maxSV1 = maxSymbolValue + 1;
-    U32 const tableSize = 1 << tableLog;
-    U32 highThreshold = tableSize-1;
-
-    /* Sanity Checks */
-    if (maxSymbolValue > FSEv07_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);
-    if (tableLog > FSEv07_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
-
-    /* Init, lay down lowprob symbols */
-    {   FSEv07_DTableHeader DTableH;
-        DTableH.tableLog = (U16)tableLog;
-        DTableH.fastMode = 1;
-        {   S16 const largeLimit= (S16)(1 << (tableLog-1));
-            U32 s;
-            for (s=0; s<maxSV1; s++) {
-                if (normalizedCounter[s]==-1) {
-                    tableDecode[highThreshold--].symbol = (FSEv07_FUNCTION_TYPE)s;
-                    symbolNext[s] = 1;
-                } else {
-                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0;
-                    symbolNext[s] = normalizedCounter[s];
-        }   }   }
-        memcpy(dt, &DTableH, sizeof(DTableH));
-    }
-
-    /* Spread symbols */
-    {   U32 const tableMask = tableSize-1;
-        U32 const step = FSEv07_TABLESTEP(tableSize);
-        U32 s, position = 0;
-        for (s=0; s<maxSV1; s++) {
-            int i;
-            for (i=0; i<normalizedCounter[s]; i++) {
-                tableDecode[position].symbol = (FSEv07_FUNCTION_TYPE)s;
-                position = (position + step) & tableMask;
-                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */
-        }   }
-
-        if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */
-    }
-
-    /* Build Decoding table */
-    {   U32 u;
-        for (u=0; u<tableSize; u++) {
-            FSEv07_FUNCTION_TYPE const symbol = (FSEv07_FUNCTION_TYPE)(tableDecode[u].symbol);
-            U16 nextState = symbolNext[symbol]++;
-            tableDecode[u].nbBits = (BYTE) (tableLog - BITv07_highbit32 ((U32)nextState) );
-            tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize);
-    }   }
-
-    return 0;
-}
-
-
-
-#ifndef FSEv07_COMMONDEFS_ONLY
-
-/*-*******************************************************
-*  Decompression (Byte symbols)
-*********************************************************/
-size_t FSEv07_buildDTable_rle (FSEv07_DTable* dt, BYTE symbolValue)
-{
-    void* ptr = dt;
-    FSEv07_DTableHeader* const DTableH = (FSEv07_DTableHeader*)ptr;
-    void* dPtr = dt + 1;
-    FSEv07_decode_t* const cell = (FSEv07_decode_t*)dPtr;
-
-    DTableH->tableLog = 0;
-    DTableH->fastMode = 0;
-
-    cell->newState = 0;
-    cell->symbol = symbolValue;
-    cell->nbBits = 0;
-
-    return 0;
-}
-
-
-size_t FSEv07_buildDTable_raw (FSEv07_DTable* dt, unsigned nbBits)
-{
-    void* ptr = dt;
-    FSEv07_DTableHeader* const DTableH = (FSEv07_DTableHeader*)ptr;
-    void* dPtr = dt + 1;
-    FSEv07_decode_t* const dinfo = (FSEv07_decode_t*)dPtr;
-    const unsigned tableSize = 1 << nbBits;
-    const unsigned tableMask = tableSize - 1;
-    const unsigned maxSV1 = tableMask+1;
-    unsigned s;
-
-    /* Sanity checks */
-    if (nbBits < 1) return ERROR(GENERIC);         /* min size */
-
-    /* Build Decoding Table */
-    DTableH->tableLog = (U16)nbBits;
-    DTableH->fastMode = 1;
-    for (s=0; s<maxSV1; s++) {
-        dinfo[s].newState = 0;
-        dinfo[s].symbol = (BYTE)s;
-        dinfo[s].nbBits = (BYTE)nbBits;
-    }
-
-    return 0;
-}
-
-FORCE_INLINE size_t FSEv07_decompress_usingDTable_generic(
-          void* dst, size_t maxDstSize,
-    const void* cSrc, size_t cSrcSize,
-    const FSEv07_DTable* dt, const unsigned fast)
-{
-    BYTE* const ostart = (BYTE*) dst;
-    BYTE* op = ostart;
-    BYTE* const omax = op + maxDstSize;
-    BYTE* const olimit = omax-3;
-
-    BITv07_DStream_t bitD;
-    FSEv07_DState_t state1;
-    FSEv07_DState_t state2;
-
-    /* Init */
-    { size_t const errorCode = BITv07_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */
-      if (FSEv07_isError(errorCode)) return errorCode; }
-
-    FSEv07_initDState(&state1, &bitD, dt);
-    FSEv07_initDState(&state2, &bitD, dt);
-
-#define FSEv07_GETSYMBOL(statePtr) fast ? FSEv07_decodeSymbolFast(statePtr, &bitD) : FSEv07_decodeSymbol(statePtr, &bitD)
-
-    /* 4 symbols per loop */
-    for ( ; (BITv07_reloadDStream(&bitD)==BITv07_DStream_unfinished) && (op<olimit) ; op+=4) {
-        op[0] = FSEv07_GETSYMBOL(&state1);
-
-        if (FSEv07_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            BITv07_reloadDStream(&bitD);
-
-        op[1] = FSEv07_GETSYMBOL(&state2);
-
-        if (FSEv07_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            { if (BITv07_reloadDStream(&bitD) > BITv07_DStream_unfinished) { op+=2; break; } }
-
-        op[2] = FSEv07_GETSYMBOL(&state1);
-
-        if (FSEv07_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */
-            BITv07_reloadDStream(&bitD);
-
-        op[3] = FSEv07_GETSYMBOL(&state2);
-    }
-
-    /* tail */
-    /* note : BITv07_reloadDStream(&bitD) >= FSEv07_DStream_partiallyFilled; Ends at exactly BITv07_DStream_completed */
-    while (1) {
-        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
-
-        *op++ = FSEv07_GETSYMBOL(&state1);
-
-        if (BITv07_reloadDStream(&bitD)==BITv07_DStream_overflow) {
-            *op++ = FSEv07_GETSYMBOL(&state2);
-            break;
-        }
-
-        if (op>(omax-2)) return ERROR(dstSize_tooSmall);
-
-        *op++ = FSEv07_GETSYMBOL(&state2);
-
-        if (BITv07_reloadDStream(&bitD)==BITv07_DStream_overflow) {
-            *op++ = FSEv07_GETSYMBOL(&state1);
-            break;
-    }   }
-
-    return op-ostart;
-}
-
-
-size_t FSEv07_decompress_usingDTable(void* dst, size_t originalSize,
-                            const void* cSrc, size_t cSrcSize,
-                            const FSEv07_DTable* dt)
-{
-    const void* ptr = dt;
-    const FSEv07_DTableHeader* DTableH = (const FSEv07_DTableHeader*)ptr;
-    const U32 fastMode = DTableH->fastMode;
-
-    /* select fast mode (static) */
-    if (fastMode) return FSEv07_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);
-    return FSEv07_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
-}
-
-
-size_t FSEv07_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[FSEv07_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 = FSEv07_MAX_SYMBOL_VALUE;
-
-    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */
-
-    /* normal FSE decoding mode */
-    {   size_t const NCountLength = FSEv07_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
-        if (FSEv07_isError(NCountLength)) return NCountLength;
-        if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */
-        ip += NCountLength;
-        cSrcSize -= NCountLength;
-    }
-
-    { size_t const errorCode = FSEv07_buildDTable (dt, counting, maxSymbolValue, tableLog);
-      if (FSEv07_isError(errorCode)) return errorCode; }
-
-    return FSEv07_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);   /* always return, even if it is an error code */
-}
-
-
-
-#endif   /* FSEv07_COMMONDEFS_ONLY */
-
-/* ******************************************************************
-   Huffman decoder, part of New Generation Entropy library
-   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 :
-    - FSE+HUF 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 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#endif
-
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#define HUFv07_STATIC_ASSERT(c) { enum { HUFv07_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-
-
-/*-***************************/
-/*  generic DTableDesc       */
-/*-***************************/
-
-typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc;
-
-static DTableDesc HUFv07_getDTableDesc(const HUFv07_DTable* table)
-{
-    DTableDesc dtd;
-    memcpy(&dtd, table, sizeof(dtd));
-    return dtd;
-}
-
-
-/*-***************************/
-/*  single-symbol decoding   */
-/*-***************************/
-
-typedef struct { BYTE byte; BYTE nbBits; } HUFv07_DEltX2;   /* single-symbol decoding */
-
-size_t HUFv07_readDTableX2 (HUFv07_DTable* DTable, const void* src, size_t srcSize)
-{
-    BYTE huffWeight[HUFv07_SYMBOLVALUE_MAX + 1];
-    U32 rankVal[HUFv07_TABLELOG_ABSOLUTEMAX + 1];   /* large enough for values from 0 to 16 */
-    U32 tableLog = 0;
-    U32 nbSymbols = 0;
-    size_t iSize;
-    void* const dtPtr = DTable + 1;
-    HUFv07_DEltX2* const dt = (HUFv07_DEltX2*)dtPtr;
-
-    HUFv07_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUFv07_DTable));
+#endif 
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#define FSEv07_isError ERR_isError 
+#define FSEv07_STATIC_ASSERT(c) { enum { FSEv07_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */ 
+ 
+ 
+/* ************************************************************** 
+*  Complex types 
+****************************************************************/ 
+typedef U32 DTable_max_t[FSEv07_DTABLE_SIZE_U32(FSEv07_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 FSEv07_FUNCTION_EXTENSION 
+#  error "FSEv07_FUNCTION_EXTENSION must be defined" 
+#endif 
+#ifndef FSEv07_FUNCTION_TYPE 
+#  error "FSEv07_FUNCTION_TYPE must be defined" 
+#endif 
+ 
+/* Function names */ 
+#define FSEv07_CAT(X,Y) X##Y 
+#define FSEv07_FUNCTION_NAME(X,Y) FSEv07_CAT(X,Y) 
+#define FSEv07_TYPE_NAME(X,Y) FSEv07_CAT(X,Y) 
+ 
+ 
+/* Function templates */ 
+FSEv07_DTable* FSEv07_createDTable (unsigned tableLog) 
+{ 
+    if (tableLog > FSEv07_TABLELOG_ABSOLUTE_MAX) tableLog = FSEv07_TABLELOG_ABSOLUTE_MAX; 
+    return (FSEv07_DTable*)malloc( FSEv07_DTABLE_SIZE_U32(tableLog) * sizeof (U32) ); 
+} 
+ 
+void FSEv07_freeDTable (FSEv07_DTable* dt) 
+{ 
+    free(dt); 
+} 
+ 
+size_t FSEv07_buildDTable(FSEv07_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) 
+{ 
+    void* const tdPtr = dt+1;   /* because *dt is unsigned, 32-bits aligned on 32-bits */ 
+    FSEv07_DECODE_TYPE* const tableDecode = (FSEv07_DECODE_TYPE*) (tdPtr); 
+    U16 symbolNext[FSEv07_MAX_SYMBOL_VALUE+1]; 
+ 
+    U32 const maxSV1 = maxSymbolValue + 1; 
+    U32 const tableSize = 1 << tableLog; 
+    U32 highThreshold = tableSize-1; 
+ 
+    /* Sanity Checks */ 
+    if (maxSymbolValue > FSEv07_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge); 
+    if (tableLog > FSEv07_MAX_TABLELOG) return ERROR(tableLog_tooLarge); 
+ 
+    /* Init, lay down lowprob symbols */ 
+    {   FSEv07_DTableHeader DTableH; 
+        DTableH.tableLog = (U16)tableLog; 
+        DTableH.fastMode = 1; 
+        {   S16 const largeLimit= (S16)(1 << (tableLog-1)); 
+            U32 s; 
+            for (s=0; s<maxSV1; s++) { 
+                if (normalizedCounter[s]==-1) { 
+                    tableDecode[highThreshold--].symbol = (FSEv07_FUNCTION_TYPE)s; 
+                    symbolNext[s] = 1; 
+                } else { 
+                    if (normalizedCounter[s] >= largeLimit) DTableH.fastMode=0; 
+                    symbolNext[s] = normalizedCounter[s]; 
+        }   }   } 
+        memcpy(dt, &DTableH, sizeof(DTableH)); 
+    } 
+ 
+    /* Spread symbols */ 
+    {   U32 const tableMask = tableSize-1; 
+        U32 const step = FSEv07_TABLESTEP(tableSize); 
+        U32 s, position = 0; 
+        for (s=0; s<maxSV1; s++) { 
+            int i; 
+            for (i=0; i<normalizedCounter[s]; i++) { 
+                tableDecode[position].symbol = (FSEv07_FUNCTION_TYPE)s; 
+                position = (position + step) & tableMask; 
+                while (position > highThreshold) position = (position + step) & tableMask;   /* lowprob area */ 
+        }   } 
+ 
+        if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */ 
+    } 
+ 
+    /* Build Decoding table */ 
+    {   U32 u; 
+        for (u=0; u<tableSize; u++) { 
+            FSEv07_FUNCTION_TYPE const symbol = (FSEv07_FUNCTION_TYPE)(tableDecode[u].symbol); 
+            U16 nextState = symbolNext[symbol]++; 
+            tableDecode[u].nbBits = (BYTE) (tableLog - BITv07_highbit32 ((U32)nextState) ); 
+            tableDecode[u].newState = (U16) ( (nextState << tableDecode[u].nbBits) - tableSize); 
+    }   } 
+ 
+    return 0; 
+} 
+ 
+ 
+ 
+#ifndef FSEv07_COMMONDEFS_ONLY 
+ 
+/*-******************************************************* 
+*  Decompression (Byte symbols) 
+*********************************************************/ 
+size_t FSEv07_buildDTable_rle (FSEv07_DTable* dt, BYTE symbolValue) 
+{ 
+    void* ptr = dt; 
+    FSEv07_DTableHeader* const DTableH = (FSEv07_DTableHeader*)ptr; 
+    void* dPtr = dt + 1; 
+    FSEv07_decode_t* const cell = (FSEv07_decode_t*)dPtr; 
+ 
+    DTableH->tableLog = 0; 
+    DTableH->fastMode = 0; 
+ 
+    cell->newState = 0; 
+    cell->symbol = symbolValue; 
+    cell->nbBits = 0; 
+ 
+    return 0; 
+} 
+ 
+ 
+size_t FSEv07_buildDTable_raw (FSEv07_DTable* dt, unsigned nbBits) 
+{ 
+    void* ptr = dt; 
+    FSEv07_DTableHeader* const DTableH = (FSEv07_DTableHeader*)ptr; 
+    void* dPtr = dt + 1; 
+    FSEv07_decode_t* const dinfo = (FSEv07_decode_t*)dPtr; 
+    const unsigned tableSize = 1 << nbBits; 
+    const unsigned tableMask = tableSize - 1; 
+    const unsigned maxSV1 = tableMask+1; 
+    unsigned s; 
+ 
+    /* Sanity checks */ 
+    if (nbBits < 1) return ERROR(GENERIC);         /* min size */ 
+ 
+    /* Build Decoding Table */ 
+    DTableH->tableLog = (U16)nbBits; 
+    DTableH->fastMode = 1; 
+    for (s=0; s<maxSV1; s++) { 
+        dinfo[s].newState = 0; 
+        dinfo[s].symbol = (BYTE)s; 
+        dinfo[s].nbBits = (BYTE)nbBits; 
+    } 
+ 
+    return 0; 
+} 
+ 
+FORCE_INLINE size_t FSEv07_decompress_usingDTable_generic( 
+          void* dst, size_t maxDstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const FSEv07_DTable* dt, const unsigned fast) 
+{ 
+    BYTE* const ostart = (BYTE*) dst; 
+    BYTE* op = ostart; 
+    BYTE* const omax = op + maxDstSize; 
+    BYTE* const olimit = omax-3; 
+ 
+    BITv07_DStream_t bitD; 
+    FSEv07_DState_t state1; 
+    FSEv07_DState_t state2; 
+ 
+    /* Init */ 
+    { size_t const errorCode = BITv07_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */ 
+      if (FSEv07_isError(errorCode)) return errorCode; } 
+ 
+    FSEv07_initDState(&state1, &bitD, dt); 
+    FSEv07_initDState(&state2, &bitD, dt); 
+ 
+#define FSEv07_GETSYMBOL(statePtr) fast ? FSEv07_decodeSymbolFast(statePtr, &bitD) : FSEv07_decodeSymbol(statePtr, &bitD) 
+ 
+    /* 4 symbols per loop */ 
+    for ( ; (BITv07_reloadDStream(&bitD)==BITv07_DStream_unfinished) && (op<olimit) ; op+=4) { 
+        op[0] = FSEv07_GETSYMBOL(&state1); 
+ 
+        if (FSEv07_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            BITv07_reloadDStream(&bitD); 
+ 
+        op[1] = FSEv07_GETSYMBOL(&state2); 
+ 
+        if (FSEv07_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            { if (BITv07_reloadDStream(&bitD) > BITv07_DStream_unfinished) { op+=2; break; } } 
+ 
+        op[2] = FSEv07_GETSYMBOL(&state1); 
+ 
+        if (FSEv07_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */ 
+            BITv07_reloadDStream(&bitD); 
+ 
+        op[3] = FSEv07_GETSYMBOL(&state2); 
+    } 
+ 
+    /* tail */ 
+    /* note : BITv07_reloadDStream(&bitD) >= FSEv07_DStream_partiallyFilled; Ends at exactly BITv07_DStream_completed */ 
+    while (1) { 
+        if (op>(omax-2)) return ERROR(dstSize_tooSmall); 
+ 
+        *op++ = FSEv07_GETSYMBOL(&state1); 
+ 
+        if (BITv07_reloadDStream(&bitD)==BITv07_DStream_overflow) { 
+            *op++ = FSEv07_GETSYMBOL(&state2); 
+            break; 
+        } 
+ 
+        if (op>(omax-2)) return ERROR(dstSize_tooSmall); 
+ 
+        *op++ = FSEv07_GETSYMBOL(&state2); 
+ 
+        if (BITv07_reloadDStream(&bitD)==BITv07_DStream_overflow) { 
+            *op++ = FSEv07_GETSYMBOL(&state1); 
+            break; 
+    }   } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+size_t FSEv07_decompress_usingDTable(void* dst, size_t originalSize, 
+                            const void* cSrc, size_t cSrcSize, 
+                            const FSEv07_DTable* dt) 
+{ 
+    const void* ptr = dt; 
+    const FSEv07_DTableHeader* DTableH = (const FSEv07_DTableHeader*)ptr; 
+    const U32 fastMode = DTableH->fastMode; 
+ 
+    /* select fast mode (static) */ 
+    if (fastMode) return FSEv07_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1); 
+    return FSEv07_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0); 
+} 
+ 
+ 
+size_t FSEv07_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[FSEv07_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 = FSEv07_MAX_SYMBOL_VALUE; 
+ 
+    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */ 
+ 
+    /* normal FSE decoding mode */ 
+    {   size_t const NCountLength = FSEv07_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize); 
+        if (FSEv07_isError(NCountLength)) return NCountLength; 
+        if (NCountLength >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */ 
+        ip += NCountLength; 
+        cSrcSize -= NCountLength; 
+    } 
+ 
+    { size_t const errorCode = FSEv07_buildDTable (dt, counting, maxSymbolValue, tableLog); 
+      if (FSEv07_isError(errorCode)) return errorCode; } 
+ 
+    return FSEv07_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);   /* always return, even if it is an error code */ 
+} 
+ 
+ 
+ 
+#endif   /* FSEv07_COMMONDEFS_ONLY */ 
+ 
+/* ****************************************************************** 
+   Huffman decoder, part of New Generation Entropy library 
+   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 : 
+    - FSE+HUF 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 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#endif 
+ 
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#define HUFv07_STATIC_ASSERT(c) { enum { HUFv07_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */ 
+ 
+ 
+/*-***************************/ 
+/*  generic DTableDesc       */ 
+/*-***************************/ 
+ 
+typedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc; 
+ 
+static DTableDesc HUFv07_getDTableDesc(const HUFv07_DTable* table) 
+{ 
+    DTableDesc dtd; 
+    memcpy(&dtd, table, sizeof(dtd)); 
+    return dtd; 
+} 
+ 
+ 
+/*-***************************/ 
+/*  single-symbol decoding   */ 
+/*-***************************/ 
+ 
+typedef struct { BYTE byte; BYTE nbBits; } HUFv07_DEltX2;   /* single-symbol decoding */ 
+ 
+size_t HUFv07_readDTableX2 (HUFv07_DTable* DTable, const void* src, size_t srcSize) 
+{ 
+    BYTE huffWeight[HUFv07_SYMBOLVALUE_MAX + 1]; 
+    U32 rankVal[HUFv07_TABLELOG_ABSOLUTEMAX + 1];   /* large enough for values from 0 to 16 */ 
+    U32 tableLog = 0; 
+    U32 nbSymbols = 0; 
+    size_t iSize; 
+    void* const dtPtr = DTable + 1; 
+    HUFv07_DEltX2* const dt = (HUFv07_DEltX2*)dtPtr; 
+ 
+    HUFv07_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUFv07_DTable)); 
     /* memset(huffWeight, 0, sizeof(huffWeight)); */   /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUFv07_readStats(huffWeight, HUFv07_SYMBOLVALUE_MAX + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);
-    if (HUFv07_isError(iSize)) return iSize;
-
-    /* Table header */
-    {   DTableDesc dtd = HUFv07_getDTableDesc(DTable);
-        if (tableLog > (U32)(dtd.maxTableLog+1)) return ERROR(tableLog_tooLarge);   /* DTable too small, huffman tree cannot fit in */
-        dtd.tableType = 0;
-        dtd.tableLog = (BYTE)tableLog;
-        memcpy(DTable, &dtd, sizeof(dtd));
-    }
-
-    /* Prepare ranks */
-    {   U32 n, nextRankStart = 0;
-        for (n=1; n<tableLog+1; n++) {
-            U32 current = nextRankStart;
-            nextRankStart += (rankVal[n] << (n-1));
-            rankVal[n] = current;
-    }   }
-
-    /* fill DTable */
-    {   U32 n;
-        for (n=0; n<nbSymbols; n++) {
-            U32 const w = huffWeight[n];
-            U32 const length = (1 << w) >> 1;
-            U32 i;
-            HUFv07_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 HUFv07_decodeSymbolX2(BITv07_DStream_t* Dstream, const HUFv07_DEltX2* dt, const U32 dtLog)
-{
-    size_t const val = BITv07_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */
-    BYTE const c = dt[val].byte;
-    BITv07_skipBits(Dstream, dt[val].nbBits);
-    return c;
-}
-
-#define HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
-    *ptr++ = HUFv07_decodeSymbolX2(DStreamPtr, dt, dtLog)
-
-#define HUFv07_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
-    if (MEM_64bits() || (HUFv07_TABLELOG_MAX<=12)) \
-        HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
-
-#define HUFv07_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
-    if (MEM_64bits()) \
-        HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
-
-static inline size_t HUFv07_decodeStreamX2(BYTE* p, BITv07_DStream_t* const bitDPtr, BYTE* const pEnd, const HUFv07_DEltX2* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 4 symbols at a time */
-    while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p <= pEnd-4)) {
-        HUFv07_DECODE_SYMBOLX2_2(p, bitDPtr);
-        HUFv07_DECODE_SYMBOLX2_1(p, bitDPtr);
-        HUFv07_DECODE_SYMBOLX2_2(p, bitDPtr);
-        HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr);
-    }
-
-    /* closer to the end */
-    while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p < pEnd))
-        HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr);
-
-    /* no more data to retrieve from bitstream, hence no need to reload */
-    while (p < pEnd)
-        HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr);
-
-    return pEnd-pStart;
-}
-
-static size_t HUFv07_decompress1X2_usingDTable_internal(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUFv07_DTable* DTable)
-{
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + dstSize;
-    const void* dtPtr = DTable + 1;
-    const HUFv07_DEltX2* const dt = (const HUFv07_DEltX2*)dtPtr;
-    BITv07_DStream_t bitD;
-    DTableDesc const dtd = HUFv07_getDTableDesc(DTable);
-    U32 const dtLog = dtd.tableLog;
-
-    { size_t const errorCode = BITv07_initDStream(&bitD, cSrc, cSrcSize);
-      if (HUFv07_isError(errorCode)) return errorCode; }
-
-    HUFv07_decodeStreamX2(op, &bitD, oend, dt, dtLog);
-
-    /* check */
-    if (!BITv07_endOfDStream(&bitD)) return ERROR(corruption_detected);
-
-    return dstSize;
-}
-
-size_t HUFv07_decompress1X2_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUFv07_DTable* DTable)
-{
-    DTableDesc dtd = HUFv07_getDTableDesc(DTable);
-    if (dtd.tableType != 0) return ERROR(GENERIC);
-    return HUFv07_decompress1X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);
-}
-
-size_t HUFv07_decompress1X2_DCtx (HUFv07_DTable* DCtx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t const hSize = HUFv07_readDTableX2 (DCtx, cSrc, cSrcSize);
-    if (HUFv07_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize; cSrcSize -= hSize;
-
-    return HUFv07_decompress1X2_usingDTable_internal (dst, dstSize, ip, cSrcSize, DCtx);
-}
-
-size_t HUFv07_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUFv07_CREATE_STATIC_DTABLEX2(DTable, HUFv07_TABLELOG_MAX);
-    return HUFv07_decompress1X2_DCtx (DTable, dst, dstSize, cSrc, cSrcSize);
-}
-
-
-static size_t HUFv07_decompress4X2_usingDTable_internal(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUFv07_DTable* DTable)
-{
-    /* Check */
-    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 + 1;
-        const HUFv07_DEltX2* const dt = (const HUFv07_DEltX2*)dtPtr;
-
-        /* Init */
-        BITv07_DStream_t bitD1;
-        BITv07_DStream_t bitD2;
-        BITv07_DStream_t bitD3;
-        BITv07_DStream_t bitD4;
-        size_t const length1 = MEM_readLE16(istart);
-        size_t const length2 = MEM_readLE16(istart+2);
-        size_t const length3 = MEM_readLE16(istart+4);
-        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
-        const BYTE* const istart1 = istart + 6;  /* jumpTable */
-        const BYTE* const istart2 = istart1 + length1;
-        const BYTE* const istart3 = istart2 + length2;
-        const BYTE* const istart4 = istart3 + length3;
-        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;
-        DTableDesc const dtd = HUFv07_getDTableDesc(DTable);
-        U32 const dtLog = dtd.tableLog;
-
-        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
-        { size_t const errorCode = BITv07_initDStream(&bitD1, istart1, length1);
-          if (HUFv07_isError(errorCode)) return errorCode; }
-        { size_t const errorCode = BITv07_initDStream(&bitD2, istart2, length2);
-          if (HUFv07_isError(errorCode)) return errorCode; }
-        { size_t const errorCode = BITv07_initDStream(&bitD3, istart3, length3);
-          if (HUFv07_isError(errorCode)) return errorCode; }
-        { size_t const errorCode = BITv07_initDStream(&bitD4, istart4, length4);
-          if (HUFv07_isError(errorCode)) return errorCode; }
-
-        /* 16-32 symbols per loop (4-8 symbols per stream) */
-        endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4);
-        for ( ; (endSignal==BITv07_DStream_unfinished) && (op4<(oend-7)) ; ) {
-            HUFv07_DECODE_SYMBOLX2_2(op1, &bitD1);
-            HUFv07_DECODE_SYMBOLX2_2(op2, &bitD2);
-            HUFv07_DECODE_SYMBOLX2_2(op3, &bitD3);
-            HUFv07_DECODE_SYMBOLX2_2(op4, &bitD4);
-            HUFv07_DECODE_SYMBOLX2_1(op1, &bitD1);
-            HUFv07_DECODE_SYMBOLX2_1(op2, &bitD2);
-            HUFv07_DECODE_SYMBOLX2_1(op3, &bitD3);
-            HUFv07_DECODE_SYMBOLX2_1(op4, &bitD4);
-            HUFv07_DECODE_SYMBOLX2_2(op1, &bitD1);
-            HUFv07_DECODE_SYMBOLX2_2(op2, &bitD2);
-            HUFv07_DECODE_SYMBOLX2_2(op3, &bitD3);
-            HUFv07_DECODE_SYMBOLX2_2(op4, &bitD4);
-            HUFv07_DECODE_SYMBOLX2_0(op1, &bitD1);
-            HUFv07_DECODE_SYMBOLX2_0(op2, &bitD2);
-            HUFv07_DECODE_SYMBOLX2_0(op3, &bitD3);
-            HUFv07_DECODE_SYMBOLX2_0(op4, &bitD4);
-            endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_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 */
-        HUFv07_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
-        HUFv07_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
-        HUFv07_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
-        HUFv07_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
-
-        /* check */
-        endSignal = BITv07_endOfDStream(&bitD1) & BITv07_endOfDStream(&bitD2) & BITv07_endOfDStream(&bitD3) & BITv07_endOfDStream(&bitD4);
-        if (!endSignal) return ERROR(corruption_detected);
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
-
-size_t HUFv07_decompress4X2_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUFv07_DTable* DTable)
-{
-    DTableDesc dtd = HUFv07_getDTableDesc(DTable);
-    if (dtd.tableType != 0) return ERROR(GENERIC);
-    return HUFv07_decompress4X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);
-}
-
-
-size_t HUFv07_decompress4X2_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t const hSize = HUFv07_readDTableX2 (dctx, cSrc, cSrcSize);
-    if (HUFv07_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize; cSrcSize -= hSize;
-
-    return HUFv07_decompress4X2_usingDTable_internal (dst, dstSize, ip, cSrcSize, dctx);
-}
-
-size_t HUFv07_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUFv07_CREATE_STATIC_DTABLEX2(DTable, HUFv07_TABLELOG_MAX);
-    return HUFv07_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
-}
-
-
-/* *************************/
-/* double-symbols decoding */
-/* *************************/
-typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUFv07_DEltX4;  /* double-symbols decoding */
-
-typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;
-
-static void HUFv07_fillDTableX4Level2(HUFv07_DEltX4* DTable, U32 sizeLog, const U32 consumed,
-                           const U32* rankValOrigin, const int minWeight,
-                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,
-                           U32 nbBitsBaseline, U16 baseSeq)
-{
-    HUFv07_DEltX4 DElt;
-    U32 rankVal[HUFv07_TABLELOG_ABSOLUTEMAX + 1];
-
-    /* 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 */
-    { U32 s; 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[HUFv07_TABLELOG_ABSOLUTEMAX][HUFv07_TABLELOG_ABSOLUTEMAX + 1];
-
-static void HUFv07_fillDTableX4(HUFv07_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[HUFv07_TABLELOG_ABSOLUTEMAX + 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];
-            HUFv07_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,
-                           rankValOrigin[nbBits], minWeight,
-                           sortedList+sortedRank, sortedListSize-sortedRank,
-                           nbBitsBaseline, symbol);
-        } else {
-            HUFv07_DEltX4 DElt;
-            MEM_writeLE16(&(DElt.sequence), symbol);
-            DElt.nbBits = (BYTE)(nbBits);
-            DElt.length = 1;
-            {   U32 u;
-                const U32 end = start + length;
-                for (u = start; u < end; u++) DTable[u] = DElt;
-        }   }
-        rankVal[weight] += length;
-    }
-}
-
-size_t HUFv07_readDTableX4 (HUFv07_DTable* DTable, const void* src, size_t srcSize)
-{
-    BYTE weightList[HUFv07_SYMBOLVALUE_MAX + 1];
-    sortedSymbol_t sortedSymbol[HUFv07_SYMBOLVALUE_MAX + 1];
-    U32 rankStats[HUFv07_TABLELOG_ABSOLUTEMAX + 1] = { 0 };
-    U32 rankStart0[HUFv07_TABLELOG_ABSOLUTEMAX + 2] = { 0 };
-    U32* const rankStart = rankStart0+1;
-    rankVal_t rankVal;
-    U32 tableLog, maxW, sizeOfSort, nbSymbols;
-    DTableDesc dtd = HUFv07_getDTableDesc(DTable);
-    U32 const maxTableLog = dtd.maxTableLog;
-    size_t iSize;
-    void* dtPtr = DTable+1;   /* force compiler to avoid strict-aliasing */
-    HUFv07_DEltX4* const dt = (HUFv07_DEltX4*)dtPtr;
-
-    HUFv07_STATIC_ASSERT(sizeof(HUFv07_DEltX4) == sizeof(HUFv07_DTable));   /* if compilation fails here, assertion is false */
-    if (maxTableLog > HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(tableLog_tooLarge);
+ 
+    iSize = HUFv07_readStats(huffWeight, HUFv07_SYMBOLVALUE_MAX + 1, rankVal, &nbSymbols, &tableLog, src, srcSize); 
+    if (HUFv07_isError(iSize)) return iSize; 
+ 
+    /* Table header */ 
+    {   DTableDesc dtd = HUFv07_getDTableDesc(DTable); 
+        if (tableLog > (U32)(dtd.maxTableLog+1)) return ERROR(tableLog_tooLarge);   /* DTable too small, huffman tree cannot fit in */ 
+        dtd.tableType = 0; 
+        dtd.tableLog = (BYTE)tableLog; 
+        memcpy(DTable, &dtd, sizeof(dtd)); 
+    } 
+ 
+    /* Prepare ranks */ 
+    {   U32 n, nextRankStart = 0; 
+        for (n=1; n<tableLog+1; n++) { 
+            U32 current = nextRankStart; 
+            nextRankStart += (rankVal[n] << (n-1)); 
+            rankVal[n] = current; 
+    }   } 
+ 
+    /* fill DTable */ 
+    {   U32 n; 
+        for (n=0; n<nbSymbols; n++) { 
+            U32 const w = huffWeight[n]; 
+            U32 const length = (1 << w) >> 1; 
+            U32 i; 
+            HUFv07_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 HUFv07_decodeSymbolX2(BITv07_DStream_t* Dstream, const HUFv07_DEltX2* dt, const U32 dtLog) 
+{ 
+    size_t const val = BITv07_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */ 
+    BYTE const c = dt[val].byte; 
+    BITv07_skipBits(Dstream, dt[val].nbBits); 
+    return c; 
+} 
+ 
+#define HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \ 
+    *ptr++ = HUFv07_decodeSymbolX2(DStreamPtr, dt, dtLog) 
+ 
+#define HUFv07_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \ 
+    if (MEM_64bits() || (HUFv07_TABLELOG_MAX<=12)) \ 
+        HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr) 
+ 
+#define HUFv07_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \ 
+    if (MEM_64bits()) \ 
+        HUFv07_DECODE_SYMBOLX2_0(ptr, DStreamPtr) 
+ 
+static inline size_t HUFv07_decodeStreamX2(BYTE* p, BITv07_DStream_t* const bitDPtr, BYTE* const pEnd, const HUFv07_DEltX2* const dt, const U32 dtLog) 
+{ 
+    BYTE* const pStart = p; 
+ 
+    /* up to 4 symbols at a time */ 
+    while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p <= pEnd-4)) { 
+        HUFv07_DECODE_SYMBOLX2_2(p, bitDPtr); 
+        HUFv07_DECODE_SYMBOLX2_1(p, bitDPtr); 
+        HUFv07_DECODE_SYMBOLX2_2(p, bitDPtr); 
+        HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr); 
+    } 
+ 
+    /* closer to the end */ 
+    while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p < pEnd)) 
+        HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr); 
+ 
+    /* no more data to retrieve from bitstream, hence no need to reload */ 
+    while (p < pEnd) 
+        HUFv07_DECODE_SYMBOLX2_0(p, bitDPtr); 
+ 
+    return pEnd-pStart; 
+} 
+ 
+static size_t HUFv07_decompress1X2_usingDTable_internal( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const HUFv07_DTable* DTable) 
+{ 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + dstSize; 
+    const void* dtPtr = DTable + 1; 
+    const HUFv07_DEltX2* const dt = (const HUFv07_DEltX2*)dtPtr; 
+    BITv07_DStream_t bitD; 
+    DTableDesc const dtd = HUFv07_getDTableDesc(DTable); 
+    U32 const dtLog = dtd.tableLog; 
+ 
+    { size_t const errorCode = BITv07_initDStream(&bitD, cSrc, cSrcSize); 
+      if (HUFv07_isError(errorCode)) return errorCode; } 
+ 
+    HUFv07_decodeStreamX2(op, &bitD, oend, dt, dtLog); 
+ 
+    /* check */ 
+    if (!BITv07_endOfDStream(&bitD)) return ERROR(corruption_detected); 
+ 
+    return dstSize; 
+} 
+ 
+size_t HUFv07_decompress1X2_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const HUFv07_DTable* DTable) 
+{ 
+    DTableDesc dtd = HUFv07_getDTableDesc(DTable); 
+    if (dtd.tableType != 0) return ERROR(GENERIC); 
+    return HUFv07_decompress1X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable); 
+} 
+ 
+size_t HUFv07_decompress1X2_DCtx (HUFv07_DTable* DCtx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
+    size_t const hSize = HUFv07_readDTableX2 (DCtx, cSrc, cSrcSize); 
+    if (HUFv07_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; cSrcSize -= hSize; 
+ 
+    return HUFv07_decompress1X2_usingDTable_internal (dst, dstSize, ip, cSrcSize, DCtx); 
+} 
+ 
+size_t HUFv07_decompress1X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUFv07_CREATE_STATIC_DTABLEX2(DTable, HUFv07_TABLELOG_MAX); 
+    return HUFv07_decompress1X2_DCtx (DTable, dst, dstSize, cSrc, cSrcSize); 
+} 
+ 
+ 
+static size_t HUFv07_decompress4X2_usingDTable_internal( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const HUFv07_DTable* DTable) 
+{ 
+    /* Check */ 
+    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 + 1; 
+        const HUFv07_DEltX2* const dt = (const HUFv07_DEltX2*)dtPtr; 
+ 
+        /* Init */ 
+        BITv07_DStream_t bitD1; 
+        BITv07_DStream_t bitD2; 
+        BITv07_DStream_t bitD3; 
+        BITv07_DStream_t bitD4; 
+        size_t const length1 = MEM_readLE16(istart); 
+        size_t const length2 = MEM_readLE16(istart+2); 
+        size_t const length3 = MEM_readLE16(istart+4); 
+        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6); 
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */ 
+        const BYTE* const istart2 = istart1 + length1; 
+        const BYTE* const istart3 = istart2 + length2; 
+        const BYTE* const istart4 = istart3 + length3; 
+        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; 
+        DTableDesc const dtd = HUFv07_getDTableDesc(DTable); 
+        U32 const dtLog = dtd.tableLog; 
+ 
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */ 
+        { size_t const errorCode = BITv07_initDStream(&bitD1, istart1, length1); 
+          if (HUFv07_isError(errorCode)) return errorCode; } 
+        { size_t const errorCode = BITv07_initDStream(&bitD2, istart2, length2); 
+          if (HUFv07_isError(errorCode)) return errorCode; } 
+        { size_t const errorCode = BITv07_initDStream(&bitD3, istart3, length3); 
+          if (HUFv07_isError(errorCode)) return errorCode; } 
+        { size_t const errorCode = BITv07_initDStream(&bitD4, istart4, length4); 
+          if (HUFv07_isError(errorCode)) return errorCode; } 
+ 
+        /* 16-32 symbols per loop (4-8 symbols per stream) */ 
+        endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4); 
+        for ( ; (endSignal==BITv07_DStream_unfinished) && (op4<(oend-7)) ; ) { 
+            HUFv07_DECODE_SYMBOLX2_2(op1, &bitD1); 
+            HUFv07_DECODE_SYMBOLX2_2(op2, &bitD2); 
+            HUFv07_DECODE_SYMBOLX2_2(op3, &bitD3); 
+            HUFv07_DECODE_SYMBOLX2_2(op4, &bitD4); 
+            HUFv07_DECODE_SYMBOLX2_1(op1, &bitD1); 
+            HUFv07_DECODE_SYMBOLX2_1(op2, &bitD2); 
+            HUFv07_DECODE_SYMBOLX2_1(op3, &bitD3); 
+            HUFv07_DECODE_SYMBOLX2_1(op4, &bitD4); 
+            HUFv07_DECODE_SYMBOLX2_2(op1, &bitD1); 
+            HUFv07_DECODE_SYMBOLX2_2(op2, &bitD2); 
+            HUFv07_DECODE_SYMBOLX2_2(op3, &bitD3); 
+            HUFv07_DECODE_SYMBOLX2_2(op4, &bitD4); 
+            HUFv07_DECODE_SYMBOLX2_0(op1, &bitD1); 
+            HUFv07_DECODE_SYMBOLX2_0(op2, &bitD2); 
+            HUFv07_DECODE_SYMBOLX2_0(op3, &bitD3); 
+            HUFv07_DECODE_SYMBOLX2_0(op4, &bitD4); 
+            endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_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 */ 
+        HUFv07_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog); 
+        HUFv07_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog); 
+        HUFv07_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog); 
+        HUFv07_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog); 
+ 
+        /* check */ 
+        endSignal = BITv07_endOfDStream(&bitD1) & BITv07_endOfDStream(&bitD2) & BITv07_endOfDStream(&bitD3) & BITv07_endOfDStream(&bitD4); 
+        if (!endSignal) return ERROR(corruption_detected); 
+ 
+        /* decoded size */ 
+        return dstSize; 
+    } 
+} 
+ 
+ 
+size_t HUFv07_decompress4X2_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const HUFv07_DTable* DTable) 
+{ 
+    DTableDesc dtd = HUFv07_getDTableDesc(DTable); 
+    if (dtd.tableType != 0) return ERROR(GENERIC); 
+    return HUFv07_decompress4X2_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable); 
+} 
+ 
+ 
+size_t HUFv07_decompress4X2_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
+    size_t const hSize = HUFv07_readDTableX2 (dctx, cSrc, cSrcSize); 
+    if (HUFv07_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; cSrcSize -= hSize; 
+ 
+    return HUFv07_decompress4X2_usingDTable_internal (dst, dstSize, ip, cSrcSize, dctx); 
+} 
+ 
+size_t HUFv07_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUFv07_CREATE_STATIC_DTABLEX2(DTable, HUFv07_TABLELOG_MAX); 
+    return HUFv07_decompress4X2_DCtx(DTable, dst, dstSize, cSrc, cSrcSize); 
+} 
+ 
+ 
+/* *************************/ 
+/* double-symbols decoding */ 
+/* *************************/ 
+typedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUFv07_DEltX4;  /* double-symbols decoding */ 
+ 
+typedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t; 
+ 
+static void HUFv07_fillDTableX4Level2(HUFv07_DEltX4* DTable, U32 sizeLog, const U32 consumed, 
+                           const U32* rankValOrigin, const int minWeight, 
+                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize, 
+                           U32 nbBitsBaseline, U16 baseSeq) 
+{ 
+    HUFv07_DEltX4 DElt; 
+    U32 rankVal[HUFv07_TABLELOG_ABSOLUTEMAX + 1]; 
+ 
+    /* 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 */ 
+    { U32 s; 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[HUFv07_TABLELOG_ABSOLUTEMAX][HUFv07_TABLELOG_ABSOLUTEMAX + 1]; 
+ 
+static void HUFv07_fillDTableX4(HUFv07_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[HUFv07_TABLELOG_ABSOLUTEMAX + 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]; 
+            HUFv07_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits, 
+                           rankValOrigin[nbBits], minWeight, 
+                           sortedList+sortedRank, sortedListSize-sortedRank, 
+                           nbBitsBaseline, symbol); 
+        } else { 
+            HUFv07_DEltX4 DElt; 
+            MEM_writeLE16(&(DElt.sequence), symbol); 
+            DElt.nbBits = (BYTE)(nbBits); 
+            DElt.length = 1; 
+            {   U32 u; 
+                const U32 end = start + length; 
+                for (u = start; u < end; u++) DTable[u] = DElt; 
+        }   } 
+        rankVal[weight] += length; 
+    } 
+} 
+ 
+size_t HUFv07_readDTableX4 (HUFv07_DTable* DTable, const void* src, size_t srcSize) 
+{ 
+    BYTE weightList[HUFv07_SYMBOLVALUE_MAX + 1]; 
+    sortedSymbol_t sortedSymbol[HUFv07_SYMBOLVALUE_MAX + 1]; 
+    U32 rankStats[HUFv07_TABLELOG_ABSOLUTEMAX + 1] = { 0 }; 
+    U32 rankStart0[HUFv07_TABLELOG_ABSOLUTEMAX + 2] = { 0 }; 
+    U32* const rankStart = rankStart0+1; 
+    rankVal_t rankVal; 
+    U32 tableLog, maxW, sizeOfSort, nbSymbols; 
+    DTableDesc dtd = HUFv07_getDTableDesc(DTable); 
+    U32 const maxTableLog = dtd.maxTableLog; 
+    size_t iSize; 
+    void* dtPtr = DTable+1;   /* force compiler to avoid strict-aliasing */ 
+    HUFv07_DEltX4* const dt = (HUFv07_DEltX4*)dtPtr; 
+ 
+    HUFv07_STATIC_ASSERT(sizeof(HUFv07_DEltX4) == sizeof(HUFv07_DTable));   /* if compilation fails here, assertion is false */ 
+    if (maxTableLog > HUFv07_TABLELOG_ABSOLUTEMAX) return ERROR(tableLog_tooLarge); 
     /* memset(weightList, 0, sizeof(weightList)); */   /* is not necessary, even though some analyzer complain ... */
-
-    iSize = HUFv07_readStats(weightList, HUFv07_SYMBOLVALUE_MAX + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);
-    if (HUFv07_isError(iSize)) return iSize;
-
-    /* check result */
-    if (tableLog > maxTableLog) 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+1; 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 const w = weightList[s];
-            U32 const 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 */
-    {   U32* const rankVal0 = rankVal[0];
-        {   int const rescale = (maxTableLog-tableLog) - 1;   /* tableLog <= maxTableLog */
-            U32 nextRankVal = 0;
-            U32 w;
-            for (w=1; w<maxW+1; w++) {
-                U32 current = nextRankVal;
-                nextRankVal += rankStats[w] << (w+rescale);
-                rankVal0[w] = current;
-        }   }
-        {   U32 const minBits = tableLog+1 - maxW;
-            U32 consumed;
-            for (consumed = minBits; consumed < maxTableLog - minBits + 1; consumed++) {
-                U32* const rankValPtr = rankVal[consumed];
-                U32 w;
-                for (w = 1; w < maxW+1; w++) {
-                    rankValPtr[w] = rankVal0[w] >> consumed;
-    }   }   }   }
-
-    HUFv07_fillDTableX4(dt, maxTableLog,
-                   sortedSymbol, sizeOfSort,
-                   rankStart0, rankVal, maxW,
-                   tableLog+1);
-
-    dtd.tableLog = (BYTE)maxTableLog;
-    dtd.tableType = 1;
-    memcpy(DTable, &dtd, sizeof(dtd));
-    return iSize;
-}
-
-
-static U32 HUFv07_decodeSymbolX4(void* op, BITv07_DStream_t* DStream, const HUFv07_DEltX4* dt, const U32 dtLog)
-{
-    const size_t val = BITv07_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    memcpy(op, dt+val, 2);
-    BITv07_skipBits(DStream, dt[val].nbBits);
-    return dt[val].length;
-}
-
-static U32 HUFv07_decodeLastSymbolX4(void* op, BITv07_DStream_t* DStream, const HUFv07_DEltX4* dt, const U32 dtLog)
-{
-    const size_t val = BITv07_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
-    memcpy(op, dt+val, 1);
-    if (dt[val].length==1) BITv07_skipBits(DStream, dt[val].nbBits);
-    else {
-        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {
-            BITv07_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 HUFv07_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \
-    ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-#define HUFv07_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \
-    if (MEM_64bits() || (HUFv07_TABLELOG_MAX<=12)) \
-        ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-#define HUFv07_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \
-    if (MEM_64bits()) \
-        ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
-
-static inline size_t HUFv07_decodeStreamX4(BYTE* p, BITv07_DStream_t* bitDPtr, BYTE* const pEnd, const HUFv07_DEltX4* const dt, const U32 dtLog)
-{
-    BYTE* const pStart = p;
-
-    /* up to 8 symbols at a time */
-    while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p < pEnd-7)) {
-        HUFv07_DECODE_SYMBOLX4_2(p, bitDPtr);
-        HUFv07_DECODE_SYMBOLX4_1(p, bitDPtr);
-        HUFv07_DECODE_SYMBOLX4_2(p, bitDPtr);
-        HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr);
-    }
-
-    /* closer to end : up to 2 symbols at a time */
-    while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p <= pEnd-2))
-        HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr);
-
-    while (p <= pEnd-2)
-        HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
-
-    if (p < pEnd)
-        p += HUFv07_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);
-
-    return p-pStart;
-}
-
-
-static size_t HUFv07_decompress1X4_usingDTable_internal(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUFv07_DTable* DTable)
-{
-    BITv07_DStream_t bitD;
-
-    /* Init */
-    {   size_t const errorCode = BITv07_initDStream(&bitD, cSrc, cSrcSize);
-        if (HUFv07_isError(errorCode)) return errorCode;
-    }
-
-    /* decode */
-    {   BYTE* const ostart = (BYTE*) dst;
-        BYTE* const oend = ostart + dstSize;
-        const void* const dtPtr = DTable+1;   /* force compiler to not use strict-aliasing */
-        const HUFv07_DEltX4* const dt = (const HUFv07_DEltX4*)dtPtr;
-        DTableDesc const dtd = HUFv07_getDTableDesc(DTable);
-        HUFv07_decodeStreamX4(ostart, &bitD, oend, dt, dtd.tableLog);
-    }
-
-    /* check */
-    if (!BITv07_endOfDStream(&bitD)) return ERROR(corruption_detected);
-
-    /* decoded size */
-    return dstSize;
-}
-
-size_t HUFv07_decompress1X4_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUFv07_DTable* DTable)
-{
-    DTableDesc dtd = HUFv07_getDTableDesc(DTable);
-    if (dtd.tableType != 1) return ERROR(GENERIC);
-    return HUFv07_decompress1X4_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);
-}
-
-size_t HUFv07_decompress1X4_DCtx (HUFv07_DTable* DCtx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t const hSize = HUFv07_readDTableX4 (DCtx, cSrc, cSrcSize);
-    if (HUFv07_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize; cSrcSize -= hSize;
-
-    return HUFv07_decompress1X4_usingDTable_internal (dst, dstSize, ip, cSrcSize, DCtx);
-}
-
-size_t HUFv07_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUFv07_CREATE_STATIC_DTABLEX4(DTable, HUFv07_TABLELOG_MAX);
-    return HUFv07_decompress1X4_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
-}
-
-static size_t HUFv07_decompress4X4_usingDTable_internal(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUFv07_DTable* DTable)
-{
-    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */
-
-    {   const BYTE* const istart = (const BYTE*) cSrc;
-        BYTE* const ostart = (BYTE*) dst;
-        BYTE* const oend = ostart + dstSize;
-        const void* const dtPtr = DTable+1;
-        const HUFv07_DEltX4* const dt = (const HUFv07_DEltX4*)dtPtr;
-
-        /* Init */
-        BITv07_DStream_t bitD1;
-        BITv07_DStream_t bitD2;
-        BITv07_DStream_t bitD3;
-        BITv07_DStream_t bitD4;
-        size_t const length1 = MEM_readLE16(istart);
-        size_t const length2 = MEM_readLE16(istart+2);
-        size_t const length3 = MEM_readLE16(istart+4);
-        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);
-        const BYTE* const istart1 = istart + 6;  /* jumpTable */
-        const BYTE* const istart2 = istart1 + length1;
-        const BYTE* const istart3 = istart2 + length2;
-        const BYTE* const istart4 = istart3 + length3;
-        size_t const segmentSize = (dstSize+3) / 4;
-        BYTE* const opStart2 = ostart + segmentSize;
-        BYTE* const opStart3 = opStart2 + segmentSize;
-        BYTE* const opStart4 = opStart3 + segmentSize;
-        BYTE* op1 = ostart;
-        BYTE* op2 = opStart2;
-        BYTE* op3 = opStart3;
-        BYTE* op4 = opStart4;
-        U32 endSignal;
-        DTableDesc const dtd = HUFv07_getDTableDesc(DTable);
-        U32 const dtLog = dtd.tableLog;
-
-        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */
-        { size_t const errorCode = BITv07_initDStream(&bitD1, istart1, length1);
-          if (HUFv07_isError(errorCode)) return errorCode; }
-        { size_t const errorCode = BITv07_initDStream(&bitD2, istart2, length2);
-          if (HUFv07_isError(errorCode)) return errorCode; }
-        { size_t const errorCode = BITv07_initDStream(&bitD3, istart3, length3);
-          if (HUFv07_isError(errorCode)) return errorCode; }
-        { size_t const errorCode = BITv07_initDStream(&bitD4, istart4, length4);
-          if (HUFv07_isError(errorCode)) return errorCode; }
-
-        /* 16-32 symbols per loop (4-8 symbols per stream) */
-        endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4);
-        for ( ; (endSignal==BITv07_DStream_unfinished) && (op4<(oend-7)) ; ) {
-            HUFv07_DECODE_SYMBOLX4_2(op1, &bitD1);
-            HUFv07_DECODE_SYMBOLX4_2(op2, &bitD2);
-            HUFv07_DECODE_SYMBOLX4_2(op3, &bitD3);
-            HUFv07_DECODE_SYMBOLX4_2(op4, &bitD4);
-            HUFv07_DECODE_SYMBOLX4_1(op1, &bitD1);
-            HUFv07_DECODE_SYMBOLX4_1(op2, &bitD2);
-            HUFv07_DECODE_SYMBOLX4_1(op3, &bitD3);
-            HUFv07_DECODE_SYMBOLX4_1(op4, &bitD4);
-            HUFv07_DECODE_SYMBOLX4_2(op1, &bitD1);
-            HUFv07_DECODE_SYMBOLX4_2(op2, &bitD2);
-            HUFv07_DECODE_SYMBOLX4_2(op3, &bitD3);
-            HUFv07_DECODE_SYMBOLX4_2(op4, &bitD4);
-            HUFv07_DECODE_SYMBOLX4_0(op1, &bitD1);
-            HUFv07_DECODE_SYMBOLX4_0(op2, &bitD2);
-            HUFv07_DECODE_SYMBOLX4_0(op3, &bitD3);
-            HUFv07_DECODE_SYMBOLX4_0(op4, &bitD4);
-
-            endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_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 */
-        HUFv07_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);
-        HUFv07_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);
-        HUFv07_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);
-        HUFv07_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog);
-
-        /* check */
-        { U32 const endCheck = BITv07_endOfDStream(&bitD1) & BITv07_endOfDStream(&bitD2) & BITv07_endOfDStream(&bitD3) & BITv07_endOfDStream(&bitD4);
-          if (!endCheck) return ERROR(corruption_detected); }
-
-        /* decoded size */
-        return dstSize;
-    }
-}
-
-
-size_t HUFv07_decompress4X4_usingDTable(
-          void* dst,  size_t dstSize,
-    const void* cSrc, size_t cSrcSize,
-    const HUFv07_DTable* DTable)
-{
-    DTableDesc dtd = HUFv07_getDTableDesc(DTable);
-    if (dtd.tableType != 1) return ERROR(GENERIC);
-    return HUFv07_decompress4X4_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable);
-}
-
-
-size_t HUFv07_decompress4X4_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    const BYTE* ip = (const BYTE*) cSrc;
-
-    size_t hSize = HUFv07_readDTableX4 (dctx, cSrc, cSrcSize);
-    if (HUFv07_isError(hSize)) return hSize;
-    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
-    ip += hSize; cSrcSize -= hSize;
-
-    return HUFv07_decompress4X4_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx);
-}
-
-size_t HUFv07_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    HUFv07_CREATE_STATIC_DTABLEX4(DTable, HUFv07_TABLELOG_MAX);
-    return HUFv07_decompress4X4_DCtx(DTable, dst, dstSize, cSrc, cSrcSize);
-}
-
-
-/* ********************************/
-/* Generic decompression selector */
-/* ********************************/
-
-size_t HUFv07_decompress1X_usingDTable(void* dst, size_t maxDstSize,
-                                    const void* cSrc, size_t cSrcSize,
-                                    const HUFv07_DTable* DTable)
-{
-    DTableDesc const dtd = HUFv07_getDTableDesc(DTable);
-    return dtd.tableType ? HUFv07_decompress1X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable) :
-                           HUFv07_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable);
-}
-
-size_t HUFv07_decompress4X_usingDTable(void* dst, size_t maxDstSize,
-                                    const void* cSrc, size_t cSrcSize,
-                                    const HUFv07_DTable* DTable)
-{
-    DTableDesc const dtd = HUFv07_getDTableDesc(DTable);
-    return dtd.tableType ? HUFv07_decompress4X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable) :
-                           HUFv07_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable);
-}
-
-
-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% */
-};
-
-/** HUFv07_selectDecoder() :
-*   Tells which decoder is likely to decode faster,
-*   based on a set of pre-determined metrics.
-*   @return : 0==HUFv07_decompress4X2, 1==HUFv07_decompress4X4 .
-*   Assumption : 0 < cSrcSize < dstSize <= 128 KB */
-U32 HUFv07_selectDecoder (size_t dstSize, size_t cSrcSize)
-{
-    /* decoder timing evaluation */
-    U32 const Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */
-    U32 const D256 = (U32)(dstSize >> 8);
-    U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256);
-    U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256);
-    DTime1 += DTime1 >> 3;  /* advantage to algorithm using less memory, for cache eviction */
-
-    return DTime1 < DTime0;
-}
-
-
-typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize);
-
-size_t HUFv07_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    static const decompressionAlgo decompress[2] = { HUFv07_decompress4X2, HUFv07_decompress4X4 };
-
-    /* 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 */
-
-    {   U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize);
-        return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
-    }
-
+ 
+    iSize = HUFv07_readStats(weightList, HUFv07_SYMBOLVALUE_MAX + 1, rankStats, &nbSymbols, &tableLog, src, srcSize); 
+    if (HUFv07_isError(iSize)) return iSize; 
+ 
+    /* check result */ 
+    if (tableLog > maxTableLog) 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+1; 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 const w = weightList[s]; 
+            U32 const 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 */ 
+    {   U32* const rankVal0 = rankVal[0]; 
+        {   int const rescale = (maxTableLog-tableLog) - 1;   /* tableLog <= maxTableLog */ 
+            U32 nextRankVal = 0; 
+            U32 w; 
+            for (w=1; w<maxW+1; w++) { 
+                U32 current = nextRankVal; 
+                nextRankVal += rankStats[w] << (w+rescale); 
+                rankVal0[w] = current; 
+        }   } 
+        {   U32 const minBits = tableLog+1 - maxW; 
+            U32 consumed; 
+            for (consumed = minBits; consumed < maxTableLog - minBits + 1; consumed++) { 
+                U32* const rankValPtr = rankVal[consumed]; 
+                U32 w; 
+                for (w = 1; w < maxW+1; w++) { 
+                    rankValPtr[w] = rankVal0[w] >> consumed; 
+    }   }   }   } 
+ 
+    HUFv07_fillDTableX4(dt, maxTableLog, 
+                   sortedSymbol, sizeOfSort, 
+                   rankStart0, rankVal, maxW, 
+                   tableLog+1); 
+ 
+    dtd.tableLog = (BYTE)maxTableLog; 
+    dtd.tableType = 1; 
+    memcpy(DTable, &dtd, sizeof(dtd)); 
+    return iSize; 
+} 
+ 
+ 
+static U32 HUFv07_decodeSymbolX4(void* op, BITv07_DStream_t* DStream, const HUFv07_DEltX4* dt, const U32 dtLog) 
+{ 
+    const size_t val = BITv07_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    memcpy(op, dt+val, 2); 
+    BITv07_skipBits(DStream, dt[val].nbBits); 
+    return dt[val].length; 
+} 
+ 
+static U32 HUFv07_decodeLastSymbolX4(void* op, BITv07_DStream_t* DStream, const HUFv07_DEltX4* dt, const U32 dtLog) 
+{ 
+    const size_t val = BITv07_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */ 
+    memcpy(op, dt+val, 1); 
+    if (dt[val].length==1) BITv07_skipBits(DStream, dt[val].nbBits); 
+    else { 
+        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) { 
+            BITv07_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 HUFv07_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \ 
+    ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+#define HUFv07_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \ 
+    if (MEM_64bits() || (HUFv07_TABLELOG_MAX<=12)) \ 
+        ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+#define HUFv07_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \ 
+    if (MEM_64bits()) \ 
+        ptr += HUFv07_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog) 
+ 
+static inline size_t HUFv07_decodeStreamX4(BYTE* p, BITv07_DStream_t* bitDPtr, BYTE* const pEnd, const HUFv07_DEltX4* const dt, const U32 dtLog) 
+{ 
+    BYTE* const pStart = p; 
+ 
+    /* up to 8 symbols at a time */ 
+    while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p < pEnd-7)) { 
+        HUFv07_DECODE_SYMBOLX4_2(p, bitDPtr); 
+        HUFv07_DECODE_SYMBOLX4_1(p, bitDPtr); 
+        HUFv07_DECODE_SYMBOLX4_2(p, bitDPtr); 
+        HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr); 
+    } 
+ 
+    /* closer to end : up to 2 symbols at a time */ 
+    while ((BITv07_reloadDStream(bitDPtr) == BITv07_DStream_unfinished) && (p <= pEnd-2)) 
+        HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr); 
+ 
+    while (p <= pEnd-2) 
+        HUFv07_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */ 
+ 
+    if (p < pEnd) 
+        p += HUFv07_decodeLastSymbolX4(p, bitDPtr, dt, dtLog); 
+ 
+    return p-pStart; 
+} 
+ 
+ 
+static size_t HUFv07_decompress1X4_usingDTable_internal( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const HUFv07_DTable* DTable) 
+{ 
+    BITv07_DStream_t bitD; 
+ 
+    /* Init */ 
+    {   size_t const errorCode = BITv07_initDStream(&bitD, cSrc, cSrcSize); 
+        if (HUFv07_isError(errorCode)) return errorCode; 
+    } 
+ 
+    /* decode */ 
+    {   BYTE* const ostart = (BYTE*) dst; 
+        BYTE* const oend = ostart + dstSize; 
+        const void* const dtPtr = DTable+1;   /* force compiler to not use strict-aliasing */ 
+        const HUFv07_DEltX4* const dt = (const HUFv07_DEltX4*)dtPtr; 
+        DTableDesc const dtd = HUFv07_getDTableDesc(DTable); 
+        HUFv07_decodeStreamX4(ostart, &bitD, oend, dt, dtd.tableLog); 
+    } 
+ 
+    /* check */ 
+    if (!BITv07_endOfDStream(&bitD)) return ERROR(corruption_detected); 
+ 
+    /* decoded size */ 
+    return dstSize; 
+} 
+ 
+size_t HUFv07_decompress1X4_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const HUFv07_DTable* DTable) 
+{ 
+    DTableDesc dtd = HUFv07_getDTableDesc(DTable); 
+    if (dtd.tableType != 1) return ERROR(GENERIC); 
+    return HUFv07_decompress1X4_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable); 
+} 
+ 
+size_t HUFv07_decompress1X4_DCtx (HUFv07_DTable* DCtx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
+    size_t const hSize = HUFv07_readDTableX4 (DCtx, cSrc, cSrcSize); 
+    if (HUFv07_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; cSrcSize -= hSize; 
+ 
+    return HUFv07_decompress1X4_usingDTable_internal (dst, dstSize, ip, cSrcSize, DCtx); 
+} 
+ 
+size_t HUFv07_decompress1X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUFv07_CREATE_STATIC_DTABLEX4(DTable, HUFv07_TABLELOG_MAX); 
+    return HUFv07_decompress1X4_DCtx(DTable, dst, dstSize, cSrc, cSrcSize); 
+} 
+ 
+static size_t HUFv07_decompress4X4_usingDTable_internal( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const HUFv07_DTable* DTable) 
+{ 
+    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */ 
+ 
+    {   const BYTE* const istart = (const BYTE*) cSrc; 
+        BYTE* const ostart = (BYTE*) dst; 
+        BYTE* const oend = ostart + dstSize; 
+        const void* const dtPtr = DTable+1; 
+        const HUFv07_DEltX4* const dt = (const HUFv07_DEltX4*)dtPtr; 
+ 
+        /* Init */ 
+        BITv07_DStream_t bitD1; 
+        BITv07_DStream_t bitD2; 
+        BITv07_DStream_t bitD3; 
+        BITv07_DStream_t bitD4; 
+        size_t const length1 = MEM_readLE16(istart); 
+        size_t const length2 = MEM_readLE16(istart+2); 
+        size_t const length3 = MEM_readLE16(istart+4); 
+        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6); 
+        const BYTE* const istart1 = istart + 6;  /* jumpTable */ 
+        const BYTE* const istart2 = istart1 + length1; 
+        const BYTE* const istart3 = istart2 + length2; 
+        const BYTE* const istart4 = istart3 + length3; 
+        size_t const segmentSize = (dstSize+3) / 4; 
+        BYTE* const opStart2 = ostart + segmentSize; 
+        BYTE* const opStart3 = opStart2 + segmentSize; 
+        BYTE* const opStart4 = opStart3 + segmentSize; 
+        BYTE* op1 = ostart; 
+        BYTE* op2 = opStart2; 
+        BYTE* op3 = opStart3; 
+        BYTE* op4 = opStart4; 
+        U32 endSignal; 
+        DTableDesc const dtd = HUFv07_getDTableDesc(DTable); 
+        U32 const dtLog = dtd.tableLog; 
+ 
+        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */ 
+        { size_t const errorCode = BITv07_initDStream(&bitD1, istart1, length1); 
+          if (HUFv07_isError(errorCode)) return errorCode; } 
+        { size_t const errorCode = BITv07_initDStream(&bitD2, istart2, length2); 
+          if (HUFv07_isError(errorCode)) return errorCode; } 
+        { size_t const errorCode = BITv07_initDStream(&bitD3, istart3, length3); 
+          if (HUFv07_isError(errorCode)) return errorCode; } 
+        { size_t const errorCode = BITv07_initDStream(&bitD4, istart4, length4); 
+          if (HUFv07_isError(errorCode)) return errorCode; } 
+ 
+        /* 16-32 symbols per loop (4-8 symbols per stream) */ 
+        endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_reloadDStream(&bitD4); 
+        for ( ; (endSignal==BITv07_DStream_unfinished) && (op4<(oend-7)) ; ) { 
+            HUFv07_DECODE_SYMBOLX4_2(op1, &bitD1); 
+            HUFv07_DECODE_SYMBOLX4_2(op2, &bitD2); 
+            HUFv07_DECODE_SYMBOLX4_2(op3, &bitD3); 
+            HUFv07_DECODE_SYMBOLX4_2(op4, &bitD4); 
+            HUFv07_DECODE_SYMBOLX4_1(op1, &bitD1); 
+            HUFv07_DECODE_SYMBOLX4_1(op2, &bitD2); 
+            HUFv07_DECODE_SYMBOLX4_1(op3, &bitD3); 
+            HUFv07_DECODE_SYMBOLX4_1(op4, &bitD4); 
+            HUFv07_DECODE_SYMBOLX4_2(op1, &bitD1); 
+            HUFv07_DECODE_SYMBOLX4_2(op2, &bitD2); 
+            HUFv07_DECODE_SYMBOLX4_2(op3, &bitD3); 
+            HUFv07_DECODE_SYMBOLX4_2(op4, &bitD4); 
+            HUFv07_DECODE_SYMBOLX4_0(op1, &bitD1); 
+            HUFv07_DECODE_SYMBOLX4_0(op2, &bitD2); 
+            HUFv07_DECODE_SYMBOLX4_0(op3, &bitD3); 
+            HUFv07_DECODE_SYMBOLX4_0(op4, &bitD4); 
+ 
+            endSignal = BITv07_reloadDStream(&bitD1) | BITv07_reloadDStream(&bitD2) | BITv07_reloadDStream(&bitD3) | BITv07_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 */ 
+        HUFv07_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog); 
+        HUFv07_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog); 
+        HUFv07_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog); 
+        HUFv07_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog); 
+ 
+        /* check */ 
+        { U32 const endCheck = BITv07_endOfDStream(&bitD1) & BITv07_endOfDStream(&bitD2) & BITv07_endOfDStream(&bitD3) & BITv07_endOfDStream(&bitD4); 
+          if (!endCheck) return ERROR(corruption_detected); } 
+ 
+        /* decoded size */ 
+        return dstSize; 
+    } 
+} 
+ 
+ 
+size_t HUFv07_decompress4X4_usingDTable( 
+          void* dst,  size_t dstSize, 
+    const void* cSrc, size_t cSrcSize, 
+    const HUFv07_DTable* DTable) 
+{ 
+    DTableDesc dtd = HUFv07_getDTableDesc(DTable); 
+    if (dtd.tableType != 1) return ERROR(GENERIC); 
+    return HUFv07_decompress4X4_usingDTable_internal(dst, dstSize, cSrc, cSrcSize, DTable); 
+} 
+ 
+ 
+size_t HUFv07_decompress4X4_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    const BYTE* ip = (const BYTE*) cSrc; 
+ 
+    size_t hSize = HUFv07_readDTableX4 (dctx, cSrc, cSrcSize); 
+    if (HUFv07_isError(hSize)) return hSize; 
+    if (hSize >= cSrcSize) return ERROR(srcSize_wrong); 
+    ip += hSize; cSrcSize -= hSize; 
+ 
+    return HUFv07_decompress4X4_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx); 
+} 
+ 
+size_t HUFv07_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    HUFv07_CREATE_STATIC_DTABLEX4(DTable, HUFv07_TABLELOG_MAX); 
+    return HUFv07_decompress4X4_DCtx(DTable, dst, dstSize, cSrc, cSrcSize); 
+} 
+ 
+ 
+/* ********************************/ 
+/* Generic decompression selector */ 
+/* ********************************/ 
+ 
+size_t HUFv07_decompress1X_usingDTable(void* dst, size_t maxDstSize, 
+                                    const void* cSrc, size_t cSrcSize, 
+                                    const HUFv07_DTable* DTable) 
+{ 
+    DTableDesc const dtd = HUFv07_getDTableDesc(DTable); 
+    return dtd.tableType ? HUFv07_decompress1X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable) : 
+                           HUFv07_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable); 
+} 
+ 
+size_t HUFv07_decompress4X_usingDTable(void* dst, size_t maxDstSize, 
+                                    const void* cSrc, size_t cSrcSize, 
+                                    const HUFv07_DTable* DTable) 
+{ 
+    DTableDesc const dtd = HUFv07_getDTableDesc(DTable); 
+    return dtd.tableType ? HUFv07_decompress4X4_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable) : 
+                           HUFv07_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable); 
+} 
+ 
+ 
+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% */ 
+}; 
+ 
+/** HUFv07_selectDecoder() : 
+*   Tells which decoder is likely to decode faster, 
+*   based on a set of pre-determined metrics. 
+*   @return : 0==HUFv07_decompress4X2, 1==HUFv07_decompress4X4 . 
+*   Assumption : 0 < cSrcSize < dstSize <= 128 KB */ 
+U32 HUFv07_selectDecoder (size_t dstSize, size_t cSrcSize) 
+{ 
+    /* decoder timing evaluation */ 
+    U32 const Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */ 
+    U32 const D256 = (U32)(dstSize >> 8); 
+    U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256); 
+    U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256); 
+    DTime1 += DTime1 >> 3;  /* advantage to algorithm using less memory, for cache eviction */ 
+ 
+    return DTime1 < DTime0; 
+} 
+ 
+ 
+typedef size_t (*decompressionAlgo)(void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize); 
+ 
+size_t HUFv07_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    static const decompressionAlgo decompress[2] = { HUFv07_decompress4X2, HUFv07_decompress4X4 }; 
+ 
+    /* 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 */ 
+ 
+    {   U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize); 
+        return decompress[algoNb](dst, dstSize, cSrc, cSrcSize); 
+    } 
+ 
     /* return HUFv07_decompress4X2(dst, dstSize, cSrc, cSrcSize); */   /* multi-streams single-symbol decoding */
     /* return HUFv07_decompress4X4(dst, dstSize, cSrc, cSrcSize); */   /* multi-streams double-symbols decoding */
-}
-
-size_t HUFv07_decompress4X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    /* 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 */
-
-    {   U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize);
-        return algoNb ? HUFv07_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
-                        HUFv07_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
-    }
-}
-
-size_t HUFv07_decompress4X_hufOnly (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    /* validation checks */
-    if (dstSize == 0) return ERROR(dstSize_tooSmall);
-    if ((cSrcSize >= dstSize) || (cSrcSize <= 1)) return ERROR(corruption_detected);   /* invalid */
-
-    {   U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize);
-        return algoNb ? HUFv07_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
-                        HUFv07_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
-    }
-}
-
-size_t HUFv07_decompress1X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
-{
-    /* 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 */
-
-    {   U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize);
-        return algoNb ? HUFv07_decompress1X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
-                        HUFv07_decompress1X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
-    }
-}
-/*
-    Common functions of Zstd compression library
-    Copyright (C) 2015-2016, Yann Collet.
-
-    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are
-    met:
-    * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-    copyright notice, this list of conditions and the following disclaimer
-    in the documentation and/or other materials provided with the
-    distribution.
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    You can contact the author at :
-    - zstd homepage : http://www.zstd.net/
-*/
-
-
-
-/*-****************************************
-*  ZSTD Error Management
-******************************************/
-/*! ZSTDv07_isError() :
-*   tells if a return value is an error code */
-unsigned ZSTDv07_isError(size_t code) { return ERR_isError(code); }
-
-/*! ZSTDv07_getErrorName() :
-*   provides error code string from function result (useful for debugging) */
-const char* ZSTDv07_getErrorName(size_t code) { return ERR_getErrorName(code); }
-
-
-
-/* **************************************************************
-*  ZBUFF Error Management
-****************************************************************/
-unsigned ZBUFFv07_isError(size_t errorCode) { return ERR_isError(errorCode); }
-
-const char* ZBUFFv07_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
-
-
-
+} 
+ 
+size_t HUFv07_decompress4X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    /* 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 */ 
+ 
+    {   U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize); 
+        return algoNb ? HUFv07_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) : 
+                        HUFv07_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ; 
+    } 
+} 
+ 
+size_t HUFv07_decompress4X_hufOnly (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    /* validation checks */ 
+    if (dstSize == 0) return ERROR(dstSize_tooSmall); 
+    if ((cSrcSize >= dstSize) || (cSrcSize <= 1)) return ERROR(corruption_detected);   /* invalid */ 
+ 
+    {   U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize); 
+        return algoNb ? HUFv07_decompress4X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) : 
+                        HUFv07_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ; 
+    } 
+} 
+ 
+size_t HUFv07_decompress1X_DCtx (HUFv07_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize) 
+{ 
+    /* 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 */ 
+ 
+    {   U32 const algoNb = HUFv07_selectDecoder(dstSize, cSrcSize); 
+        return algoNb ? HUFv07_decompress1X4_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) : 
+                        HUFv07_decompress1X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ; 
+    } 
+} 
+/* 
+    Common functions of Zstd compression library 
+    Copyright (C) 2015-2016, Yann Collet. 
+ 
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+    Redistribution and use in source and binary forms, with or without 
+    modification, are permitted provided that the following conditions are 
+    met: 
+    * Redistributions of source code must retain the above copyright 
+    notice, this list of conditions and the following disclaimer. 
+    * Redistributions in binary form must reproduce the above 
+    copyright notice, this list of conditions and the following disclaimer 
+    in the documentation and/or other materials provided with the 
+    distribution. 
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+    You can contact the author at : 
+    - zstd homepage : http://www.zstd.net/ 
+*/ 
+ 
+ 
+ 
+/*-**************************************** 
+*  ZSTD Error Management 
+******************************************/ 
+/*! ZSTDv07_isError() : 
+*   tells if a return value is an error code */ 
+unsigned ZSTDv07_isError(size_t code) { return ERR_isError(code); } 
+ 
+/*! ZSTDv07_getErrorName() : 
+*   provides error code string from function result (useful for debugging) */ 
+const char* ZSTDv07_getErrorName(size_t code) { return ERR_getErrorName(code); } 
+ 
+ 
+ 
+/* ************************************************************** 
+*  ZBUFF Error Management 
+****************************************************************/ 
+unsigned ZBUFFv07_isError(size_t errorCode) { return ERR_isError(errorCode); } 
+ 
+const char* ZBUFFv07_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); } 
+ 
+ 
+ 
 static void* ZSTDv07_defaultAllocFunction(void* opaque, size_t size)
-{
-    void* address = malloc(size);
-    (void)opaque;
-    /* printf("alloc %p, %d opaque=%p \n", address, (int)size, opaque); */
-    return address;
-}
-
+{ 
+    void* address = malloc(size); 
+    (void)opaque; 
+    /* printf("alloc %p, %d opaque=%p \n", address, (int)size, opaque); */ 
+    return address; 
+} 
+ 
 static void ZSTDv07_defaultFreeFunction(void* opaque, void* address)
-{
-    (void)opaque;
-    /* if (address) printf("free %p opaque=%p \n", address, opaque); */
-    free(address);
-}
-/*
-    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 ZSTDv07_CCOMMON_H_MODULE
-#define ZSTDv07_CCOMMON_H_MODULE
-
-
-/*-*************************************
-*  Common macros
-***************************************/
-#define MIN(a,b) ((a)<(b) ? (a) : (b))
-#define MAX(a,b) ((a)>(b) ? (a) : (b))
-
-
-/*-*************************************
-*  Common constants
-***************************************/
-#define ZSTDv07_OPT_NUM    (1<<12)
-#define ZSTDv07_DICT_MAGIC  0xEC30A437   /* v0.7 */
-
-#define ZSTDv07_REP_NUM    3
-#define ZSTDv07_REP_INIT   ZSTDv07_REP_NUM
-#define ZSTDv07_REP_MOVE   (ZSTDv07_REP_NUM-1)
-static const U32 repStartValue[ZSTDv07_REP_NUM] = { 1, 4, 8 };
-
-#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 ZSTDv07_WINDOWLOG_ABSOLUTEMIN 10
-static const size_t ZSTDv07_fcs_fieldSize[4] = { 0, 2, 4, 8 };
-static const size_t ZSTDv07_did_fieldSize[4] = { 0, 1, 2, 4 };
-
-#define ZSTDv07_BLOCKHEADERSIZE 3   /* C standard doesn't allow `static const` variable to be init using another `static const` variable */
-static const size_t ZSTDv07_blockHeaderSize = ZSTDv07_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
-typedef enum { lbt_huffman, lbt_repeat, lbt_raw, lbt_rle } litBlockType_t;
-
-#define LONGNBSEQ 0x7F00
-
-#define MINMATCH 3
-#define EQUAL_READ32 4
-
-#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 FSEv07_ENCODING_RAW     0
-#define FSEv07_ENCODING_RLE     1
-#define FSEv07_ENCODING_STATIC  2
-#define FSEv07_ENCODING_DYNAMIC 3
-
+{ 
+    (void)opaque; 
+    /* if (address) printf("free %p opaque=%p \n", address, opaque); */ 
+    free(address); 
+} 
+/* 
+    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 ZSTDv07_CCOMMON_H_MODULE 
+#define ZSTDv07_CCOMMON_H_MODULE 
+ 
+ 
+/*-************************************* 
+*  Common macros 
+***************************************/ 
+#define MIN(a,b) ((a)<(b) ? (a) : (b)) 
+#define MAX(a,b) ((a)>(b) ? (a) : (b)) 
+ 
+ 
+/*-************************************* 
+*  Common constants 
+***************************************/ 
+#define ZSTDv07_OPT_NUM    (1<<12) 
+#define ZSTDv07_DICT_MAGIC  0xEC30A437   /* v0.7 */ 
+ 
+#define ZSTDv07_REP_NUM    3 
+#define ZSTDv07_REP_INIT   ZSTDv07_REP_NUM 
+#define ZSTDv07_REP_MOVE   (ZSTDv07_REP_NUM-1) 
+static const U32 repStartValue[ZSTDv07_REP_NUM] = { 1, 4, 8 }; 
+ 
+#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 ZSTDv07_WINDOWLOG_ABSOLUTEMIN 10 
+static const size_t ZSTDv07_fcs_fieldSize[4] = { 0, 2, 4, 8 }; 
+static const size_t ZSTDv07_did_fieldSize[4] = { 0, 1, 2, 4 }; 
+ 
+#define ZSTDv07_BLOCKHEADERSIZE 3   /* C standard doesn't allow `static const` variable to be init using another `static const` variable */ 
+static const size_t ZSTDv07_blockHeaderSize = ZSTDv07_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 
+typedef enum { lbt_huffman, lbt_repeat, lbt_raw, lbt_rle } litBlockType_t; 
+ 
+#define LONGNBSEQ 0x7F00 
+ 
+#define MINMATCH 3 
+#define EQUAL_READ32 4 
+ 
+#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 FSEv07_ENCODING_RAW     0 
+#define FSEv07_ENCODING_RLE     1 
+#define FSEv07_ENCODING_STATIC  2 
+#define FSEv07_ENCODING_DYNAMIC 3 
+ 
 #define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)
 
-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 ZSTDv07_copy8(void* dst, const void* src) { memcpy(dst, src, 8); }
-#define COPY8(d,s) { ZSTDv07_copy8(d,s); d+=8; s+=8; }
-
-/*! ZSTDv07_wildcopy() :
-*   custom version of memcpy(), can copy up to 7 bytes too many (8 bytes if length==0) */
-#define WILDCOPY_OVERLENGTH 8
+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 ZSTDv07_copy8(void* dst, const void* src) { memcpy(dst, src, 8); } 
+#define COPY8(d,s) { ZSTDv07_copy8(d,s); d+=8; s+=8; } 
+ 
+/*! ZSTDv07_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 ZSTDv07_wildcopy(void* dst, const void* src, ptrdiff_t length)
-{
-    const BYTE* ip = (const BYTE*)src;
-    BYTE* op = (BYTE*)dst;
-    BYTE* const oend = op + length;
-    do
-        COPY8(op, ip)
-    while (op < oend);
-}
-
-
-/*-*******************************************
-*  Private interfaces
-*********************************************/
-typedef struct ZSTDv07_stats_s ZSTDv07_stats_t;
-
-typedef struct {
-    U32 off;
-    U32 len;
-} ZSTDv07_match_t;
-
-typedef struct {
-    U32 price;
-    U32 off;
-    U32 mlen;
-    U32 litlen;
-    U32 rep[ZSTDv07_REP_INIT];
-} ZSTDv07_optimal_t;
-
-struct ZSTDv07_stats_s { U32 unused; };
-
-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 */
-    ZSTDv07_optimal_t* priceTable;
-    ZSTDv07_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;
-    ZSTDv07_stats_t stats;
-} seqStore_t;
-
-void ZSTDv07_seqToCodes(const seqStore_t* seqStorePtr, size_t const nbSeq);
-
-/* custom memory allocation functions */
-static const ZSTDv07_customMem defaultCustomMem = { ZSTDv07_defaultAllocFunction, ZSTDv07_defaultFreeFunction, NULL };
-
-#endif   /* ZSTDv07_CCOMMON_H_MODULE */
-/*
-    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 ZSTDv07_decompress() will allocate memory,
- * in memory stack (0), or in memory heap (1, requires malloc())
- */
-#ifndef ZSTDv07_HEAPMODE
-#  define ZSTDv07_HEAPMODE 1
-#endif
-
-
-/*-*******************************************************
-*  Compiler specifics
-*********************************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  include <intrin.h>                    /* For Visual 2005 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    BYTE* op = (BYTE*)dst; 
+    BYTE* const oend = op + length; 
+    do 
+        COPY8(op, ip) 
+    while (op < oend); 
+} 
+ 
+ 
+/*-******************************************* 
+*  Private interfaces 
+*********************************************/ 
+typedef struct ZSTDv07_stats_s ZSTDv07_stats_t; 
+ 
+typedef struct { 
+    U32 off; 
+    U32 len; 
+} ZSTDv07_match_t; 
+ 
+typedef struct { 
+    U32 price; 
+    U32 off; 
+    U32 mlen; 
+    U32 litlen; 
+    U32 rep[ZSTDv07_REP_INIT]; 
+} ZSTDv07_optimal_t; 
+ 
+struct ZSTDv07_stats_s { U32 unused; }; 
+ 
+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 */ 
+    ZSTDv07_optimal_t* priceTable; 
+    ZSTDv07_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; 
+    ZSTDv07_stats_t stats; 
+} seqStore_t; 
+ 
+void ZSTDv07_seqToCodes(const seqStore_t* seqStorePtr, size_t const nbSeq); 
+ 
+/* custom memory allocation functions */ 
+static const ZSTDv07_customMem defaultCustomMem = { ZSTDv07_defaultAllocFunction, ZSTDv07_defaultFreeFunction, NULL }; 
+ 
+#endif   /* ZSTDv07_CCOMMON_H_MODULE */ 
+/* 
+    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 ZSTDv07_decompress() will allocate memory, 
+ * in memory stack (0), or in memory heap (1, requires malloc()) 
+ */ 
+#ifndef ZSTDv07_HEAPMODE 
+#  define ZSTDv07_HEAPMODE 1 
+#endif 
+ 
+ 
+/*-******************************************************* 
+*  Compiler specifics 
+*********************************************************/ 
+#ifdef _MSC_VER    /* Visual Studio */ 
+#  include <intrin.h>                    /* For Visual 2005 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */ 
 #  pragma warning(disable : 4100)        /* disable: C4100: unreferenced formal parameter */
-#endif
-
-
-/*-*************************************
-*  Macros
-***************************************/
-#define ZSTDv07_isError ERR_isError   /* for inlining */
-#define FSEv07_isError  ERR_isError
-#define HUFv07_isError  ERR_isError
-
-
-/*_*******************************************************
-*  Memory operations
-**********************************************************/
-static void ZSTDv07_copy4(void* dst, const void* src) { memcpy(dst, src, 4); }
-
-
-/*-*************************************************************
-*   Context management
-***************************************************************/
-typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,
-               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock,
-               ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTDv07_dStage;
-
-struct ZSTDv07_DCtx_s
-{
-    FSEv07_DTable LLTable[FSEv07_DTABLE_SIZE_U32(LLFSELog)];
-    FSEv07_DTable OffTable[FSEv07_DTABLE_SIZE_U32(OffFSELog)];
-    FSEv07_DTable MLTable[FSEv07_DTABLE_SIZE_U32(MLFSELog)];
-    HUFv07_DTable hufTable[HUFv07_DTABLE_SIZE(HufLog)];  /* can accommodate HUFv07_decompress4X */
-    const void* previousDstEnd;
-    const void* base;
-    const void* vBase;
-    const void* dictEnd;
-    size_t expected;
-    U32 rep[3];
-    ZSTDv07_frameParams fParams;
-    blockType_t bType;   /* used in ZSTDv07_decompressContinue(), to transfer blockType between header decoding and block decoding stages */
-    ZSTDv07_dStage stage;
-    U32 litEntropy;
-    U32 fseEntropy;
-    XXH64_state_t xxhState;
-    size_t headerSize;
-    U32 dictID;
-    const BYTE* litPtr;
-    ZSTDv07_customMem customMem;
-    size_t litSize;
-    BYTE litBuffer[ZSTDv07_BLOCKSIZE_ABSOLUTEMAX + WILDCOPY_OVERLENGTH];
-    BYTE headerBuffer[ZSTDv07_FRAMEHEADERSIZE_MAX];
-};  /* typedef'd to ZSTDv07_DCtx within "zstd_static.h" */
-
-int ZSTDv07_isSkipFrame(ZSTDv07_DCtx* dctx);
-
-size_t ZSTDv07_sizeofDCtx (const ZSTDv07_DCtx* dctx) { return sizeof(*dctx); }
-
-size_t ZSTDv07_estimateDCtxSize(void) { return sizeof(ZSTDv07_DCtx); }
-
-size_t ZSTDv07_decompressBegin(ZSTDv07_DCtx* dctx)
-{
-    dctx->expected = ZSTDv07_frameHeaderSize_min;
-    dctx->stage = ZSTDds_getFrameHeaderSize;
-    dctx->previousDstEnd = NULL;
-    dctx->base = NULL;
-    dctx->vBase = NULL;
-    dctx->dictEnd = NULL;
-    dctx->hufTable[0] = (HUFv07_DTable)((HufLog)*0x1000001);
-    dctx->litEntropy = dctx->fseEntropy = 0;
-    dctx->dictID = 0;
-    { int i; for (i=0; i<ZSTDv07_REP_NUM; i++) dctx->rep[i] = repStartValue[i]; }
-    return 0;
-}
-
-ZSTDv07_DCtx* ZSTDv07_createDCtx_advanced(ZSTDv07_customMem customMem)
-{
-    ZSTDv07_DCtx* dctx;
-
-    if (!customMem.customAlloc && !customMem.customFree)
-        customMem = defaultCustomMem;
-
-    if (!customMem.customAlloc || !customMem.customFree)
-        return NULL;
-
-    dctx = (ZSTDv07_DCtx*) customMem.customAlloc(customMem.opaque, sizeof(ZSTDv07_DCtx));
-    if (!dctx) return NULL;
-    memcpy(&dctx->customMem, &customMem, sizeof(ZSTDv07_customMem));
-    ZSTDv07_decompressBegin(dctx);
-    return dctx;
-}
-
-ZSTDv07_DCtx* ZSTDv07_createDCtx(void)
-{
-    return ZSTDv07_createDCtx_advanced(defaultCustomMem);
-}
-
-size_t ZSTDv07_freeDCtx(ZSTDv07_DCtx* dctx)
-{
-    if (dctx==NULL) return 0;   /* support free on NULL */
-    dctx->customMem.customFree(dctx->customMem.opaque, dctx);
-    return 0;   /* reserved as a potential error code in the future */
-}
-
-void ZSTDv07_copyDCtx(ZSTDv07_DCtx* dstDCtx, const ZSTDv07_DCtx* srcDCtx)
-{
-    memcpy(dstDCtx, srcDCtx,
-           sizeof(ZSTDv07_DCtx) - (ZSTDv07_BLOCKSIZE_ABSOLUTEMAX+WILDCOPY_OVERLENGTH + ZSTDv07_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 : ZSTDv07_MAGICNUMBER (defined within zstd.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 Header :
-
-   1 byte - FrameHeaderDescription :
-   bit 0-1 : dictID (0, 1, 2 or 4 bytes)
-   bit 2   : checksumFlag
-   bit 3   : reserved (must be zero)
-   bit 4   : reserved (unused, can be any value)
-   bit 5   : Single Segment (if 1, WindowLog byte is not present)
-   bit 6-7 : FrameContentFieldSize (0, 2, 4, or 8)
-             if (SkippedWindowLog && !FrameContentFieldsize) FrameContentFieldsize=1;
-
-   Optional : WindowLog (0 or 1 byte)
-   bit 0-2 : octal Fractional (1/8th)
-   bit 3-7 : Power of 2, with 0 = 1 KB (up to 2 TB)
-
-   Optional : dictID (0, 1, 2 or 4 bytes)
-   Automatic adaptation
-   0 : no dictID
-   1 : 1 - 255
-   2 : 256 - 65535
-   4 : all other values
-
-   Optional : content size (0, 1, 2, 4 or 8 bytes)
-   0 : unknown          (fcfs==0 and swl==0)
-   1 : 0-255 bytes      (fcfs==0 and swl==1)
-   2 : 256 - 65535+256  (fcfs==1)
-   4 : 0 - 4GB-1        (fcfs==2)
-   8 : 0 - 16EB-1       (fcfs==3)
-*/
-
-
-/* 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
-*/
-
-/** ZSTDv07_frameHeaderSize() :
-*   srcSize must be >= ZSTDv07_frameHeaderSize_min.
-*   @return : size of the Frame Header */
-static size_t ZSTDv07_frameHeaderSize(const void* src, size_t srcSize)
-{
-    if (srcSize < ZSTDv07_frameHeaderSize_min) return ERROR(srcSize_wrong);
-    {   BYTE const fhd = ((const BYTE*)src)[4];
-        U32 const dictID= fhd & 3;
-        U32 const directMode = (fhd >> 5) & 1;
-        U32 const fcsId = fhd >> 6;
-        return ZSTDv07_frameHeaderSize_min + !directMode + ZSTDv07_did_fieldSize[dictID] + ZSTDv07_fcs_fieldSize[fcsId]
-                + (directMode && !ZSTDv07_fcs_fieldSize[fcsId]);
-    }
-}
-
-
-/** ZSTDv07_getFrameParams() :
-*   decode Frame Header, or require larger `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 ZSTDv07_isError() */
-size_t ZSTDv07_getFrameParams(ZSTDv07_frameParams* fparamsPtr, const void* src, size_t srcSize)
-{
-    const BYTE* ip = (const BYTE*)src;
-
-    if (srcSize < ZSTDv07_frameHeaderSize_min) return ZSTDv07_frameHeaderSize_min;
+#endif 
+ 
+ 
+/*-************************************* 
+*  Macros 
+***************************************/ 
+#define ZSTDv07_isError ERR_isError   /* for inlining */ 
+#define FSEv07_isError  ERR_isError 
+#define HUFv07_isError  ERR_isError 
+ 
+ 
+/*_******************************************************* 
+*  Memory operations 
+**********************************************************/ 
+static void ZSTDv07_copy4(void* dst, const void* src) { memcpy(dst, src, 4); } 
+ 
+ 
+/*-************************************************************* 
+*   Context management 
+***************************************************************/ 
+typedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader, 
+               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock, 
+               ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTDv07_dStage; 
+ 
+struct ZSTDv07_DCtx_s 
+{ 
+    FSEv07_DTable LLTable[FSEv07_DTABLE_SIZE_U32(LLFSELog)]; 
+    FSEv07_DTable OffTable[FSEv07_DTABLE_SIZE_U32(OffFSELog)]; 
+    FSEv07_DTable MLTable[FSEv07_DTABLE_SIZE_U32(MLFSELog)]; 
+    HUFv07_DTable hufTable[HUFv07_DTABLE_SIZE(HufLog)];  /* can accommodate HUFv07_decompress4X */ 
+    const void* previousDstEnd; 
+    const void* base; 
+    const void* vBase; 
+    const void* dictEnd; 
+    size_t expected; 
+    U32 rep[3]; 
+    ZSTDv07_frameParams fParams; 
+    blockType_t bType;   /* used in ZSTDv07_decompressContinue(), to transfer blockType between header decoding and block decoding stages */ 
+    ZSTDv07_dStage stage; 
+    U32 litEntropy; 
+    U32 fseEntropy; 
+    XXH64_state_t xxhState; 
+    size_t headerSize; 
+    U32 dictID; 
+    const BYTE* litPtr; 
+    ZSTDv07_customMem customMem; 
+    size_t litSize; 
+    BYTE litBuffer[ZSTDv07_BLOCKSIZE_ABSOLUTEMAX + WILDCOPY_OVERLENGTH]; 
+    BYTE headerBuffer[ZSTDv07_FRAMEHEADERSIZE_MAX]; 
+};  /* typedef'd to ZSTDv07_DCtx within "zstd_static.h" */ 
+ 
+int ZSTDv07_isSkipFrame(ZSTDv07_DCtx* dctx); 
+ 
+size_t ZSTDv07_sizeofDCtx (const ZSTDv07_DCtx* dctx) { return sizeof(*dctx); } 
+ 
+size_t ZSTDv07_estimateDCtxSize(void) { return sizeof(ZSTDv07_DCtx); } 
+ 
+size_t ZSTDv07_decompressBegin(ZSTDv07_DCtx* dctx) 
+{ 
+    dctx->expected = ZSTDv07_frameHeaderSize_min; 
+    dctx->stage = ZSTDds_getFrameHeaderSize; 
+    dctx->previousDstEnd = NULL; 
+    dctx->base = NULL; 
+    dctx->vBase = NULL; 
+    dctx->dictEnd = NULL; 
+    dctx->hufTable[0] = (HUFv07_DTable)((HufLog)*0x1000001); 
+    dctx->litEntropy = dctx->fseEntropy = 0; 
+    dctx->dictID = 0; 
+    { int i; for (i=0; i<ZSTDv07_REP_NUM; i++) dctx->rep[i] = repStartValue[i]; } 
+    return 0; 
+} 
+ 
+ZSTDv07_DCtx* ZSTDv07_createDCtx_advanced(ZSTDv07_customMem customMem) 
+{ 
+    ZSTDv07_DCtx* dctx; 
+ 
+    if (!customMem.customAlloc && !customMem.customFree) 
+        customMem = defaultCustomMem; 
+ 
+    if (!customMem.customAlloc || !customMem.customFree) 
+        return NULL; 
+ 
+    dctx = (ZSTDv07_DCtx*) customMem.customAlloc(customMem.opaque, sizeof(ZSTDv07_DCtx)); 
+    if (!dctx) return NULL; 
+    memcpy(&dctx->customMem, &customMem, sizeof(ZSTDv07_customMem)); 
+    ZSTDv07_decompressBegin(dctx); 
+    return dctx; 
+} 
+ 
+ZSTDv07_DCtx* ZSTDv07_createDCtx(void) 
+{ 
+    return ZSTDv07_createDCtx_advanced(defaultCustomMem); 
+} 
+ 
+size_t ZSTDv07_freeDCtx(ZSTDv07_DCtx* dctx) 
+{ 
+    if (dctx==NULL) return 0;   /* support free on NULL */ 
+    dctx->customMem.customFree(dctx->customMem.opaque, dctx); 
+    return 0;   /* reserved as a potential error code in the future */ 
+} 
+ 
+void ZSTDv07_copyDCtx(ZSTDv07_DCtx* dstDCtx, const ZSTDv07_DCtx* srcDCtx) 
+{ 
+    memcpy(dstDCtx, srcDCtx, 
+           sizeof(ZSTDv07_DCtx) - (ZSTDv07_BLOCKSIZE_ABSOLUTEMAX+WILDCOPY_OVERLENGTH + ZSTDv07_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 : ZSTDv07_MAGICNUMBER (defined within zstd.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 Header : 
+ 
+   1 byte - FrameHeaderDescription : 
+   bit 0-1 : dictID (0, 1, 2 or 4 bytes) 
+   bit 2   : checksumFlag 
+   bit 3   : reserved (must be zero) 
+   bit 4   : reserved (unused, can be any value) 
+   bit 5   : Single Segment (if 1, WindowLog byte is not present) 
+   bit 6-7 : FrameContentFieldSize (0, 2, 4, or 8) 
+             if (SkippedWindowLog && !FrameContentFieldsize) FrameContentFieldsize=1; 
+ 
+   Optional : WindowLog (0 or 1 byte) 
+   bit 0-2 : octal Fractional (1/8th) 
+   bit 3-7 : Power of 2, with 0 = 1 KB (up to 2 TB) 
+ 
+   Optional : dictID (0, 1, 2 or 4 bytes) 
+   Automatic adaptation 
+   0 : no dictID 
+   1 : 1 - 255 
+   2 : 256 - 65535 
+   4 : all other values 
+ 
+   Optional : content size (0, 1, 2, 4 or 8 bytes) 
+   0 : unknown          (fcfs==0 and swl==0) 
+   1 : 0-255 bytes      (fcfs==0 and swl==1) 
+   2 : 256 - 65535+256  (fcfs==1) 
+   4 : 0 - 4GB-1        (fcfs==2) 
+   8 : 0 - 16EB-1       (fcfs==3) 
+*/ 
+ 
+ 
+/* 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 
+*/ 
+ 
+/** ZSTDv07_frameHeaderSize() : 
+*   srcSize must be >= ZSTDv07_frameHeaderSize_min. 
+*   @return : size of the Frame Header */ 
+static size_t ZSTDv07_frameHeaderSize(const void* src, size_t srcSize) 
+{ 
+    if (srcSize < ZSTDv07_frameHeaderSize_min) return ERROR(srcSize_wrong); 
+    {   BYTE const fhd = ((const BYTE*)src)[4]; 
+        U32 const dictID= fhd & 3; 
+        U32 const directMode = (fhd >> 5) & 1; 
+        U32 const fcsId = fhd >> 6; 
+        return ZSTDv07_frameHeaderSize_min + !directMode + ZSTDv07_did_fieldSize[dictID] + ZSTDv07_fcs_fieldSize[fcsId] 
+                + (directMode && !ZSTDv07_fcs_fieldSize[fcsId]); 
+    } 
+} 
+ 
+ 
+/** ZSTDv07_getFrameParams() : 
+*   decode Frame Header, or require larger `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 ZSTDv07_isError() */ 
+size_t ZSTDv07_getFrameParams(ZSTDv07_frameParams* fparamsPtr, const void* src, size_t srcSize) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+ 
+    if (srcSize < ZSTDv07_frameHeaderSize_min) return ZSTDv07_frameHeaderSize_min; 
     memset(fparamsPtr, 0, sizeof(*fparamsPtr));
-    if (MEM_readLE32(src) != ZSTDv07_MAGICNUMBER) {
-        if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTDv07_MAGIC_SKIPPABLE_START) {
-            if (srcSize < ZSTDv07_skippableHeaderSize) return ZSTDv07_skippableHeaderSize; /* magic number + skippable frame length */
-            fparamsPtr->frameContentSize = MEM_readLE32((const char *)src + 4);
-            fparamsPtr->windowSize = 0; /* windowSize==0 means a frame is skippable */
-            return 0;
-        }
-        return ERROR(prefix_unknown);
-    }
-
-    /* ensure there is enough `srcSize` to fully read/decode frame header */
-    { size_t const fhsize = ZSTDv07_frameHeaderSize(src, srcSize);
-      if (srcSize < fhsize) return fhsize; }
-
-    {   BYTE const fhdByte = ip[4];
-        size_t pos = 5;
-        U32 const dictIDSizeCode = fhdByte&3;
-        U32 const checksumFlag = (fhdByte>>2)&1;
-        U32 const directMode = (fhdByte>>5)&1;
-        U32 const fcsID = fhdByte>>6;
-        U32 const windowSizeMax = 1U << ZSTDv07_WINDOWLOG_MAX;
-        U32 windowSize = 0;
-        U32 dictID = 0;
-        U64 frameContentSize = 0;
+    if (MEM_readLE32(src) != ZSTDv07_MAGICNUMBER) { 
+        if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTDv07_MAGIC_SKIPPABLE_START) { 
+            if (srcSize < ZSTDv07_skippableHeaderSize) return ZSTDv07_skippableHeaderSize; /* magic number + skippable frame length */ 
+            fparamsPtr->frameContentSize = MEM_readLE32((const char *)src + 4); 
+            fparamsPtr->windowSize = 0; /* windowSize==0 means a frame is skippable */ 
+            return 0; 
+        } 
+        return ERROR(prefix_unknown); 
+    } 
+ 
+    /* ensure there is enough `srcSize` to fully read/decode frame header */ 
+    { size_t const fhsize = ZSTDv07_frameHeaderSize(src, srcSize); 
+      if (srcSize < fhsize) return fhsize; } 
+ 
+    {   BYTE const fhdByte = ip[4]; 
+        size_t pos = 5; 
+        U32 const dictIDSizeCode = fhdByte&3; 
+        U32 const checksumFlag = (fhdByte>>2)&1; 
+        U32 const directMode = (fhdByte>>5)&1; 
+        U32 const fcsID = fhdByte>>6; 
+        U32 const windowSizeMax = 1U << ZSTDv07_WINDOWLOG_MAX; 
+        U32 windowSize = 0; 
+        U32 dictID = 0; 
+        U64 frameContentSize = 0; 
         if ((fhdByte & 0x08) != 0)   /* reserved bits, which must be zero */
             return ERROR(frameParameter_unsupported);
-        if (!directMode) {
-            BYTE const wlByte = ip[pos++];
-            U32 const windowLog = (wlByte >> 3) + ZSTDv07_WINDOWLOG_ABSOLUTEMIN;
+        if (!directMode) { 
+            BYTE const wlByte = ip[pos++]; 
+            U32 const windowLog = (wlByte >> 3) + ZSTDv07_WINDOWLOG_ABSOLUTEMIN; 
             if (windowLog > ZSTDv07_WINDOWLOG_MAX)
                 return ERROR(frameParameter_unsupported);
-            windowSize = (1U << windowLog);
-            windowSize += (windowSize >> 3) * (wlByte&7);
-        }
-
-        switch(dictIDSizeCode)
-        {
-            default:   /* impossible */
-            case 0 : break;
-            case 1 : dictID = ip[pos]; pos++; break;
-            case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break;
-            case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break;
-        }
-        switch(fcsID)
-        {
-            default:   /* impossible */
-            case 0 : if (directMode) frameContentSize = ip[pos]; break;
-            case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break;
-            case 2 : frameContentSize = MEM_readLE32(ip+pos); break;
-            case 3 : frameContentSize = MEM_readLE64(ip+pos); break;
-        }
-        if (!windowSize) windowSize = (U32)frameContentSize;
+            windowSize = (1U << windowLog); 
+            windowSize += (windowSize >> 3) * (wlByte&7); 
+        } 
+ 
+        switch(dictIDSizeCode) 
+        { 
+            default:   /* impossible */ 
+            case 0 : break; 
+            case 1 : dictID = ip[pos]; pos++; break; 
+            case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break; 
+            case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break; 
+        } 
+        switch(fcsID) 
+        { 
+            default:   /* impossible */ 
+            case 0 : if (directMode) frameContentSize = ip[pos]; break; 
+            case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break; 
+            case 2 : frameContentSize = MEM_readLE32(ip+pos); break; 
+            case 3 : frameContentSize = MEM_readLE64(ip+pos); break; 
+        } 
+        if (!windowSize) windowSize = (U32)frameContentSize; 
         if (windowSize > windowSizeMax)
             return ERROR(frameParameter_unsupported);
-        fparamsPtr->frameContentSize = frameContentSize;
-        fparamsPtr->windowSize = windowSize;
-        fparamsPtr->dictID = dictID;
-        fparamsPtr->checksumFlag = checksumFlag;
-    }
-    return 0;
-}
-
-
-/** ZSTDv07_getDecompressedSize() :
-*   compatible with legacy mode
-*   @return : decompressed size if known, 0 otherwise
-              note : 0 can mean any of the following :
-                   - decompressed size is not provided within frame header
-                   - frame header unknown / not supported
-                   - frame header not completely provided (`srcSize` too small) */
-unsigned long long ZSTDv07_getDecompressedSize(const void* src, size_t srcSize)
-{
+        fparamsPtr->frameContentSize = frameContentSize; 
+        fparamsPtr->windowSize = windowSize; 
+        fparamsPtr->dictID = dictID; 
+        fparamsPtr->checksumFlag = checksumFlag; 
+    } 
+    return 0; 
+} 
+ 
+ 
+/** ZSTDv07_getDecompressedSize() : 
+*   compatible with legacy mode 
+*   @return : decompressed size if known, 0 otherwise 
+              note : 0 can mean any of the following : 
+                   - decompressed size is not provided within frame header 
+                   - frame header unknown / not supported 
+                   - frame header not completely provided (`srcSize` too small) */ 
+unsigned long long ZSTDv07_getDecompressedSize(const void* src, size_t srcSize) 
+{ 
     ZSTDv07_frameParams fparams;
     size_t const frResult = ZSTDv07_getFrameParams(&fparams, src, srcSize);
     if (frResult!=0) return 0;
     return fparams.frameContentSize;
-}
-
-
-/** ZSTDv07_decodeFrameHeader() :
-*   `srcSize` must be the size provided by ZSTDv07_frameHeaderSize().
-*   @return : 0 if success, or an error code, which can be tested using ZSTDv07_isError() */
-static size_t ZSTDv07_decodeFrameHeader(ZSTDv07_DCtx* dctx, const void* src, size_t srcSize)
-{
-    size_t const result = ZSTDv07_getFrameParams(&(dctx->fParams), src, srcSize);
-    if (dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID)) return ERROR(dictionary_wrong);
-    if (dctx->fParams.checksumFlag) XXH64_reset(&dctx->xxhState, 0);
-    return result;
-}
-
-
-typedef struct
-{
-    blockType_t blockType;
-    U32 origSize;
-} blockProperties_t;
-
-/*! ZSTDv07_getcBlockSize() :
-*   Provides the size of compressed block from block header `src` */
+} 
+ 
+ 
+/** ZSTDv07_decodeFrameHeader() : 
+*   `srcSize` must be the size provided by ZSTDv07_frameHeaderSize(). 
+*   @return : 0 if success, or an error code, which can be tested using ZSTDv07_isError() */ 
+static size_t ZSTDv07_decodeFrameHeader(ZSTDv07_DCtx* dctx, const void* src, size_t srcSize) 
+{ 
+    size_t const result = ZSTDv07_getFrameParams(&(dctx->fParams), src, srcSize); 
+    if (dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID)) return ERROR(dictionary_wrong); 
+    if (dctx->fParams.checksumFlag) XXH64_reset(&dctx->xxhState, 0); 
+    return result; 
+} 
+ 
+ 
+typedef struct 
+{ 
+    blockType_t blockType; 
+    U32 origSize; 
+} blockProperties_t; 
+ 
+/*! ZSTDv07_getcBlockSize() : 
+*   Provides the size of compressed block from block header `src` */ 
 static size_t ZSTDv07_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)
-{
+{ 
     const BYTE* const in = (const BYTE*)src;
-    U32 cSize;
-
-    if (srcSize < ZSTDv07_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 ZSTDv07_copyRawBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall);
+    U32 cSize; 
+ 
+    if (srcSize < ZSTDv07_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 ZSTDv07_copyRawBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    if (srcSize > dstCapacity) return ERROR(dstSize_tooSmall); 
     if (srcSize > 0) {
         memcpy(dst, src, srcSize);
     }
-    return srcSize;
-}
-
-
-/*! ZSTDv07_decodeLiteralsBlock() :
-    @return : nb of bytes read from src (< srcSize ) */
+    return srcSize; 
+} 
+ 
+ 
+/*! ZSTDv07_decodeLiteralsBlock() : 
+    @return : nb of bytes read from src (< srcSize ) */ 
 static size_t ZSTDv07_decodeLiteralsBlock(ZSTDv07_DCtx* dctx,
-                          const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */
-{
-    const BYTE* const istart = (const BYTE*) src;
-
-    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected);
-
-    switch((litBlockType_t)(istart[0]>> 6))
-    {
-    case lbt_huffman:
-        {   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 > ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(corruption_detected);
-            if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
-
-            if (HUFv07_isError(singleStream ?
-                            HUFv07_decompress1X2_DCtx(dctx->hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize) :
-                            HUFv07_decompress4X_hufOnly (dctx->hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize) ))
-                return ERROR(corruption_detected);
-
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litSize = litSize;
-            dctx->litEntropy = 1;
+                          const void* src, size_t srcSize)   /* note : srcSize < BLOCKSIZE */ 
+{ 
+    const BYTE* const istart = (const BYTE*) src; 
+ 
+    if (srcSize < MIN_CBLOCK_SIZE) return ERROR(corruption_detected); 
+ 
+    switch((litBlockType_t)(istart[0]>> 6)) 
+    { 
+    case lbt_huffman: 
+        {   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 > ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(corruption_detected); 
+            if (litCSize + lhSize > srcSize) return ERROR(corruption_detected); 
+ 
+            if (HUFv07_isError(singleStream ? 
+                            HUFv07_decompress1X2_DCtx(dctx->hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize) : 
+                            HUFv07_decompress4X_hufOnly (dctx->hufTable, dctx->litBuffer, litSize, istart+lhSize, litCSize) )) 
+                return ERROR(corruption_detected); 
+ 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litSize = litSize; 
+            dctx->litEntropy = 1; 
             memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
-            return litCSize + lhSize;
-        }
-    case lbt_repeat:
-        {   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->litEntropy==0)
-                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];
-            if (litCSize + lhSize > srcSize) return ERROR(corruption_detected);
-
-            {   size_t const errorCode = HUFv07_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTable);
-                if (HUFv07_isError(errorCode)) return ERROR(corruption_detected);
-            }
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litSize = litSize;
+            return litCSize + lhSize; 
+        } 
+    case lbt_repeat: 
+        {   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->litEntropy==0) 
+                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]; 
+            if (litCSize + lhSize > srcSize) return ERROR(corruption_detected); 
+ 
+            {   size_t const errorCode = HUFv07_decompress1X4_usingDTable(dctx->litBuffer, litSize, istart+lhSize, litCSize, dctx->hufTable); 
+                if (HUFv07_isError(errorCode)) return ERROR(corruption_detected); 
+            } 
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litSize = litSize; 
             memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
-            return litCSize + lhSize;
-        }
-    case lbt_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->litSize = litSize;
+            return litCSize + lhSize; 
+        } 
+    case lbt_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->litSize = litSize; 
                 memset(dctx->litBuffer + dctx->litSize, 0, WILDCOPY_OVERLENGTH);
-                return lhSize+litSize;
-            }
-            /* direct reference into compressed stream */
-            dctx->litPtr = istart+lhSize;
-            dctx->litSize = litSize;
-            return lhSize+litSize;
-        }
-    case lbt_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 > ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(corruption_detected);
+                return lhSize+litSize; 
+            } 
+            /* direct reference into compressed stream */ 
+            dctx->litPtr = istart+lhSize; 
+            dctx->litSize = litSize; 
+            return lhSize+litSize; 
+        } 
+    case lbt_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 > ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(corruption_detected); 
             memset(dctx->litBuffer, istart[lhSize], litSize + WILDCOPY_OVERLENGTH);
-            dctx->litPtr = dctx->litBuffer;
-            dctx->litSize = litSize;
-            return lhSize+1;
-        }
-    default:
-        return ERROR(corruption_detected);   /* impossible */
-    }
-}
-
-
-/*! ZSTDv07_buildSeqTable() :
-    @return : nb bytes read from src,
-              or an error code if it fails, testable with ZSTDv07_isError()
-*/
+            dctx->litPtr = dctx->litBuffer; 
+            dctx->litSize = litSize; 
+            return lhSize+1; 
+        } 
+    default: 
+        return ERROR(corruption_detected);   /* impossible */ 
+    } 
+} 
+ 
+ 
+/*! ZSTDv07_buildSeqTable() : 
+    @return : nb bytes read from src, 
+              or an error code if it fails, testable with ZSTDv07_isError() 
+*/ 
 static size_t ZSTDv07_buildSeqTable(FSEv07_DTable* DTable, U32 type, U32 max, U32 maxLog,
-                                 const void* src, size_t srcSize,
-                                 const S16* defaultNorm, U32 defaultLog, U32 flagRepeatTable)
-{
-    switch(type)
-    {
-    case FSEv07_ENCODING_RLE :
-        if (!srcSize) return ERROR(srcSize_wrong);
-        if ( (*(const BYTE*)src) > max) return ERROR(corruption_detected);
-        FSEv07_buildDTable_rle(DTable, *(const BYTE*)src);   /* if *src > max, data is corrupted */
-        return 1;
-    case FSEv07_ENCODING_RAW :
-        FSEv07_buildDTable(DTable, defaultNorm, max, defaultLog);
-        return 0;
-    case FSEv07_ENCODING_STATIC:
-        if (!flagRepeatTable) return ERROR(corruption_detected);
-        return 0;
-    default :   /* impossible */
-    case FSEv07_ENCODING_DYNAMIC :
-        {   U32 tableLog;
-            S16 norm[MaxSeq+1];
-            size_t const headerSize = FSEv07_readNCount(norm, &max, &tableLog, src, srcSize);
-            if (FSEv07_isError(headerSize)) return ERROR(corruption_detected);
-            if (tableLog > maxLog) return ERROR(corruption_detected);
-            FSEv07_buildDTable(DTable, norm, max, tableLog);
-            return headerSize;
-    }   }
-}
-
-
+                                 const void* src, size_t srcSize, 
+                                 const S16* defaultNorm, U32 defaultLog, U32 flagRepeatTable) 
+{ 
+    switch(type) 
+    { 
+    case FSEv07_ENCODING_RLE : 
+        if (!srcSize) return ERROR(srcSize_wrong); 
+        if ( (*(const BYTE*)src) > max) return ERROR(corruption_detected); 
+        FSEv07_buildDTable_rle(DTable, *(const BYTE*)src);   /* if *src > max, data is corrupted */ 
+        return 1; 
+    case FSEv07_ENCODING_RAW : 
+        FSEv07_buildDTable(DTable, defaultNorm, max, defaultLog); 
+        return 0; 
+    case FSEv07_ENCODING_STATIC: 
+        if (!flagRepeatTable) return ERROR(corruption_detected); 
+        return 0; 
+    default :   /* impossible */ 
+    case FSEv07_ENCODING_DYNAMIC : 
+        {   U32 tableLog; 
+            S16 norm[MaxSeq+1]; 
+            size_t const headerSize = FSEv07_readNCount(norm, &max, &tableLog, src, srcSize); 
+            if (FSEv07_isError(headerSize)) return ERROR(corruption_detected); 
+            if (tableLog > maxLog) return ERROR(corruption_detected); 
+            FSEv07_buildDTable(DTable, norm, max, tableLog); 
+            return headerSize; 
+    }   } 
+} 
+ 
+ 
 static size_t ZSTDv07_decodeSeqHeaders(int* nbSeqPtr,
-                             FSEv07_DTable* DTableLL, FSEv07_DTable* DTableML, FSEv07_DTable* DTableOffb, U32 flagRepeatTable,
-                             const void* src, size_t srcSize)
-{
+                             FSEv07_DTable* DTableLL, FSEv07_DTable* DTableML, FSEv07_DTable* DTableOffb, U32 flagRepeatTable, 
+                             const void* src, size_t srcSize) 
+{ 
     const BYTE* const istart = (const BYTE*)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) {
+    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) {
                 if (ip+2 > iend) return ERROR(srcSize_wrong);
-                nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2;
+                nbSeq = MEM_readLE16(ip) + LONGNBSEQ, ip+=2; 
             } else {
                 if (ip >= iend) return ERROR(srcSize_wrong);
-                nbSeq = ((nbSeq-0x80)<<8) + *ip++;
+                nbSeq = ((nbSeq-0x80)<<8) + *ip++; 
             }
-        }
-        *nbSeqPtr = nbSeq;
-    }
-
-    /* FSE table descriptors */
+        } 
+        *nbSeqPtr = nbSeq; 
+    } 
+ 
+    /* FSE table descriptors */ 
     if (ip + 4 > iend) return ERROR(srcSize_wrong); /* min : header byte + all 3 are "raw", hence no header, but at least xxLog bits per type */
-    {   U32 const LLtype  = *ip >> 6;
-        U32 const OFtype = (*ip >> 4) & 3;
-        U32 const MLtype  = (*ip >> 2) & 3;
-        ip++;
-
-        /* Build DTables */
-        {   size_t const llhSize = ZSTDv07_buildSeqTable(DTableLL, LLtype, MaxLL, LLFSELog, ip, iend-ip, LL_defaultNorm, LL_defaultNormLog, flagRepeatTable);
-            if (ZSTDv07_isError(llhSize)) return ERROR(corruption_detected);
-            ip += llhSize;
-        }
-        {   size_t const ofhSize = ZSTDv07_buildSeqTable(DTableOffb, OFtype, MaxOff, OffFSELog, ip, iend-ip, OF_defaultNorm, OF_defaultNormLog, flagRepeatTable);
-            if (ZSTDv07_isError(ofhSize)) return ERROR(corruption_detected);
-            ip += ofhSize;
-        }
-        {   size_t const mlhSize = ZSTDv07_buildSeqTable(DTableML, MLtype, MaxML, MLFSELog, ip, iend-ip, ML_defaultNorm, ML_defaultNormLog, flagRepeatTable);
-            if (ZSTDv07_isError(mlhSize)) return ERROR(corruption_detected);
-            ip += mlhSize;
-    }   }
-
-    return ip-istart;
-}
-
-
-typedef struct {
-    size_t litLength;
-    size_t matchLength;
-    size_t offset;
-} seq_t;
-
-typedef struct {
-    BITv07_DStream_t DStream;
-    FSEv07_DState_t stateLL;
-    FSEv07_DState_t stateOffb;
-    FSEv07_DState_t stateML;
-    size_t prevOffset[ZSTDv07_REP_INIT];
-} seqState_t;
-
-
-static seq_t ZSTDv07_decodeSequence(seqState_t* seqState)
-{
-    seq_t seq;
-
-    U32 const llCode = FSEv07_peekSymbol(&(seqState->stateLL));
-    U32 const mlCode = FSEv07_peekSymbol(&(seqState->stateML));
-    U32 const ofCode = FSEv07_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] = {
-                             3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,   14,    15,    16,    17,    18,
-                            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,   30,    31,    32,    33,    34,
-                            35, 37, 39, 41, 43, 47, 51, 59, 67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803,
-                            0x1003, 0x2003, 0x4003, 0x8003, 0x10003 };
-
-    static const U32 OF_base[MaxOff+1] = {
-                 0,        1,       1,       5,     0xD,     0x1D,     0x3D,     0x7D,
-                 0xFD,   0x1FD,   0x3FD,   0x7FD,   0xFFD,   0x1FFD,   0x3FFD,   0x7FFD,
-                 0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD,
-                 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD };
-
-    /* sequence */
-    {   size_t offset;
-        if (!ofCode)
-            offset = 0;
-        else {
-            offset = OF_base[ofCode] + BITv07_readBits(&(seqState->DStream), ofBits);   /* <=  (ZSTDv07_WINDOWLOG_MAX-1) bits */
-            if (MEM_32bits()) BITv07_reloadDStream(&(seqState->DStream));
-        }
-
-        if (ofCode <= 1) {
-            if ((llCode == 0) & (offset <= 1)) offset = 1-offset;
-            if (offset) {
-                size_t const 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 {
-            seqState->prevOffset[2] = seqState->prevOffset[1];
-            seqState->prevOffset[1] = seqState->prevOffset[0];
-            seqState->prevOffset[0] = offset;
-        }
-        seq.offset = offset;
-    }
-
-    seq.matchLength = ML_base[mlCode] + ((mlCode>31) ? BITv07_readBits(&(seqState->DStream), mlBits) : 0);   /* <=  16 bits */
-    if (MEM_32bits() && (mlBits+llBits>24)) BITv07_reloadDStream(&(seqState->DStream));
-
-    seq.litLength = LL_base[llCode] + ((llCode>15) ? BITv07_readBits(&(seqState->DStream), llBits) : 0);   /* <=  16 bits */
-    if (MEM_32bits() ||
-       (totalBits > 64 - 7 - (LLFSELog+MLFSELog+OffFSELog)) ) BITv07_reloadDStream(&(seqState->DStream));
-
-    /* ANS state update */
-    FSEv07_updateState(&(seqState->stateLL), &(seqState->DStream));   /* <=  9 bits */
-    FSEv07_updateState(&(seqState->stateML), &(seqState->DStream));   /* <=  9 bits */
-    if (MEM_32bits()) BITv07_reloadDStream(&(seqState->DStream));     /* <= 18 bits */
-    FSEv07_updateState(&(seqState->stateOffb), &(seqState->DStream)); /* <=  8 bits */
-
-    return seq;
-}
-
-
-static
-size_t ZSTDv07_execSequence(BYTE* op,
-                                BYTE* const oend, seq_t sequence,
+    {   U32 const LLtype  = *ip >> 6; 
+        U32 const OFtype = (*ip >> 4) & 3; 
+        U32 const MLtype  = (*ip >> 2) & 3; 
+        ip++; 
+ 
+        /* Build DTables */ 
+        {   size_t const llhSize = ZSTDv07_buildSeqTable(DTableLL, LLtype, MaxLL, LLFSELog, ip, iend-ip, LL_defaultNorm, LL_defaultNormLog, flagRepeatTable); 
+            if (ZSTDv07_isError(llhSize)) return ERROR(corruption_detected); 
+            ip += llhSize; 
+        } 
+        {   size_t const ofhSize = ZSTDv07_buildSeqTable(DTableOffb, OFtype, MaxOff, OffFSELog, ip, iend-ip, OF_defaultNorm, OF_defaultNormLog, flagRepeatTable); 
+            if (ZSTDv07_isError(ofhSize)) return ERROR(corruption_detected); 
+            ip += ofhSize; 
+        } 
+        {   size_t const mlhSize = ZSTDv07_buildSeqTable(DTableML, MLtype, MaxML, MLFSELog, ip, iend-ip, ML_defaultNorm, ML_defaultNormLog, flagRepeatTable); 
+            if (ZSTDv07_isError(mlhSize)) return ERROR(corruption_detected); 
+            ip += mlhSize; 
+    }   } 
+ 
+    return ip-istart; 
+} 
+ 
+ 
+typedef struct { 
+    size_t litLength; 
+    size_t matchLength; 
+    size_t offset; 
+} seq_t; 
+ 
+typedef struct { 
+    BITv07_DStream_t DStream; 
+    FSEv07_DState_t stateLL; 
+    FSEv07_DState_t stateOffb; 
+    FSEv07_DState_t stateML; 
+    size_t prevOffset[ZSTDv07_REP_INIT]; 
+} seqState_t; 
+ 
+ 
+static seq_t ZSTDv07_decodeSequence(seqState_t* seqState) 
+{ 
+    seq_t seq; 
+ 
+    U32 const llCode = FSEv07_peekSymbol(&(seqState->stateLL)); 
+    U32 const mlCode = FSEv07_peekSymbol(&(seqState->stateML)); 
+    U32 const ofCode = FSEv07_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] = { 
+                             3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,   14,    15,    16,    17,    18, 
+                            19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,   30,    31,    32,    33,    34, 
+                            35, 37, 39, 41, 43, 47, 51, 59, 67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803, 
+                            0x1003, 0x2003, 0x4003, 0x8003, 0x10003 }; 
+ 
+    static const U32 OF_base[MaxOff+1] = { 
+                 0,        1,       1,       5,     0xD,     0x1D,     0x3D,     0x7D, 
+                 0xFD,   0x1FD,   0x3FD,   0x7FD,   0xFFD,   0x1FFD,   0x3FFD,   0x7FFD, 
+                 0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD, 
+                 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD }; 
+ 
+    /* sequence */ 
+    {   size_t offset; 
+        if (!ofCode) 
+            offset = 0; 
+        else { 
+            offset = OF_base[ofCode] + BITv07_readBits(&(seqState->DStream), ofBits);   /* <=  (ZSTDv07_WINDOWLOG_MAX-1) bits */ 
+            if (MEM_32bits()) BITv07_reloadDStream(&(seqState->DStream)); 
+        } 
+ 
+        if (ofCode <= 1) { 
+            if ((llCode == 0) & (offset <= 1)) offset = 1-offset; 
+            if (offset) { 
+                size_t const 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 { 
+            seqState->prevOffset[2] = seqState->prevOffset[1]; 
+            seqState->prevOffset[1] = seqState->prevOffset[0]; 
+            seqState->prevOffset[0] = offset; 
+        } 
+        seq.offset = offset; 
+    } 
+ 
+    seq.matchLength = ML_base[mlCode] + ((mlCode>31) ? BITv07_readBits(&(seqState->DStream), mlBits) : 0);   /* <=  16 bits */ 
+    if (MEM_32bits() && (mlBits+llBits>24)) BITv07_reloadDStream(&(seqState->DStream)); 
+ 
+    seq.litLength = LL_base[llCode] + ((llCode>15) ? BITv07_readBits(&(seqState->DStream), llBits) : 0);   /* <=  16 bits */ 
+    if (MEM_32bits() || 
+       (totalBits > 64 - 7 - (LLFSELog+MLFSELog+OffFSELog)) ) BITv07_reloadDStream(&(seqState->DStream)); 
+ 
+    /* ANS state update */ 
+    FSEv07_updateState(&(seqState->stateLL), &(seqState->DStream));   /* <=  9 bits */ 
+    FSEv07_updateState(&(seqState->stateML), &(seqState->DStream));   /* <=  9 bits */ 
+    if (MEM_32bits()) BITv07_reloadDStream(&(seqState->DStream));     /* <= 18 bits */ 
+    FSEv07_updateState(&(seqState->stateOffb), &(seqState->DStream)); /* <=  8 bits */ 
+ 
+    return seq; 
+} 
+ 
+ 
+static 
+size_t ZSTDv07_execSequence(BYTE* op, 
+                                BYTE* const oend, seq_t sequence, 
                                 const BYTE** litPtr, const BYTE* const litLimit,
-                                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_w = oend-WILDCOPY_OVERLENGTH;
-    const BYTE* const iLitEnd = *litPtr + sequence.litLength;
-    const BYTE* match = oLitEnd - sequence.offset;
-
-    /* check */
-    if ((oLitEnd>oend_w) | (oMatchEnd>oend)) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */
+                                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_w = oend-WILDCOPY_OVERLENGTH; 
+    const BYTE* const iLitEnd = *litPtr + sequence.litLength; 
+    const BYTE* match = oLitEnd - sequence.offset; 
+ 
+    /* check */ 
+    if ((oLitEnd>oend_w) | (oMatchEnd>oend)) return ERROR(dstSize_tooSmall); /* last match must start at a minimum distance of WILDCOPY_OVERLENGTH from oend */ 
     if (iLitEnd > litLimit) return ERROR(corruption_detected);   /* over-read beyond lit buffer */
-
-    /* copy Literals */
-    ZSTDv07_wildcopy(op, *litPtr, sequence.litLength);   /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, 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;
+ 
+    /* copy Literals */ 
+    ZSTDv07_wildcopy(op, *litPtr, sequence.litLength);   /* note : since oLitEnd <= oend-WILDCOPY_OVERLENGTH, 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; 
             if (op > oend_w || sequence.matchLength < MINMATCH) {
               while (op < oMatchEnd) *op++ = *match++;
               return sequenceLength;
             }
-    }   }
+    }   } 
     /* Requirement: op <= oend_w */
-
-    /* match within prefix */
-    if (sequence.offset < 8) {
-        /* close range match, overlap */
-        static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */
+ 
+    /* 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 };   /* subtracted */
-        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];
-        ZSTDv07_copy4(op+4, match);
-        match -= sub2;
-    } else {
-        ZSTDv07_copy8(op, match);
-    }
-    op += 8; match += 8;
-
-    if (oMatchEnd > oend-(16-MINMATCH)) {
-        if (op < oend_w) {
-            ZSTDv07_wildcopy(op, match, oend_w - op);
-            match += oend_w - op;
-            op = oend_w;
-        }
-        while (op < oMatchEnd) *op++ = *match++;
-    } else {
+        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]; 
+        ZSTDv07_copy4(op+4, match); 
+        match -= sub2; 
+    } else { 
+        ZSTDv07_copy8(op, match); 
+    } 
+    op += 8; match += 8; 
+ 
+    if (oMatchEnd > oend-(16-MINMATCH)) { 
+        if (op < oend_w) { 
+            ZSTDv07_wildcopy(op, match, oend_w - op); 
+            match += oend_w - op; 
+            op = oend_w; 
+        } 
+        while (op < oMatchEnd) *op++ = *match++; 
+    } else { 
         ZSTDv07_wildcopy(op, match, (ptrdiff_t)sequence.matchLength-8);   /* works even if matchLength < 8 */
-    }
-    return sequenceLength;
-}
-
-
-static size_t ZSTDv07_decompressSequences(
-                               ZSTDv07_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;
+    } 
+    return sequenceLength; 
+} 
+ 
+ 
+static size_t ZSTDv07_decompressSequences( 
+                               ZSTDv07_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*)dst;
-    BYTE* const oend = ostart + maxDstSize;
-    BYTE* op = ostart;
-    const BYTE* litPtr = dctx->litPtr;
-    const BYTE* const litEnd = litPtr + dctx->litSize;
-    FSEv07_DTable* DTableLL = dctx->LLTable;
-    FSEv07_DTable* DTableML = dctx->MLTable;
-    FSEv07_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 = ZSTDv07_decodeSeqHeaders(&nbSeq, DTableLL, DTableML, DTableOffb, dctx->fseEntropy, ip, seqSize);
-        if (ZSTDv07_isError(seqHSize)) return seqHSize;
-        ip += seqHSize;
-    }
-
-    /* Regen sequences */
-    if (nbSeq) {
-        seqState_t seqState;
-        dctx->fseEntropy = 1;
-        { U32 i; for (i=0; i<ZSTDv07_REP_INIT; i++) seqState.prevOffset[i] = dctx->rep[i]; }
-        { size_t const errorCode = BITv07_initDStream(&(seqState.DStream), ip, iend-ip);
-          if (ERR_isError(errorCode)) return ERROR(corruption_detected); }
-        FSEv07_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);
-        FSEv07_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);
-        FSEv07_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);
-
-        for ( ; (BITv07_reloadDStream(&(seqState.DStream)) <= BITv07_DStream_completed) && nbSeq ; ) {
-            nbSeq--;
-            {   seq_t const sequence = ZSTDv07_decodeSequence(&seqState);
+    BYTE* const oend = ostart + maxDstSize; 
+    BYTE* op = ostart; 
+    const BYTE* litPtr = dctx->litPtr; 
+    const BYTE* const litEnd = litPtr + dctx->litSize; 
+    FSEv07_DTable* DTableLL = dctx->LLTable; 
+    FSEv07_DTable* DTableML = dctx->MLTable; 
+    FSEv07_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 = ZSTDv07_decodeSeqHeaders(&nbSeq, DTableLL, DTableML, DTableOffb, dctx->fseEntropy, ip, seqSize); 
+        if (ZSTDv07_isError(seqHSize)) return seqHSize; 
+        ip += seqHSize; 
+    } 
+ 
+    /* Regen sequences */ 
+    if (nbSeq) { 
+        seqState_t seqState; 
+        dctx->fseEntropy = 1; 
+        { U32 i; for (i=0; i<ZSTDv07_REP_INIT; i++) seqState.prevOffset[i] = dctx->rep[i]; } 
+        { size_t const errorCode = BITv07_initDStream(&(seqState.DStream), ip, iend-ip); 
+          if (ERR_isError(errorCode)) return ERROR(corruption_detected); } 
+        FSEv07_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL); 
+        FSEv07_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb); 
+        FSEv07_initDState(&(seqState.stateML), &(seqState.DStream), DTableML); 
+ 
+        for ( ; (BITv07_reloadDStream(&(seqState.DStream)) <= BITv07_DStream_completed) && nbSeq ; ) { 
+            nbSeq--; 
+            {   seq_t const sequence = ZSTDv07_decodeSequence(&seqState); 
                 size_t const oneSeqSize = ZSTDv07_execSequence(op, oend, sequence, &litPtr, litEnd, base, vBase, dictEnd);
-                if (ZSTDv07_isError(oneSeqSize)) return oneSeqSize;
-                op += oneSeqSize;
-        }   }
-
-        /* check if reached exact end */
-        if (nbSeq) return ERROR(corruption_detected);
-        /* save reps for next block */
-        { U32 i; for (i=0; i<ZSTDv07_REP_INIT; i++) dctx->rep[i] = (U32)(seqState.prevOffset[i]); }
-    }
-
-    /* last literal segment */
-    {   size_t const lastLLSize = litEnd - litPtr;
+                if (ZSTDv07_isError(oneSeqSize)) return oneSeqSize; 
+                op += oneSeqSize; 
+        }   } 
+ 
+        /* check if reached exact end */ 
+        if (nbSeq) return ERROR(corruption_detected); 
+        /* save reps for next block */ 
+        { U32 i; for (i=0; i<ZSTDv07_REP_INIT; i++) dctx->rep[i] = (U32)(seqState.prevOffset[i]); } 
+    } 
+ 
+    /* last literal segment */ 
+    {   size_t const lastLLSize = litEnd - litPtr; 
         /* if (litPtr > litEnd) return ERROR(corruption_detected); */   /* too many literals already used */
-        if (lastLLSize > (size_t)(oend-op)) return ERROR(dstSize_tooSmall);
+        if (lastLLSize > (size_t)(oend-op)) return ERROR(dstSize_tooSmall); 
         if (lastLLSize > 0) {
             memcpy(op, litPtr, lastLLSize);
             op += lastLLSize;
         }
-    }
-
-    return op-ostart;
-}
-
-
-static void ZSTDv07_checkContinuity(ZSTDv07_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 ZSTDv07_decompressBlock_internal(ZSTDv07_DCtx* dctx,
-                            void* dst, size_t dstCapacity,
-                      const void* src, size_t srcSize)
-{   /* blockType == blockCompressed */
-    const BYTE* ip = (const BYTE*)src;
-
-    if (srcSize >= ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(srcSize_wrong);
-
-    /* Decode literals sub-block */
-    {   size_t const litCSize = ZSTDv07_decodeLiteralsBlock(dctx, src, srcSize);
-        if (ZSTDv07_isError(litCSize)) return litCSize;
-        ip += litCSize;
-        srcSize -= litCSize;
-    }
-    return ZSTDv07_decompressSequences(dctx, dst, dstCapacity, ip, srcSize);
-}
-
-
-size_t ZSTDv07_decompressBlock(ZSTDv07_DCtx* dctx,
-                            void* dst, size_t dstCapacity,
-                      const void* src, size_t srcSize)
-{
-    size_t dSize;
-    ZSTDv07_checkContinuity(dctx, dst);
-    dSize = ZSTDv07_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
-    dctx->previousDstEnd = (char*)dst + dSize;
-    return dSize;
-}
-
-
-/** ZSTDv07_insertBlock() :
-    insert `src` block into `dctx` history. Useful to track uncompressed blocks. */
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+static void ZSTDv07_checkContinuity(ZSTDv07_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 ZSTDv07_decompressBlock_internal(ZSTDv07_DCtx* dctx, 
+                            void* dst, size_t dstCapacity, 
+                      const void* src, size_t srcSize) 
+{   /* blockType == blockCompressed */ 
+    const BYTE* ip = (const BYTE*)src; 
+ 
+    if (srcSize >= ZSTDv07_BLOCKSIZE_ABSOLUTEMAX) return ERROR(srcSize_wrong); 
+ 
+    /* Decode literals sub-block */ 
+    {   size_t const litCSize = ZSTDv07_decodeLiteralsBlock(dctx, src, srcSize); 
+        if (ZSTDv07_isError(litCSize)) return litCSize; 
+        ip += litCSize; 
+        srcSize -= litCSize; 
+    } 
+    return ZSTDv07_decompressSequences(dctx, dst, dstCapacity, ip, srcSize); 
+} 
+ 
+ 
+size_t ZSTDv07_decompressBlock(ZSTDv07_DCtx* dctx, 
+                            void* dst, size_t dstCapacity, 
+                      const void* src, size_t srcSize) 
+{ 
+    size_t dSize; 
+    ZSTDv07_checkContinuity(dctx, dst); 
+    dSize = ZSTDv07_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize); 
+    dctx->previousDstEnd = (char*)dst + dSize; 
+    return dSize; 
+} 
+ 
+ 
+/** ZSTDv07_insertBlock() : 
+    insert `src` block into `dctx` history. Useful to track uncompressed blocks. */ 
 ZSTDLIBv07_API size_t ZSTDv07_insertBlock(ZSTDv07_DCtx* dctx, const void* blockStart, size_t blockSize)
-{
-    ZSTDv07_checkContinuity(dctx, blockStart);
-    dctx->previousDstEnd = (const char*)blockStart + blockSize;
-    return blockSize;
-}
-
-
+{ 
+    ZSTDv07_checkContinuity(dctx, blockStart); 
+    dctx->previousDstEnd = (const char*)blockStart + blockSize; 
+    return blockSize; 
+} 
+ 
+ 
 static size_t ZSTDv07_generateNxBytes(void* dst, size_t dstCapacity, BYTE byte, size_t length)
-{
-    if (length > dstCapacity) return ERROR(dstSize_tooSmall);
+{ 
+    if (length > dstCapacity) return ERROR(dstSize_tooSmall); 
     if (length > 0) {
         memset(dst, byte, length);
     }
-    return length;
-}
-
-
-/*! ZSTDv07_decompressFrame() :
-*   `dctx` must be properly initialized */
-static size_t ZSTDv07_decompressFrame(ZSTDv07_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;
+    return length; 
+} 
+ 
+ 
+/*! ZSTDv07_decompressFrame() : 
+*   `dctx` must be properly initialized */ 
+static size_t ZSTDv07_decompressFrame(ZSTDv07_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*)dst;
-    BYTE* const oend = ostart + dstCapacity;
-    BYTE* op = ostart;
-    size_t remainingSize = srcSize;
-
-    /* check */
-    if (srcSize < ZSTDv07_frameHeaderSize_min+ZSTDv07_blockHeaderSize) return ERROR(srcSize_wrong);
-
-    /* Frame Header */
-    {   size_t const frameHeaderSize = ZSTDv07_frameHeaderSize(src, ZSTDv07_frameHeaderSize_min);
-        if (ZSTDv07_isError(frameHeaderSize)) return frameHeaderSize;
-        if (srcSize < frameHeaderSize+ZSTDv07_blockHeaderSize) return ERROR(srcSize_wrong);
-        if (ZSTDv07_decodeFrameHeader(dctx, src, frameHeaderSize)) return ERROR(corruption_detected);
-        ip += frameHeaderSize; remainingSize -= frameHeaderSize;
-    }
-
-    /* Loop on each block */
-    while (1) {
-        size_t decodedSize;
-        blockProperties_t blockProperties;
-        size_t const cBlockSize = ZSTDv07_getcBlockSize(ip, iend-ip, &blockProperties);
-        if (ZSTDv07_isError(cBlockSize)) return cBlockSize;
-
-        ip += ZSTDv07_blockHeaderSize;
-        remainingSize -= ZSTDv07_blockHeaderSize;
-        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong);
-
-        switch(blockProperties.blockType)
-        {
-        case bt_compressed:
-            decodedSize = ZSTDv07_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize);
-            break;
-        case bt_raw :
-            decodedSize = ZSTDv07_copyRawBlock(op, oend-op, ip, cBlockSize);
-            break;
-        case bt_rle :
-            decodedSize = ZSTDv07_generateNxBytes(op, oend-op, *ip, blockProperties.origSize);
-            break;
-        case bt_end :
-            /* end of frame */
-            if (remainingSize) return ERROR(srcSize_wrong);
-            decodedSize = 0;
-            break;
-        default:
-            return ERROR(GENERIC);   /* impossible */
-        }
-        if (blockProperties.blockType == bt_end) break;   /* bt_end */
-
-        if (ZSTDv07_isError(decodedSize)) return decodedSize;
-        if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, op, decodedSize);
-        op += decodedSize;
-        ip += cBlockSize;
-        remainingSize -= cBlockSize;
-    }
-
-    return op-ostart;
-}
-
-
-/*! ZSTDv07_decompress_usingPreparedDCtx() :
-*   Same as ZSTDv07_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 ZSTDv07_decompressBegin_usingDict().
-*   Requires 2 contexts : 1 for reference (preparedDCtx), which will not be modified, and 1 to run the decompression operation (dctx) */
+    BYTE* const oend = ostart + dstCapacity; 
+    BYTE* op = ostart; 
+    size_t remainingSize = srcSize; 
+ 
+    /* check */ 
+    if (srcSize < ZSTDv07_frameHeaderSize_min+ZSTDv07_blockHeaderSize) return ERROR(srcSize_wrong); 
+ 
+    /* Frame Header */ 
+    {   size_t const frameHeaderSize = ZSTDv07_frameHeaderSize(src, ZSTDv07_frameHeaderSize_min); 
+        if (ZSTDv07_isError(frameHeaderSize)) return frameHeaderSize; 
+        if (srcSize < frameHeaderSize+ZSTDv07_blockHeaderSize) return ERROR(srcSize_wrong); 
+        if (ZSTDv07_decodeFrameHeader(dctx, src, frameHeaderSize)) return ERROR(corruption_detected); 
+        ip += frameHeaderSize; remainingSize -= frameHeaderSize; 
+    } 
+ 
+    /* Loop on each block */ 
+    while (1) { 
+        size_t decodedSize; 
+        blockProperties_t blockProperties; 
+        size_t const cBlockSize = ZSTDv07_getcBlockSize(ip, iend-ip, &blockProperties); 
+        if (ZSTDv07_isError(cBlockSize)) return cBlockSize; 
+ 
+        ip += ZSTDv07_blockHeaderSize; 
+        remainingSize -= ZSTDv07_blockHeaderSize; 
+        if (cBlockSize > remainingSize) return ERROR(srcSize_wrong); 
+ 
+        switch(blockProperties.blockType) 
+        { 
+        case bt_compressed: 
+            decodedSize = ZSTDv07_decompressBlock_internal(dctx, op, oend-op, ip, cBlockSize); 
+            break; 
+        case bt_raw : 
+            decodedSize = ZSTDv07_copyRawBlock(op, oend-op, ip, cBlockSize); 
+            break; 
+        case bt_rle : 
+            decodedSize = ZSTDv07_generateNxBytes(op, oend-op, *ip, blockProperties.origSize); 
+            break; 
+        case bt_end : 
+            /* end of frame */ 
+            if (remainingSize) return ERROR(srcSize_wrong); 
+            decodedSize = 0; 
+            break; 
+        default: 
+            return ERROR(GENERIC);   /* impossible */ 
+        } 
+        if (blockProperties.blockType == bt_end) break;   /* bt_end */ 
+ 
+        if (ZSTDv07_isError(decodedSize)) return decodedSize; 
+        if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, op, decodedSize); 
+        op += decodedSize; 
+        ip += cBlockSize; 
+        remainingSize -= cBlockSize; 
+    } 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+/*! ZSTDv07_decompress_usingPreparedDCtx() : 
+*   Same as ZSTDv07_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 ZSTDv07_decompressBegin_usingDict(). 
+*   Requires 2 contexts : 1 for reference (preparedDCtx), which will not be modified, and 1 to run the decompression operation (dctx) */ 
 static size_t ZSTDv07_decompress_usingPreparedDCtx(ZSTDv07_DCtx* dctx, const ZSTDv07_DCtx* refDCtx,
-                                         void* dst, size_t dstCapacity,
-                                   const void* src, size_t srcSize)
-{
-    ZSTDv07_copyDCtx(dctx, refDCtx);
-    ZSTDv07_checkContinuity(dctx, dst);
-    return ZSTDv07_decompressFrame(dctx, dst, dstCapacity, src, srcSize);
-}
-
-
-size_t ZSTDv07_decompress_usingDict(ZSTDv07_DCtx* dctx,
-                                 void* dst, size_t dstCapacity,
-                                 const void* src, size_t srcSize,
-                                 const void* dict, size_t dictSize)
-{
-    ZSTDv07_decompressBegin_usingDict(dctx, dict, dictSize);
-    ZSTDv07_checkContinuity(dctx, dst);
-    return ZSTDv07_decompressFrame(dctx, dst, dstCapacity, src, srcSize);
-}
-
-
-size_t ZSTDv07_decompressDCtx(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    return ZSTDv07_decompress_usingDict(dctx, dst, dstCapacity, src, srcSize, NULL, 0);
-}
-
-
-size_t ZSTDv07_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-#if defined(ZSTDv07_HEAPMODE) && (ZSTDv07_HEAPMODE==1)
-    size_t regenSize;
-    ZSTDv07_DCtx* const dctx = ZSTDv07_createDCtx();
-    if (dctx==NULL) return ERROR(memory_allocation);
-    regenSize = ZSTDv07_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);
-    ZSTDv07_freeDCtx(dctx);
-    return regenSize;
-#else   /* stack mode */
-    ZSTDv07_DCtx dctx;
-    return ZSTDv07_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);
-#endif
-}
-
+                                         void* dst, size_t dstCapacity, 
+                                   const void* src, size_t srcSize) 
+{ 
+    ZSTDv07_copyDCtx(dctx, refDCtx); 
+    ZSTDv07_checkContinuity(dctx, dst); 
+    return ZSTDv07_decompressFrame(dctx, dst, dstCapacity, src, srcSize); 
+} 
+ 
+ 
+size_t ZSTDv07_decompress_usingDict(ZSTDv07_DCtx* dctx, 
+                                 void* dst, size_t dstCapacity, 
+                                 const void* src, size_t srcSize, 
+                                 const void* dict, size_t dictSize) 
+{ 
+    ZSTDv07_decompressBegin_usingDict(dctx, dict, dictSize); 
+    ZSTDv07_checkContinuity(dctx, dst); 
+    return ZSTDv07_decompressFrame(dctx, dst, dstCapacity, src, srcSize); 
+} 
+ 
+ 
+size_t ZSTDv07_decompressDCtx(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    return ZSTDv07_decompress_usingDict(dctx, dst, dstCapacity, src, srcSize, NULL, 0); 
+} 
+ 
+ 
+size_t ZSTDv07_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+#if defined(ZSTDv07_HEAPMODE) && (ZSTDv07_HEAPMODE==1) 
+    size_t regenSize; 
+    ZSTDv07_DCtx* const dctx = ZSTDv07_createDCtx(); 
+    if (dctx==NULL) return ERROR(memory_allocation); 
+    regenSize = ZSTDv07_decompressDCtx(dctx, dst, dstCapacity, src, srcSize); 
+    ZSTDv07_freeDCtx(dctx); 
+    return regenSize; 
+#else   /* stack mode */ 
+    ZSTDv07_DCtx dctx; 
+    return ZSTDv07_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize); 
+#endif 
+} 
+ 
 /* ZSTD_errorFrameSizeInfoLegacy() :
    assumes `cSize` and `dBound` are _not_ NULL */
 static void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)
@@ -3914,7 +3914,7 @@ void ZSTDv07_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cS
     const BYTE* ip = (const BYTE*)src;
     size_t remainingSize = srcSize;
     size_t nbBlocks = 0;
-
+ 
     /* check */
     if (srcSize < ZSTDv07_frameHeaderSize_min+ZSTDv07_blockHeaderSize) {
         ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));
@@ -3966,576 +3966,576 @@ void ZSTDv07_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cS
     *dBound = nbBlocks * ZSTDv07_BLOCKSIZE_ABSOLUTEMAX;
 }
 
-/*_******************************
-*  Streaming Decompression API
-********************************/
-size_t ZSTDv07_nextSrcSizeToDecompress(ZSTDv07_DCtx* dctx)
-{
-    return dctx->expected;
-}
-
-int ZSTDv07_isSkipFrame(ZSTDv07_DCtx* dctx)
-{
-    return dctx->stage == ZSTDds_skipFrame;
-}
-
-/** ZSTDv07_decompressContinue() :
-*   @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity)
-*             or an error code, which can be tested using ZSTDv07_isError() */
-size_t ZSTDv07_decompressContinue(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    /* Sanity check */
-    if (srcSize != dctx->expected) return ERROR(srcSize_wrong);
-    if (dstCapacity) ZSTDv07_checkContinuity(dctx, dst);
-
-    switch (dctx->stage)
-    {
-    case ZSTDds_getFrameHeaderSize :
-        if (srcSize != ZSTDv07_frameHeaderSize_min) return ERROR(srcSize_wrong);   /* impossible */
-        if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTDv07_MAGIC_SKIPPABLE_START) {
-            memcpy(dctx->headerBuffer, src, ZSTDv07_frameHeaderSize_min);
-            dctx->expected = ZSTDv07_skippableHeaderSize - ZSTDv07_frameHeaderSize_min; /* magic number + skippable frame length */
-            dctx->stage = ZSTDds_decodeSkippableHeader;
-            return 0;
-        }
-        dctx->headerSize = ZSTDv07_frameHeaderSize(src, ZSTDv07_frameHeaderSize_min);
-        if (ZSTDv07_isError(dctx->headerSize)) return dctx->headerSize;
-        memcpy(dctx->headerBuffer, src, ZSTDv07_frameHeaderSize_min);
-        if (dctx->headerSize > ZSTDv07_frameHeaderSize_min) {
-            dctx->expected = dctx->headerSize - ZSTDv07_frameHeaderSize_min;
-            dctx->stage = ZSTDds_decodeFrameHeader;
-            return 0;
-        }
-        dctx->expected = 0;   /* not necessary to copy more */
+/*_****************************** 
+*  Streaming Decompression API 
+********************************/ 
+size_t ZSTDv07_nextSrcSizeToDecompress(ZSTDv07_DCtx* dctx) 
+{ 
+    return dctx->expected; 
+} 
+ 
+int ZSTDv07_isSkipFrame(ZSTDv07_DCtx* dctx) 
+{ 
+    return dctx->stage == ZSTDds_skipFrame; 
+} 
+ 
+/** ZSTDv07_decompressContinue() : 
+*   @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity) 
+*             or an error code, which can be tested using ZSTDv07_isError() */ 
+size_t ZSTDv07_decompressContinue(ZSTDv07_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    /* Sanity check */ 
+    if (srcSize != dctx->expected) return ERROR(srcSize_wrong); 
+    if (dstCapacity) ZSTDv07_checkContinuity(dctx, dst); 
+ 
+    switch (dctx->stage) 
+    { 
+    case ZSTDds_getFrameHeaderSize : 
+        if (srcSize != ZSTDv07_frameHeaderSize_min) return ERROR(srcSize_wrong);   /* impossible */ 
+        if ((MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTDv07_MAGIC_SKIPPABLE_START) { 
+            memcpy(dctx->headerBuffer, src, ZSTDv07_frameHeaderSize_min); 
+            dctx->expected = ZSTDv07_skippableHeaderSize - ZSTDv07_frameHeaderSize_min; /* magic number + skippable frame length */ 
+            dctx->stage = ZSTDds_decodeSkippableHeader; 
+            return 0; 
+        } 
+        dctx->headerSize = ZSTDv07_frameHeaderSize(src, ZSTDv07_frameHeaderSize_min); 
+        if (ZSTDv07_isError(dctx->headerSize)) return dctx->headerSize; 
+        memcpy(dctx->headerBuffer, src, ZSTDv07_frameHeaderSize_min); 
+        if (dctx->headerSize > ZSTDv07_frameHeaderSize_min) { 
+            dctx->expected = dctx->headerSize - ZSTDv07_frameHeaderSize_min; 
+            dctx->stage = ZSTDds_decodeFrameHeader; 
+            return 0; 
+        } 
+        dctx->expected = 0;   /* not necessary to copy more */ 
 	/* fall-through */
-    case ZSTDds_decodeFrameHeader:
-        {   size_t result;
-            memcpy(dctx->headerBuffer + ZSTDv07_frameHeaderSize_min, src, dctx->expected);
-            result = ZSTDv07_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize);
-            if (ZSTDv07_isError(result)) return result;
-            dctx->expected = ZSTDv07_blockHeaderSize;
-            dctx->stage = ZSTDds_decodeBlockHeader;
-            return 0;
-        }
-    case ZSTDds_decodeBlockHeader:
-        {   blockProperties_t bp;
-            size_t const cBlockSize = ZSTDv07_getcBlockSize(src, ZSTDv07_blockHeaderSize, &bp);
-            if (ZSTDv07_isError(cBlockSize)) return cBlockSize;
-            if (bp.blockType == bt_end) {
-                if (dctx->fParams.checksumFlag) {
-                    U64 const h64 = XXH64_digest(&dctx->xxhState);
-                    U32 const h32 = (U32)(h64>>11) & ((1<<22)-1);
-                    const BYTE* const ip = (const BYTE*)src;
-                    U32 const check32 = ip[2] + (ip[1] << 8) + ((ip[0] & 0x3F) << 16);
-                    if (check32 != h32) return ERROR(checksum_wrong);
-                }
-                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:
-                rSize = ZSTDv07_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize);
-                break;
-            case bt_raw :
-                rSize = ZSTDv07_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 = ZSTDv07_blockHeaderSize;
-            dctx->previousDstEnd = (char*)dst + rSize;
-            if (ZSTDv07_isError(rSize)) return rSize;
-            if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, dst, rSize);
-            return rSize;
-        }
-    case ZSTDds_decodeSkippableHeader:
-        {   memcpy(dctx->headerBuffer + ZSTDv07_frameHeaderSize_min, src, dctx->expected);
-            dctx->expected = MEM_readLE32(dctx->headerBuffer + 4);
-            dctx->stage = ZSTDds_skipFrame;
-            return 0;
-        }
-    case ZSTDds_skipFrame:
-        {   dctx->expected = 0;
-            dctx->stage = ZSTDds_getFrameHeaderSize;
-            return 0;
-        }
-    default:
-        return ERROR(GENERIC);   /* impossible */
-    }
-}
-
-
-static size_t ZSTDv07_refDictContent(ZSTDv07_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;
-    return 0;
-}
-
-static size_t ZSTDv07_loadEntropy(ZSTDv07_DCtx* dctx, const void* const dict, size_t const dictSize)
-{
-    const BYTE* dictPtr = (const BYTE*)dict;
-    const BYTE* const dictEnd = dictPtr + dictSize;
-
-    {   size_t const hSize = HUFv07_readDTableX4(dctx->hufTable, dict, dictSize);
-        if (HUFv07_isError(hSize)) return ERROR(dictionary_corrupted);
-        dictPtr += hSize;
-    }
-
-    {   short offcodeNCount[MaxOff+1];
+    case ZSTDds_decodeFrameHeader: 
+        {   size_t result; 
+            memcpy(dctx->headerBuffer + ZSTDv07_frameHeaderSize_min, src, dctx->expected); 
+            result = ZSTDv07_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize); 
+            if (ZSTDv07_isError(result)) return result; 
+            dctx->expected = ZSTDv07_blockHeaderSize; 
+            dctx->stage = ZSTDds_decodeBlockHeader; 
+            return 0; 
+        } 
+    case ZSTDds_decodeBlockHeader: 
+        {   blockProperties_t bp; 
+            size_t const cBlockSize = ZSTDv07_getcBlockSize(src, ZSTDv07_blockHeaderSize, &bp); 
+            if (ZSTDv07_isError(cBlockSize)) return cBlockSize; 
+            if (bp.blockType == bt_end) { 
+                if (dctx->fParams.checksumFlag) { 
+                    U64 const h64 = XXH64_digest(&dctx->xxhState); 
+                    U32 const h32 = (U32)(h64>>11) & ((1<<22)-1); 
+                    const BYTE* const ip = (const BYTE*)src; 
+                    U32 const check32 = ip[2] + (ip[1] << 8) + ((ip[0] & 0x3F) << 16); 
+                    if (check32 != h32) return ERROR(checksum_wrong); 
+                } 
+                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: 
+                rSize = ZSTDv07_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize); 
+                break; 
+            case bt_raw : 
+                rSize = ZSTDv07_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 = ZSTDv07_blockHeaderSize; 
+            dctx->previousDstEnd = (char*)dst + rSize; 
+            if (ZSTDv07_isError(rSize)) return rSize; 
+            if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, dst, rSize); 
+            return rSize; 
+        } 
+    case ZSTDds_decodeSkippableHeader: 
+        {   memcpy(dctx->headerBuffer + ZSTDv07_frameHeaderSize_min, src, dctx->expected); 
+            dctx->expected = MEM_readLE32(dctx->headerBuffer + 4); 
+            dctx->stage = ZSTDds_skipFrame; 
+            return 0; 
+        } 
+    case ZSTDds_skipFrame: 
+        {   dctx->expected = 0; 
+            dctx->stage = ZSTDds_getFrameHeaderSize; 
+            return 0; 
+        } 
+    default: 
+        return ERROR(GENERIC);   /* impossible */ 
+    } 
+} 
+ 
+ 
+static size_t ZSTDv07_refDictContent(ZSTDv07_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; 
+    return 0; 
+} 
+ 
+static size_t ZSTDv07_loadEntropy(ZSTDv07_DCtx* dctx, const void* const dict, size_t const dictSize) 
+{ 
+    const BYTE* dictPtr = (const BYTE*)dict; 
+    const BYTE* const dictEnd = dictPtr + dictSize; 
+ 
+    {   size_t const hSize = HUFv07_readDTableX4(dctx->hufTable, dict, dictSize); 
+        if (HUFv07_isError(hSize)) return ERROR(dictionary_corrupted); 
+        dictPtr += hSize; 
+    } 
+ 
+    {   short offcodeNCount[MaxOff+1]; 
         U32 offcodeMaxValue=MaxOff, offcodeLog;
-        size_t const offcodeHeaderSize = FSEv07_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr);
-        if (FSEv07_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);
+        size_t const offcodeHeaderSize = FSEv07_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, dictEnd-dictPtr); 
+        if (FSEv07_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted); 
         if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted);
-        { size_t const errorCode = FSEv07_buildDTable(dctx->OffTable, offcodeNCount, offcodeMaxValue, offcodeLog);
-          if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); }
-        dictPtr += offcodeHeaderSize;
-    }
-
-    {   short matchlengthNCount[MaxML+1];
+        { size_t const errorCode = FSEv07_buildDTable(dctx->OffTable, offcodeNCount, offcodeMaxValue, offcodeLog); 
+          if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); } 
+        dictPtr += offcodeHeaderSize; 
+    } 
+ 
+    {   short matchlengthNCount[MaxML+1]; 
         unsigned matchlengthMaxValue = MaxML, matchlengthLog;
-        size_t const matchlengthHeaderSize = FSEv07_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr);
-        if (FSEv07_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted);
+        size_t const matchlengthHeaderSize = FSEv07_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, dictEnd-dictPtr); 
+        if (FSEv07_isError(matchlengthHeaderSize)) return ERROR(dictionary_corrupted); 
         if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted);
-        { size_t const errorCode = FSEv07_buildDTable(dctx->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog);
-          if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); }
-        dictPtr += matchlengthHeaderSize;
-    }
-
-    {   short litlengthNCount[MaxLL+1];
+        { size_t const errorCode = FSEv07_buildDTable(dctx->MLTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog); 
+          if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); } 
+        dictPtr += matchlengthHeaderSize; 
+    } 
+ 
+    {   short litlengthNCount[MaxLL+1]; 
         unsigned litlengthMaxValue = MaxLL, litlengthLog;
-        size_t const litlengthHeaderSize = FSEv07_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr);
-        if (FSEv07_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted);
+        size_t const litlengthHeaderSize = FSEv07_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, dictEnd-dictPtr); 
+        if (FSEv07_isError(litlengthHeaderSize)) return ERROR(dictionary_corrupted); 
         if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted);
-        { size_t const errorCode = FSEv07_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog);
-          if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); }
-        dictPtr += litlengthHeaderSize;
-    }
-
-    if (dictPtr+12 > dictEnd) return ERROR(dictionary_corrupted);
+        { size_t const errorCode = FSEv07_buildDTable(dctx->LLTable, litlengthNCount, litlengthMaxValue, litlengthLog); 
+          if (FSEv07_isError(errorCode)) return ERROR(dictionary_corrupted); } 
+        dictPtr += litlengthHeaderSize; 
+    } 
+ 
+    if (dictPtr+12 > dictEnd) return ERROR(dictionary_corrupted); 
     dctx->rep[0] = MEM_readLE32(dictPtr+0); if (dctx->rep[0] == 0 || dctx->rep[0] >= dictSize) return ERROR(dictionary_corrupted);
     dctx->rep[1] = MEM_readLE32(dictPtr+4); if (dctx->rep[1] == 0 || dctx->rep[1] >= dictSize) return ERROR(dictionary_corrupted);
     dctx->rep[2] = MEM_readLE32(dictPtr+8); if (dctx->rep[2] == 0 || dctx->rep[2] >= dictSize) return ERROR(dictionary_corrupted);
-    dictPtr += 12;
-
-    dctx->litEntropy = dctx->fseEntropy = 1;
-    return dictPtr - (const BYTE*)dict;
-}
-
-static size_t ZSTDv07_decompress_insertDictionary(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    if (dictSize < 8) return ZSTDv07_refDictContent(dctx, dict, dictSize);
-    {   U32 const magic = MEM_readLE32(dict);
-        if (magic != ZSTDv07_DICT_MAGIC) {
-            return ZSTDv07_refDictContent(dctx, dict, dictSize);   /* pure content mode */
-    }   }
-    dctx->dictID = MEM_readLE32((const char*)dict + 4);
-
-    /* load entropy tables */
-    dict = (const char*)dict + 8;
-    dictSize -= 8;
-    {   size_t const eSize = ZSTDv07_loadEntropy(dctx, dict, dictSize);
-        if (ZSTDv07_isError(eSize)) return ERROR(dictionary_corrupted);
-        dict = (const char*)dict + eSize;
-        dictSize -= eSize;
-    }
-
-    /* reference dictionary content */
-    return ZSTDv07_refDictContent(dctx, dict, dictSize);
-}
-
-
-size_t ZSTDv07_decompressBegin_usingDict(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize)
-{
-    { size_t const errorCode = ZSTDv07_decompressBegin(dctx);
-      if (ZSTDv07_isError(errorCode)) return errorCode; }
-
-    if (dict && dictSize) {
-        size_t const errorCode = ZSTDv07_decompress_insertDictionary(dctx, dict, dictSize);
-        if (ZSTDv07_isError(errorCode)) return ERROR(dictionary_corrupted);
-    }
-
-    return 0;
-}
-
-
-struct ZSTDv07_DDict_s {
-    void* dict;
-    size_t dictSize;
-    ZSTDv07_DCtx* refContext;
-};  /* typedef'd tp ZSTDv07_CDict within zstd.h */
-
+    dictPtr += 12; 
+ 
+    dctx->litEntropy = dctx->fseEntropy = 1; 
+    return dictPtr - (const BYTE*)dict; 
+} 
+ 
+static size_t ZSTDv07_decompress_insertDictionary(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
+    if (dictSize < 8) return ZSTDv07_refDictContent(dctx, dict, dictSize); 
+    {   U32 const magic = MEM_readLE32(dict); 
+        if (magic != ZSTDv07_DICT_MAGIC) { 
+            return ZSTDv07_refDictContent(dctx, dict, dictSize);   /* pure content mode */ 
+    }   } 
+    dctx->dictID = MEM_readLE32((const char*)dict + 4); 
+ 
+    /* load entropy tables */ 
+    dict = (const char*)dict + 8; 
+    dictSize -= 8; 
+    {   size_t const eSize = ZSTDv07_loadEntropy(dctx, dict, dictSize); 
+        if (ZSTDv07_isError(eSize)) return ERROR(dictionary_corrupted); 
+        dict = (const char*)dict + eSize; 
+        dictSize -= eSize; 
+    } 
+ 
+    /* reference dictionary content */ 
+    return ZSTDv07_refDictContent(dctx, dict, dictSize); 
+} 
+ 
+ 
+size_t ZSTDv07_decompressBegin_usingDict(ZSTDv07_DCtx* dctx, const void* dict, size_t dictSize) 
+{ 
+    { size_t const errorCode = ZSTDv07_decompressBegin(dctx); 
+      if (ZSTDv07_isError(errorCode)) return errorCode; } 
+ 
+    if (dict && dictSize) { 
+        size_t const errorCode = ZSTDv07_decompress_insertDictionary(dctx, dict, dictSize); 
+        if (ZSTDv07_isError(errorCode)) return ERROR(dictionary_corrupted); 
+    } 
+ 
+    return 0; 
+} 
+ 
+ 
+struct ZSTDv07_DDict_s { 
+    void* dict; 
+    size_t dictSize; 
+    ZSTDv07_DCtx* refContext; 
+};  /* typedef'd tp ZSTDv07_CDict within zstd.h */ 
+ 
 static ZSTDv07_DDict* ZSTDv07_createDDict_advanced(const void* dict, size_t dictSize, ZSTDv07_customMem customMem)
-{
-    if (!customMem.customAlloc && !customMem.customFree)
-        customMem = defaultCustomMem;
-
-    if (!customMem.customAlloc || !customMem.customFree)
-        return NULL;
-
-    {   ZSTDv07_DDict* const ddict = (ZSTDv07_DDict*) customMem.customAlloc(customMem.opaque, sizeof(*ddict));
-        void* const dictContent = customMem.customAlloc(customMem.opaque, dictSize);
-        ZSTDv07_DCtx* const dctx = ZSTDv07_createDCtx_advanced(customMem);
-
-        if (!dictContent || !ddict || !dctx) {
-            customMem.customFree(customMem.opaque, dictContent);
-            customMem.customFree(customMem.opaque, ddict);
-            customMem.customFree(customMem.opaque, dctx);
-            return NULL;
-        }
-
-        memcpy(dictContent, dict, dictSize);
-        {   size_t const errorCode = ZSTDv07_decompressBegin_usingDict(dctx, dictContent, dictSize);
-            if (ZSTDv07_isError(errorCode)) {
-                customMem.customFree(customMem.opaque, dictContent);
-                customMem.customFree(customMem.opaque, ddict);
-                customMem.customFree(customMem.opaque, dctx);
-                return NULL;
-        }   }
-
-        ddict->dict = dictContent;
-        ddict->dictSize = dictSize;
-        ddict->refContext = dctx;
-        return ddict;
-    }
-}
-
-/*! ZSTDv07_createDDict() :
-*   Create a digested dictionary, ready to start decompression without startup delay.
-*   `dict` can be released after `ZSTDv07_DDict` creation */
-ZSTDv07_DDict* ZSTDv07_createDDict(const void* dict, size_t dictSize)
-{
-    ZSTDv07_customMem const allocator = { NULL, NULL, NULL };
-    return ZSTDv07_createDDict_advanced(dict, dictSize, allocator);
-}
-
-size_t ZSTDv07_freeDDict(ZSTDv07_DDict* ddict)
-{
-    ZSTDv07_freeFunction const cFree = ddict->refContext->customMem.customFree;
-    void* const opaque = ddict->refContext->customMem.opaque;
-    ZSTDv07_freeDCtx(ddict->refContext);
-    cFree(opaque, ddict->dict);
-    cFree(opaque, ddict);
-    return 0;
-}
-
-/*! ZSTDv07_decompress_usingDDict() :
-*   Decompression using a pre-digested Dictionary
-*   Use dictionary without significant overhead. */
+{ 
+    if (!customMem.customAlloc && !customMem.customFree) 
+        customMem = defaultCustomMem; 
+ 
+    if (!customMem.customAlloc || !customMem.customFree) 
+        return NULL; 
+ 
+    {   ZSTDv07_DDict* const ddict = (ZSTDv07_DDict*) customMem.customAlloc(customMem.opaque, sizeof(*ddict)); 
+        void* const dictContent = customMem.customAlloc(customMem.opaque, dictSize); 
+        ZSTDv07_DCtx* const dctx = ZSTDv07_createDCtx_advanced(customMem); 
+ 
+        if (!dictContent || !ddict || !dctx) { 
+            customMem.customFree(customMem.opaque, dictContent); 
+            customMem.customFree(customMem.opaque, ddict); 
+            customMem.customFree(customMem.opaque, dctx); 
+            return NULL; 
+        } 
+ 
+        memcpy(dictContent, dict, dictSize); 
+        {   size_t const errorCode = ZSTDv07_decompressBegin_usingDict(dctx, dictContent, dictSize); 
+            if (ZSTDv07_isError(errorCode)) { 
+                customMem.customFree(customMem.opaque, dictContent); 
+                customMem.customFree(customMem.opaque, ddict); 
+                customMem.customFree(customMem.opaque, dctx); 
+                return NULL; 
+        }   } 
+ 
+        ddict->dict = dictContent; 
+        ddict->dictSize = dictSize; 
+        ddict->refContext = dctx; 
+        return ddict; 
+    } 
+} 
+ 
+/*! ZSTDv07_createDDict() : 
+*   Create a digested dictionary, ready to start decompression without startup delay. 
+*   `dict` can be released after `ZSTDv07_DDict` creation */ 
+ZSTDv07_DDict* ZSTDv07_createDDict(const void* dict, size_t dictSize) 
+{ 
+    ZSTDv07_customMem const allocator = { NULL, NULL, NULL }; 
+    return ZSTDv07_createDDict_advanced(dict, dictSize, allocator); 
+} 
+ 
+size_t ZSTDv07_freeDDict(ZSTDv07_DDict* ddict) 
+{ 
+    ZSTDv07_freeFunction const cFree = ddict->refContext->customMem.customFree; 
+    void* const opaque = ddict->refContext->customMem.opaque; 
+    ZSTDv07_freeDCtx(ddict->refContext); 
+    cFree(opaque, ddict->dict); 
+    cFree(opaque, ddict); 
+    return 0; 
+} 
+ 
+/*! ZSTDv07_decompress_usingDDict() : 
+*   Decompression using a pre-digested Dictionary 
+*   Use dictionary without significant overhead. */ 
 ZSTDLIBv07_API size_t ZSTDv07_decompress_usingDDict(ZSTDv07_DCtx* dctx,
-                                           void* dst, size_t dstCapacity,
-                                     const void* src, size_t srcSize,
-                                     const ZSTDv07_DDict* ddict)
-{
-    return ZSTDv07_decompress_usingPreparedDCtx(dctx, ddict->refContext,
-                                           dst, dstCapacity,
-                                           src, srcSize);
-}
-/*
-    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/
-*/
-
-
-
-/*-***************************************************************************
-*  Streaming decompression howto
-*
-*  A ZBUFFv07_DCtx object is required to track streaming operations.
-*  Use ZBUFFv07_createDCtx() and ZBUFFv07_freeDCtx() to create/release resources.
-*  Use ZBUFFv07_decompressInit() to start a new decompression operation,
-*   or ZBUFFv07_decompressInitDictionary() if decompression requires a dictionary.
-*  Note that ZBUFFv07_DCtx objects can be re-init multiple times.
-*
-*  Use ZBUFFv07_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 ZBUFFv07_isError().
-*
-*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv07_recommendedDInSize() and ZBUFFv07_recommendedDOutSize()
-*  output : ZBUFFv07_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
-*  input  : ZBUFFv07_recommendedDInSize == 128KB + 3;
-*           just follow indications from ZBUFFv07_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
-* *******************************************************************************/
-
-typedef enum { ZBUFFds_init, ZBUFFds_loadHeader,
-               ZBUFFds_read, ZBUFFds_load, ZBUFFds_flush } ZBUFFv07_dStage;
-
-/* *** Resource management *** */
-struct ZBUFFv07_DCtx_s {
-    ZSTDv07_DCtx* zd;
-    ZSTDv07_frameParams fParams;
-    ZBUFFv07_dStage stage;
-    char*  inBuff;
-    size_t inBuffSize;
-    size_t inPos;
-    char*  outBuff;
-    size_t outBuffSize;
-    size_t outStart;
-    size_t outEnd;
-    size_t blockSize;
-    BYTE headerBuffer[ZSTDv07_FRAMEHEADERSIZE_MAX];
-    size_t lhSize;
-    ZSTDv07_customMem customMem;
-};   /* typedef'd to ZBUFFv07_DCtx within "zstd_buffered.h" */
-
+                                           void* dst, size_t dstCapacity, 
+                                     const void* src, size_t srcSize, 
+                                     const ZSTDv07_DDict* ddict) 
+{ 
+    return ZSTDv07_decompress_usingPreparedDCtx(dctx, ddict->refContext, 
+                                           dst, dstCapacity, 
+                                           src, srcSize); 
+} 
+/* 
+    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/ 
+*/ 
+ 
+ 
+ 
+/*-*************************************************************************** 
+*  Streaming decompression howto 
+* 
+*  A ZBUFFv07_DCtx object is required to track streaming operations. 
+*  Use ZBUFFv07_createDCtx() and ZBUFFv07_freeDCtx() to create/release resources. 
+*  Use ZBUFFv07_decompressInit() to start a new decompression operation, 
+*   or ZBUFFv07_decompressInitDictionary() if decompression requires a dictionary. 
+*  Note that ZBUFFv07_DCtx objects can be re-init multiple times. 
+* 
+*  Use ZBUFFv07_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 ZBUFFv07_isError(). 
+* 
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv07_recommendedDInSize() and ZBUFFv07_recommendedDOutSize() 
+*  output : ZBUFFv07_recommendedDOutSize==128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded. 
+*  input  : ZBUFFv07_recommendedDInSize == 128KB + 3; 
+*           just follow indications from ZBUFFv07_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 . 
+* *******************************************************************************/ 
+ 
+typedef enum { ZBUFFds_init, ZBUFFds_loadHeader, 
+               ZBUFFds_read, ZBUFFds_load, ZBUFFds_flush } ZBUFFv07_dStage; 
+ 
+/* *** Resource management *** */ 
+struct ZBUFFv07_DCtx_s { 
+    ZSTDv07_DCtx* zd; 
+    ZSTDv07_frameParams fParams; 
+    ZBUFFv07_dStage stage; 
+    char*  inBuff; 
+    size_t inBuffSize; 
+    size_t inPos; 
+    char*  outBuff; 
+    size_t outBuffSize; 
+    size_t outStart; 
+    size_t outEnd; 
+    size_t blockSize; 
+    BYTE headerBuffer[ZSTDv07_FRAMEHEADERSIZE_MAX]; 
+    size_t lhSize; 
+    ZSTDv07_customMem customMem; 
+};   /* typedef'd to ZBUFFv07_DCtx within "zstd_buffered.h" */ 
+ 
 ZSTDLIBv07_API ZBUFFv07_DCtx* ZBUFFv07_createDCtx_advanced(ZSTDv07_customMem customMem);
-
-ZBUFFv07_DCtx* ZBUFFv07_createDCtx(void)
-{
-    return ZBUFFv07_createDCtx_advanced(defaultCustomMem);
-}
-
-ZBUFFv07_DCtx* ZBUFFv07_createDCtx_advanced(ZSTDv07_customMem customMem)
-{
-    ZBUFFv07_DCtx* zbd;
-
-    if (!customMem.customAlloc && !customMem.customFree)
-        customMem = defaultCustomMem;
-
-    if (!customMem.customAlloc || !customMem.customFree)
-        return NULL;
-
-    zbd = (ZBUFFv07_DCtx*)customMem.customAlloc(customMem.opaque, sizeof(ZBUFFv07_DCtx));
-    if (zbd==NULL) return NULL;
-    memset(zbd, 0, sizeof(ZBUFFv07_DCtx));
-    memcpy(&zbd->customMem, &customMem, sizeof(ZSTDv07_customMem));
-    zbd->zd = ZSTDv07_createDCtx_advanced(customMem);
-    if (zbd->zd == NULL) { ZBUFFv07_freeDCtx(zbd); return NULL; }
-    zbd->stage = ZBUFFds_init;
-    return zbd;
-}
-
-size_t ZBUFFv07_freeDCtx(ZBUFFv07_DCtx* zbd)
-{
-    if (zbd==NULL) return 0;   /* support free on null */
-    ZSTDv07_freeDCtx(zbd->zd);
-    if (zbd->inBuff) zbd->customMem.customFree(zbd->customMem.opaque, zbd->inBuff);
-    if (zbd->outBuff) zbd->customMem.customFree(zbd->customMem.opaque, zbd->outBuff);
-    zbd->customMem.customFree(zbd->customMem.opaque, zbd);
-    return 0;
-}
-
-
-/* *** Initialization *** */
-
-size_t ZBUFFv07_decompressInitDictionary(ZBUFFv07_DCtx* zbd, const void* dict, size_t dictSize)
-{
-    zbd->stage = ZBUFFds_loadHeader;
-    zbd->lhSize = zbd->inPos = zbd->outStart = zbd->outEnd = 0;
-    return ZSTDv07_decompressBegin_usingDict(zbd->zd, dict, dictSize);
-}
-
-size_t ZBUFFv07_decompressInit(ZBUFFv07_DCtx* zbd)
-{
-    return ZBUFFv07_decompressInitDictionary(zbd, NULL, 0);
-}
-
-
-/* internal util function */
-MEM_STATIC size_t ZBUFFv07_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
-{
-    size_t const length = MIN(dstCapacity, srcSize);
+ 
+ZBUFFv07_DCtx* ZBUFFv07_createDCtx(void) 
+{ 
+    return ZBUFFv07_createDCtx_advanced(defaultCustomMem); 
+} 
+ 
+ZBUFFv07_DCtx* ZBUFFv07_createDCtx_advanced(ZSTDv07_customMem customMem) 
+{ 
+    ZBUFFv07_DCtx* zbd; 
+ 
+    if (!customMem.customAlloc && !customMem.customFree) 
+        customMem = defaultCustomMem; 
+ 
+    if (!customMem.customAlloc || !customMem.customFree) 
+        return NULL; 
+ 
+    zbd = (ZBUFFv07_DCtx*)customMem.customAlloc(customMem.opaque, sizeof(ZBUFFv07_DCtx)); 
+    if (zbd==NULL) return NULL; 
+    memset(zbd, 0, sizeof(ZBUFFv07_DCtx)); 
+    memcpy(&zbd->customMem, &customMem, sizeof(ZSTDv07_customMem)); 
+    zbd->zd = ZSTDv07_createDCtx_advanced(customMem); 
+    if (zbd->zd == NULL) { ZBUFFv07_freeDCtx(zbd); return NULL; } 
+    zbd->stage = ZBUFFds_init; 
+    return zbd; 
+} 
+ 
+size_t ZBUFFv07_freeDCtx(ZBUFFv07_DCtx* zbd) 
+{ 
+    if (zbd==NULL) return 0;   /* support free on null */ 
+    ZSTDv07_freeDCtx(zbd->zd); 
+    if (zbd->inBuff) zbd->customMem.customFree(zbd->customMem.opaque, zbd->inBuff); 
+    if (zbd->outBuff) zbd->customMem.customFree(zbd->customMem.opaque, zbd->outBuff); 
+    zbd->customMem.customFree(zbd->customMem.opaque, zbd); 
+    return 0; 
+} 
+ 
+ 
+/* *** Initialization *** */ 
+ 
+size_t ZBUFFv07_decompressInitDictionary(ZBUFFv07_DCtx* zbd, const void* dict, size_t dictSize) 
+{ 
+    zbd->stage = ZBUFFds_loadHeader; 
+    zbd->lhSize = zbd->inPos = zbd->outStart = zbd->outEnd = 0; 
+    return ZSTDv07_decompressBegin_usingDict(zbd->zd, dict, dictSize); 
+} 
+ 
+size_t ZBUFFv07_decompressInit(ZBUFFv07_DCtx* zbd) 
+{ 
+    return ZBUFFv07_decompressInitDictionary(zbd, NULL, 0); 
+} 
+ 
+ 
+/* internal util function */ 
+MEM_STATIC size_t ZBUFFv07_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize) 
+{ 
+    size_t const length = MIN(dstCapacity, srcSize); 
     if (length > 0) {
         memcpy(dst, src, length);
     }
-    return length;
-}
-
-
-/* *** Decompression *** */
-
-size_t ZBUFFv07_decompressContinue(ZBUFFv07_DCtx* zbd,
-                                void* dst, size_t* dstCapacityPtr,
-                          const void* src, size_t* srcSizePtr)
-{
-    const char* const istart = (const char*)src;
-    const char* const iend = istart + *srcSizePtr;
-    const char* ip = istart;
-    char* const ostart = (char*)dst;
-    char* const oend = ostart + *dstCapacityPtr;
-    char* op = ostart;
-    U32 notDone = 1;
-
-    while (notDone) {
-        switch(zbd->stage)
-        {
-        case ZBUFFds_init :
-            return ERROR(init_missing);
-
-        case ZBUFFds_loadHeader :
-            {   size_t const hSize = ZSTDv07_getFrameParams(&(zbd->fParams), zbd->headerBuffer, zbd->lhSize);
+    return length; 
+} 
+ 
+ 
+/* *** Decompression *** */ 
+ 
+size_t ZBUFFv07_decompressContinue(ZBUFFv07_DCtx* zbd, 
+                                void* dst, size_t* dstCapacityPtr, 
+                          const void* src, size_t* srcSizePtr) 
+{ 
+    const char* const istart = (const char*)src; 
+    const char* const iend = istart + *srcSizePtr; 
+    const char* ip = istart; 
+    char* const ostart = (char*)dst; 
+    char* const oend = ostart + *dstCapacityPtr; 
+    char* op = ostart; 
+    U32 notDone = 1; 
+ 
+    while (notDone) { 
+        switch(zbd->stage) 
+        { 
+        case ZBUFFds_init : 
+            return ERROR(init_missing); 
+ 
+        case ZBUFFds_loadHeader : 
+            {   size_t const hSize = ZSTDv07_getFrameParams(&(zbd->fParams), zbd->headerBuffer, zbd->lhSize); 
                 if (ZSTDv07_isError(hSize)) return hSize;
-                if (hSize != 0) {
-                    size_t const toLoad = hSize - zbd->lhSize;   /* if hSize!=0, hSize > zbd->lhSize */
-                    if (toLoad > (size_t)(iend-ip)) {   /* not enough input to load full header */
-                        memcpy(zbd->headerBuffer + zbd->lhSize, ip, iend-ip);
-                        zbd->lhSize += iend-ip;
-                        *dstCapacityPtr = 0;
-                        return (hSize - zbd->lhSize) + ZSTDv07_blockHeaderSize;   /* remaining header bytes + next block header */
-                    }
-                    memcpy(zbd->headerBuffer + zbd->lhSize, ip, toLoad); zbd->lhSize = hSize; ip += toLoad;
-                    break;
-            }   }
-
-            /* Consume header */
-            {   size_t const h1Size = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);  /* == ZSTDv07_frameHeaderSize_min */
-                size_t const h1Result = ZSTDv07_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer, h1Size);
-                if (ZSTDv07_isError(h1Result)) return h1Result;
-                if (h1Size < zbd->lhSize) {   /* long header */
-                    size_t const h2Size = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);
-                    size_t const h2Result = ZSTDv07_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer+h1Size, h2Size);
-                    if (ZSTDv07_isError(h2Result)) return h2Result;
-            }   }
-
-            zbd->fParams.windowSize = MAX(zbd->fParams.windowSize, 1U << ZSTDv07_WINDOWLOG_ABSOLUTEMIN);
-
-            /* Frame header instruct buffer sizes */
-            {   size_t const blockSize = MIN(zbd->fParams.windowSize, ZSTDv07_BLOCKSIZE_ABSOLUTEMAX);
-                zbd->blockSize = blockSize;
-                if (zbd->inBuffSize < blockSize) {
-                    zbd->customMem.customFree(zbd->customMem.opaque, zbd->inBuff);
-                    zbd->inBuffSize = blockSize;
-                    zbd->inBuff = (char*)zbd->customMem.customAlloc(zbd->customMem.opaque, blockSize);
-                    if (zbd->inBuff == NULL) return ERROR(memory_allocation);
-                }
+                if (hSize != 0) { 
+                    size_t const toLoad = hSize - zbd->lhSize;   /* if hSize!=0, hSize > zbd->lhSize */ 
+                    if (toLoad > (size_t)(iend-ip)) {   /* not enough input to load full header */ 
+                        memcpy(zbd->headerBuffer + zbd->lhSize, ip, iend-ip); 
+                        zbd->lhSize += iend-ip; 
+                        *dstCapacityPtr = 0; 
+                        return (hSize - zbd->lhSize) + ZSTDv07_blockHeaderSize;   /* remaining header bytes + next block header */ 
+                    } 
+                    memcpy(zbd->headerBuffer + zbd->lhSize, ip, toLoad); zbd->lhSize = hSize; ip += toLoad; 
+                    break; 
+            }   } 
+ 
+            /* Consume header */ 
+            {   size_t const h1Size = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);  /* == ZSTDv07_frameHeaderSize_min */ 
+                size_t const h1Result = ZSTDv07_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer, h1Size); 
+                if (ZSTDv07_isError(h1Result)) return h1Result; 
+                if (h1Size < zbd->lhSize) {   /* long header */ 
+                    size_t const h2Size = ZSTDv07_nextSrcSizeToDecompress(zbd->zd); 
+                    size_t const h2Result = ZSTDv07_decompressContinue(zbd->zd, NULL, 0, zbd->headerBuffer+h1Size, h2Size); 
+                    if (ZSTDv07_isError(h2Result)) return h2Result; 
+            }   } 
+ 
+            zbd->fParams.windowSize = MAX(zbd->fParams.windowSize, 1U << ZSTDv07_WINDOWLOG_ABSOLUTEMIN); 
+ 
+            /* Frame header instruct buffer sizes */ 
+            {   size_t const blockSize = MIN(zbd->fParams.windowSize, ZSTDv07_BLOCKSIZE_ABSOLUTEMAX); 
+                zbd->blockSize = blockSize; 
+                if (zbd->inBuffSize < blockSize) { 
+                    zbd->customMem.customFree(zbd->customMem.opaque, zbd->inBuff); 
+                    zbd->inBuffSize = blockSize; 
+                    zbd->inBuff = (char*)zbd->customMem.customAlloc(zbd->customMem.opaque, blockSize); 
+                    if (zbd->inBuff == NULL) return ERROR(memory_allocation); 
+                } 
                 {   size_t const neededOutSize = zbd->fParams.windowSize + blockSize + WILDCOPY_OVERLENGTH * 2;
-                    if (zbd->outBuffSize < neededOutSize) {
-                        zbd->customMem.customFree(zbd->customMem.opaque, zbd->outBuff);
-                        zbd->outBuffSize = neededOutSize;
-                        zbd->outBuff = (char*)zbd->customMem.customAlloc(zbd->customMem.opaque, neededOutSize);
-                        if (zbd->outBuff == NULL) return ERROR(memory_allocation);
-            }   }   }
-            zbd->stage = ZBUFFds_read;
+                    if (zbd->outBuffSize < neededOutSize) { 
+                        zbd->customMem.customFree(zbd->customMem.opaque, zbd->outBuff); 
+                        zbd->outBuffSize = neededOutSize; 
+                        zbd->outBuff = (char*)zbd->customMem.customAlloc(zbd->customMem.opaque, neededOutSize); 
+                        if (zbd->outBuff == NULL) return ERROR(memory_allocation); 
+            }   }   } 
+            zbd->stage = ZBUFFds_read; 
             /* pass-through */
 	    /* fall-through */
-        case ZBUFFds_read:
-            {   size_t const neededInSize = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);
-                if (neededInSize==0) {  /* end of frame */
-                    zbd->stage = ZBUFFds_init;
-                    notDone = 0;
-                    break;
-                }
-                if ((size_t)(iend-ip) >= neededInSize) {  /* decode directly from src */
-                    const int isSkipFrame = ZSTDv07_isSkipFrame(zbd->zd);
-                    size_t const decodedSize = ZSTDv07_decompressContinue(zbd->zd,
-                        zbd->outBuff + zbd->outStart, (isSkipFrame ? 0 : zbd->outBuffSize - zbd->outStart),
-                        ip, neededInSize);
-                    if (ZSTDv07_isError(decodedSize)) return decodedSize;
-                    ip += neededInSize;
-                    if (!decodedSize && !isSkipFrame) break;   /* this was just a header */
-                    zbd->outEnd = zbd->outStart +  decodedSize;
-                    zbd->stage = ZBUFFds_flush;
-                    break;
-                }
-                if (ip==iend) { notDone = 0; break; }   /* no more input */
-                zbd->stage = ZBUFFds_load;
-            }
+        case ZBUFFds_read: 
+            {   size_t const neededInSize = ZSTDv07_nextSrcSizeToDecompress(zbd->zd); 
+                if (neededInSize==0) {  /* end of frame */ 
+                    zbd->stage = ZBUFFds_init; 
+                    notDone = 0; 
+                    break; 
+                } 
+                if ((size_t)(iend-ip) >= neededInSize) {  /* decode directly from src */ 
+                    const int isSkipFrame = ZSTDv07_isSkipFrame(zbd->zd); 
+                    size_t const decodedSize = ZSTDv07_decompressContinue(zbd->zd, 
+                        zbd->outBuff + zbd->outStart, (isSkipFrame ? 0 : zbd->outBuffSize - zbd->outStart), 
+                        ip, neededInSize); 
+                    if (ZSTDv07_isError(decodedSize)) return decodedSize; 
+                    ip += neededInSize; 
+                    if (!decodedSize && !isSkipFrame) break;   /* this was just a header */ 
+                    zbd->outEnd = zbd->outStart +  decodedSize; 
+                    zbd->stage = ZBUFFds_flush; 
+                    break; 
+                } 
+                if (ip==iend) { notDone = 0; break; }   /* no more input */ 
+                zbd->stage = ZBUFFds_load; 
+            } 
 	    /* fall-through */
-        case ZBUFFds_load:
-            {   size_t const neededInSize = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);
-                size_t const toLoad = neededInSize - zbd->inPos;   /* should always be <= remaining space within inBuff */
-                size_t loadedSize;
-                if (toLoad > zbd->inBuffSize - zbd->inPos) return ERROR(corruption_detected);   /* should never happen */
-                loadedSize = ZBUFFv07_limitCopy(zbd->inBuff + zbd->inPos, toLoad, ip, iend-ip);
-                ip += loadedSize;
-                zbd->inPos += loadedSize;
-                if (loadedSize < toLoad) { notDone = 0; break; }   /* not enough input, wait for more */
-
-                /* decode loaded input */
-                {  const int isSkipFrame = ZSTDv07_isSkipFrame(zbd->zd);
-                   size_t const decodedSize = ZSTDv07_decompressContinue(zbd->zd,
-                        zbd->outBuff + zbd->outStart, zbd->outBuffSize - zbd->outStart,
-                        zbd->inBuff, neededInSize);
-                    if (ZSTDv07_isError(decodedSize)) return decodedSize;
-                    zbd->inPos = 0;   /* input is consumed */
-                    if (!decodedSize && !isSkipFrame) { zbd->stage = ZBUFFds_read; break; }   /* this was just a header */
-                    zbd->outEnd = zbd->outStart +  decodedSize;
-                    zbd->stage = ZBUFFds_flush;
+        case ZBUFFds_load: 
+            {   size_t const neededInSize = ZSTDv07_nextSrcSizeToDecompress(zbd->zd); 
+                size_t const toLoad = neededInSize - zbd->inPos;   /* should always be <= remaining space within inBuff */ 
+                size_t loadedSize; 
+                if (toLoad > zbd->inBuffSize - zbd->inPos) return ERROR(corruption_detected);   /* should never happen */ 
+                loadedSize = ZBUFFv07_limitCopy(zbd->inBuff + zbd->inPos, toLoad, ip, iend-ip); 
+                ip += loadedSize; 
+                zbd->inPos += loadedSize; 
+                if (loadedSize < toLoad) { notDone = 0; break; }   /* not enough input, wait for more */ 
+ 
+                /* decode loaded input */ 
+                {  const int isSkipFrame = ZSTDv07_isSkipFrame(zbd->zd); 
+                   size_t const decodedSize = ZSTDv07_decompressContinue(zbd->zd, 
+                        zbd->outBuff + zbd->outStart, zbd->outBuffSize - zbd->outStart, 
+                        zbd->inBuff, neededInSize); 
+                    if (ZSTDv07_isError(decodedSize)) return decodedSize; 
+                    zbd->inPos = 0;   /* input is consumed */ 
+                    if (!decodedSize && !isSkipFrame) { zbd->stage = ZBUFFds_read; break; }   /* this was just a header */ 
+                    zbd->outEnd = zbd->outStart +  decodedSize; 
+                    zbd->stage = ZBUFFds_flush; 
                     /* break; */
                     /* pass-through */
                 }
 	    }
 	    /* fall-through */
-        case ZBUFFds_flush:
-            {   size_t const toFlushSize = zbd->outEnd - zbd->outStart;
-                size_t const flushedSize = ZBUFFv07_limitCopy(op, oend-op, zbd->outBuff + zbd->outStart, toFlushSize);
-                op += flushedSize;
-                zbd->outStart += flushedSize;
-                if (flushedSize == toFlushSize) {
-                    zbd->stage = ZBUFFds_read;
-                    if (zbd->outStart + zbd->blockSize > zbd->outBuffSize)
-                        zbd->outStart = zbd->outEnd = 0;
-                    break;
-                }
-                /* cannot flush everything */
-                notDone = 0;
-                break;
-            }
-        default: return ERROR(GENERIC);   /* impossible */
-    }   }
-
-    /* result */
-    *srcSizePtr = ip-istart;
-    *dstCapacityPtr = op-ostart;
-    {   size_t nextSrcSizeHint = ZSTDv07_nextSrcSizeToDecompress(zbd->zd);
-        nextSrcSizeHint -= zbd->inPos;   /* already loaded*/
-        return nextSrcSizeHint;
-    }
-}
-
-
-
-/* *************************************
-*  Tool functions
-***************************************/
-size_t ZBUFFv07_recommendedDInSize(void)  { return ZSTDv07_BLOCKSIZE_ABSOLUTEMAX + ZSTDv07_blockHeaderSize /* block header size*/ ; }
-size_t ZBUFFv07_recommendedDOutSize(void) { return ZSTDv07_BLOCKSIZE_ABSOLUTEMAX; }
+        case ZBUFFds_flush: 
+            {   size_t const toFlushSize = zbd->outEnd - zbd->outStart; 
+                size_t const flushedSize = ZBUFFv07_limitCopy(op, oend-op, zbd->outBuff + zbd->outStart, toFlushSize); 
+                op += flushedSize; 
+                zbd->outStart += flushedSize; 
+                if (flushedSize == toFlushSize) { 
+                    zbd->stage = ZBUFFds_read; 
+                    if (zbd->outStart + zbd->blockSize > zbd->outBuffSize) 
+                        zbd->outStart = zbd->outEnd = 0; 
+                    break; 
+                } 
+                /* cannot flush everything */ 
+                notDone = 0; 
+                break; 
+            } 
+        default: return ERROR(GENERIC);   /* impossible */ 
+    }   } 
+ 
+    /* result */ 
+    *srcSizePtr = ip-istart; 
+    *dstCapacityPtr = op-ostart; 
+    {   size_t nextSrcSizeHint = ZSTDv07_nextSrcSizeToDecompress(zbd->zd); 
+        nextSrcSizeHint -= zbd->inPos;   /* already loaded*/ 
+        return nextSrcSizeHint; 
+    } 
+} 
+ 
+ 
+ 
+/* ************************************* 
+*  Tool functions 
+***************************************/ 
+size_t ZBUFFv07_recommendedDInSize(void)  { return ZSTDv07_BLOCKSIZE_ABSOLUTEMAX + ZSTDv07_blockHeaderSize /* block header size*/ ; } 
+size_t ZBUFFv07_recommendedDOutSize(void) { return ZSTDv07_BLOCKSIZE_ABSOLUTEMAX; } 
diff --git a/contrib/libs/zstd/lib/legacy/zstd_v07.h b/contrib/libs/zstd/lib/legacy/zstd_v07.h
index bc35cfa6a3..aa87ecb67c 100644
--- a/contrib/libs/zstd/lib/legacy/zstd_v07.h
+++ b/contrib/libs/zstd/lib/legacy/zstd_v07.h
@@ -7,48 +7,48 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
-#ifndef ZSTDv07_H_235446
-#define ZSTDv07_H_235446
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/*======  Dependency  ======*/
-#include <stddef.h>   /* size_t */
-
-
-/*======  Export for Windows  ======*/
-/*!
-*  ZSTDv07_DLL_EXPORT :
-*  Enable exporting of functions when building a Windows DLL
-*/
-#if defined(_WIN32) && defined(ZSTDv07_DLL_EXPORT) && (ZSTDv07_DLL_EXPORT==1)
+ 
+#ifndef ZSTDv07_H_235446 
+#define ZSTDv07_H_235446 
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
+/*======  Dependency  ======*/ 
+#include <stddef.h>   /* size_t */ 
+ 
+ 
+/*======  Export for Windows  ======*/ 
+/*! 
+*  ZSTDv07_DLL_EXPORT : 
+*  Enable exporting of functions when building a Windows DLL 
+*/ 
+#if defined(_WIN32) && defined(ZSTDv07_DLL_EXPORT) && (ZSTDv07_DLL_EXPORT==1) 
 #  define ZSTDLIBv07_API __declspec(dllexport)
-#else
+#else 
 #  define ZSTDLIBv07_API
-#endif
-
-
-/* *************************************
-*  Simple API
-***************************************/
-/*! ZSTDv07_getDecompressedSize() :
-*   @return : decompressed size if known, 0 otherwise.
-       note 1 : if `0`, follow up with ZSTDv07_getFrameParams() to know precise failure cause.
-       note 2 : decompressed size could be wrong or intentionally modified !
-                always ensure results fit within application's authorized limits */
-unsigned long long ZSTDv07_getDecompressedSize(const void* src, size_t srcSize);
-
-/*! ZSTDv07_decompress() :
-    `compressedSize` : must be _exact_ size of compressed input, otherwise decompression will fail.
-    `dstCapacity` must be 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 ZSTDv07_isError()) */
+#endif 
+ 
+ 
+/* ************************************* 
+*  Simple API 
+***************************************/ 
+/*! ZSTDv07_getDecompressedSize() : 
+*   @return : decompressed size if known, 0 otherwise. 
+       note 1 : if `0`, follow up with ZSTDv07_getFrameParams() to know precise failure cause. 
+       note 2 : decompressed size could be wrong or intentionally modified ! 
+                always ensure results fit within application's authorized limits */ 
+unsigned long long ZSTDv07_getDecompressedSize(const void* src, size_t srcSize); 
+ 
+/*! ZSTDv07_decompress() : 
+    `compressedSize` : must be _exact_ size of compressed input, otherwise decompression will fail. 
+    `dstCapacity` must be 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 ZSTDv07_isError()) */ 
 ZSTDLIBv07_API size_t ZSTDv07_decompress( void* dst, size_t dstCapacity,
                                     const void* src, size_t compressedSize);
-
+ 
 /**
 ZSTDv07_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.7.x format
     srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'
@@ -62,126 +62,126 @@ ZSTDv07_findFrameSizeInfoLegacy() : get the source length and decompressed bound
 void ZSTDv07_findFrameSizeInfoLegacy(const void *src, size_t srcSize,
                                      size_t* cSize, unsigned long long* dBound);
 
-/*======  Helper functions  ======*/
+/*======  Helper functions  ======*/ 
 ZSTDLIBv07_API unsigned    ZSTDv07_isError(size_t code);          /*!< tells if a `size_t` function result is an error code */
 ZSTDLIBv07_API const char* ZSTDv07_getErrorName(size_t code);     /*!< provides readable string from an error code */
-
-
-/*-*************************************
-*  Explicit memory management
-***************************************/
-/** Decompression context */
-typedef struct ZSTDv07_DCtx_s ZSTDv07_DCtx;
+ 
+ 
+/*-************************************* 
+*  Explicit memory management 
+***************************************/ 
+/** Decompression context */ 
+typedef struct ZSTDv07_DCtx_s ZSTDv07_DCtx; 
 ZSTDLIBv07_API ZSTDv07_DCtx* ZSTDv07_createDCtx(void);
 ZSTDLIBv07_API size_t     ZSTDv07_freeDCtx(ZSTDv07_DCtx* dctx);      /*!< @return : errorCode */
-
-/** ZSTDv07_decompressDCtx() :
-*   Same as ZSTDv07_decompress(), requires an allocated ZSTDv07_DCtx (see ZSTDv07_createDCtx()) */
+ 
+/** ZSTDv07_decompressDCtx() : 
+*   Same as ZSTDv07_decompress(), requires an allocated ZSTDv07_DCtx (see ZSTDv07_createDCtx()) */ 
 ZSTDLIBv07_API size_t ZSTDv07_decompressDCtx(ZSTDv07_DCtx* ctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
-
-/*-************************
-*  Simple dictionary API
-***************************/
-/*! ZSTDv07_decompress_usingDict() :
-*   Decompression using a pre-defined Dictionary content (see dictBuilder).
-*   Dictionary must be identical to the one used during compression.
-*   Note : This function load the dictionary, resulting in a significant startup time */
+ 
+ 
+/*-************************ 
+*  Simple dictionary API 
+***************************/ 
+/*! ZSTDv07_decompress_usingDict() : 
+*   Decompression using a pre-defined Dictionary content (see dictBuilder). 
+*   Dictionary must be identical to the one used during compression. 
+*   Note : This function load the dictionary, resulting in a significant startup time */ 
 ZSTDLIBv07_API size_t ZSTDv07_decompress_usingDict(ZSTDv07_DCtx* dctx,
                                                    void* dst, size_t dstCapacity,
                                              const void* src, size_t srcSize,
                                              const void* dict,size_t dictSize);
-
-
-/*-**************************
-*  Advanced Dictionary API
-****************************/
-/*! ZSTDv07_createDDict() :
-*   Create a digested dictionary, ready to start decompression operation without startup delay.
-*   `dict` can be released after creation */
-typedef struct ZSTDv07_DDict_s ZSTDv07_DDict;
+ 
+ 
+/*-************************** 
+*  Advanced Dictionary API 
+****************************/ 
+/*! ZSTDv07_createDDict() : 
+*   Create a digested dictionary, ready to start decompression operation without startup delay. 
+*   `dict` can be released after creation */ 
+typedef struct ZSTDv07_DDict_s ZSTDv07_DDict; 
 ZSTDLIBv07_API ZSTDv07_DDict* ZSTDv07_createDDict(const void* dict, size_t dictSize);
 ZSTDLIBv07_API size_t      ZSTDv07_freeDDict(ZSTDv07_DDict* ddict);
-
-/*! ZSTDv07_decompress_usingDDict() :
-*   Decompression using a pre-digested Dictionary
-*   Faster startup than ZSTDv07_decompress_usingDict(), recommended when same dictionary is used multiple times. */
+ 
+/*! ZSTDv07_decompress_usingDDict() : 
+*   Decompression using a pre-digested Dictionary 
+*   Faster startup than ZSTDv07_decompress_usingDict(), recommended when same dictionary is used multiple times. */ 
 ZSTDLIBv07_API size_t ZSTDv07_decompress_usingDDict(ZSTDv07_DCtx* dctx,
                                                     void* dst, size_t dstCapacity,
                                               const void* src, size_t srcSize,
                                               const ZSTDv07_DDict* ddict);
-
-typedef struct {
-    unsigned long long frameContentSize;
-    unsigned windowSize;
-    unsigned dictID;
-    unsigned checksumFlag;
-} ZSTDv07_frameParams;
-
+ 
+typedef struct { 
+    unsigned long long frameContentSize; 
+    unsigned windowSize; 
+    unsigned dictID; 
+    unsigned checksumFlag; 
+} ZSTDv07_frameParams; 
+ 
 ZSTDLIBv07_API size_t ZSTDv07_getFrameParams(ZSTDv07_frameParams* fparamsPtr, const void* src, size_t srcSize);   /**< doesn't consume input */
-
-
-
-
-/* *************************************
-*  Streaming functions
-***************************************/
-typedef struct ZBUFFv07_DCtx_s ZBUFFv07_DCtx;
+ 
+ 
+ 
+ 
+/* ************************************* 
+*  Streaming functions 
+***************************************/ 
+typedef struct ZBUFFv07_DCtx_s ZBUFFv07_DCtx; 
 ZSTDLIBv07_API ZBUFFv07_DCtx* ZBUFFv07_createDCtx(void);
 ZSTDLIBv07_API size_t      ZBUFFv07_freeDCtx(ZBUFFv07_DCtx* dctx);
-
+ 
 ZSTDLIBv07_API size_t ZBUFFv07_decompressInit(ZBUFFv07_DCtx* dctx);
 ZSTDLIBv07_API size_t ZBUFFv07_decompressInitDictionary(ZBUFFv07_DCtx* dctx, const void* dict, size_t dictSize);
-
+ 
 ZSTDLIBv07_API size_t ZBUFFv07_decompressContinue(ZBUFFv07_DCtx* dctx,
-                                            void* dst, size_t* dstCapacityPtr,
-                                      const void* src, size_t* srcSizePtr);
-
-/*-***************************************************************************
-*  Streaming decompression howto
-*
-*  A ZBUFFv07_DCtx object is required to track streaming operations.
-*  Use ZBUFFv07_createDCtx() and ZBUFFv07_freeDCtx() to create/release resources.
-*  Use ZBUFFv07_decompressInit() to start a new decompression operation,
-*   or ZBUFFv07_decompressInitDictionary() if decompression requires a dictionary.
-*  Note that ZBUFFv07_DCtx objects can be re-init multiple times.
-*
-*  Use ZBUFFv07_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 ZBUFFv07_isError().
-*
-*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv07_recommendedDInSize() and ZBUFFv07_recommendedDOutSize()
-*  output : ZBUFFv07_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.
-*  input  : ZBUFFv07_recommendedDInSize == 128KB + 3;
-*           just follow indications from ZBUFFv07_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .
-* *******************************************************************************/
-
-
-/* *************************************
-*  Tool functions
-***************************************/
+                                            void* dst, size_t* dstCapacityPtr, 
+                                      const void* src, size_t* srcSizePtr); 
+ 
+/*-*************************************************************************** 
+*  Streaming decompression howto 
+* 
+*  A ZBUFFv07_DCtx object is required to track streaming operations. 
+*  Use ZBUFFv07_createDCtx() and ZBUFFv07_freeDCtx() to create/release resources. 
+*  Use ZBUFFv07_decompressInit() to start a new decompression operation, 
+*   or ZBUFFv07_decompressInitDictionary() if decompression requires a dictionary. 
+*  Note that ZBUFFv07_DCtx objects can be re-init multiple times. 
+* 
+*  Use ZBUFFv07_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 ZBUFFv07_isError(). 
+* 
+*  Hint : recommended buffer sizes (not compulsory) : ZBUFFv07_recommendedDInSize() and ZBUFFv07_recommendedDOutSize() 
+*  output : ZBUFFv07_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded. 
+*  input  : ZBUFFv07_recommendedDInSize == 128KB + 3; 
+*           just follow indications from ZBUFFv07_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 . 
+* *******************************************************************************/ 
+ 
+ 
+/* ************************************* 
+*  Tool functions 
+***************************************/ 
 ZSTDLIBv07_API unsigned ZBUFFv07_isError(size_t errorCode);
 ZSTDLIBv07_API const char* ZBUFFv07_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 */
+ 
+/** Functions below provide recommended buffer sizes for Compression or Decompression operations. 
+*   These sizes are just hints, they tend to offer better latency */ 
 ZSTDLIBv07_API size_t ZBUFFv07_recommendedDInSize(void);
 ZSTDLIBv07_API size_t ZBUFFv07_recommendedDOutSize(void);
-
-
-/*-*************************************
-*  Constants
-***************************************/
-#define ZSTDv07_MAGICNUMBER            0xFD2FB527   /* v0.7 */
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif  /* ZSTDv07_H_235446 */
+ 
+ 
+/*-************************************* 
+*  Constants 
+***************************************/ 
+#define ZSTDv07_MAGICNUMBER            0xFD2FB527   /* v0.7 */ 
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif  /* ZSTDv07_H_235446 */ 
diff --git a/contrib/libs/zstd/lib/zdict.h b/contrib/libs/zstd/lib/zdict.h
index f1e139a40d..5307791357 100644
--- a/contrib/libs/zstd/lib/zdict.h
+++ b/contrib/libs/zstd/lib/zdict.h
@@ -7,18 +7,18 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
+ 
 #ifndef DICTBUILDER_H_001
 #define DICTBUILDER_H_001
-
+ 
 #if defined (__cplusplus)
 extern "C" {
 #endif
-
-
+ 
+ 
 /*======  Dependencies  ======*/
 #include <stddef.h>  /* size_t */
-
+ 
 
 /* =====   ZDICTLIB_API : control library symbols visibility   ===== */
 #ifndef ZDICTLIB_VISIBILITY
@@ -35,7 +35,7 @@ extern "C" {
 #else
 #  define ZDICTLIB_API ZDICTLIB_VISIBILITY
 #endif
-
+ 
 /*******************************************************************************
  * Zstd dictionary builder
  *
@@ -174,7 +174,7 @@ extern "C" {
  * just like if they controlled the compressed data.
  *
  ******************************************************************************/
-
+ 
 
 /*! ZDICT_trainFromBuffer():
  *  Train a dictionary from an array of samples.
@@ -199,7 +199,7 @@ extern "C" {
 ZDICTLIB_API size_t ZDICT_trainFromBuffer(void* dictBuffer, size_t dictBufferCapacity,
                                     const void* samplesBuffer,
                                     const size_t* samplesSizes, unsigned nbSamples);
-
+ 
 typedef struct {
     int      compressionLevel;   /*< optimize for a specific zstd compression level; 0 means default */
     unsigned notificationLevel;  /*< Write log to stderr; 0 = none (default); 1 = errors; 2 = progression; 3 = details; 4 = debug; */
@@ -212,7 +212,7 @@ typedef struct {
                                   *           - high range : >= (2^31)
                                   */
 } ZDICT_params_t;
-
+ 
 /*! ZDICT_finalizeDictionary():
  * Given a custom content as a basis for dictionary, and a set of samples,
  * finalize dictionary by adding headers and statistics according to the zstd
@@ -254,27 +254,27 @@ ZDICTLIB_API size_t ZDICT_finalizeDictionary(void* dstDictBuffer, size_t maxDict
                                 ZDICT_params_t parameters);
 
 
-/*======   Helper functions   ======*/
+/*======   Helper functions   ======*/ 
 ZDICTLIB_API unsigned ZDICT_getDictID(const void* dictBuffer, size_t dictSize);  /**< extracts dictID; @return zero if error (not a valid dictionary) */
 ZDICTLIB_API size_t ZDICT_getDictHeaderSize(const void* dictBuffer, size_t dictSize);  /* returns dict header size; returns a ZSTD error code on failure */
 ZDICTLIB_API unsigned ZDICT_isError(size_t errorCode);
 ZDICTLIB_API const char* ZDICT_getErrorName(size_t errorCode);
-
-
-
-#ifdef ZDICT_STATIC_LINKING_ONLY
-
-/* ====================================================================================
- * The definitions in this section are considered experimental.
- * They should never be used with a dynamic library, as they may change in the future.
- * They are provided for advanced usages.
- * Use them only in association with static linking.
- * ==================================================================================== */
-
+ 
+ 
+ 
+#ifdef ZDICT_STATIC_LINKING_ONLY 
+ 
+/* ==================================================================================== 
+ * The definitions in this section are considered experimental. 
+ * They should never be used with a dynamic library, as they may change in the future. 
+ * They are provided for advanced usages. 
+ * Use them only in association with static linking. 
+ * ==================================================================================== */ 
+ 
 #define ZDICT_DICTSIZE_MIN    256
 /* Deprecated: Remove in v1.6.0 */
 #define ZDICT_CONTENTSIZE_MIN 128
-
+ 
 /*! ZDICT_cover_params_t:
  *  k and d are the only required parameters.
  *  For others, value 0 means default.
@@ -289,7 +289,7 @@ typedef struct {
     unsigned shrinkDictMaxRegression; /* Sets shrinkDictMaxRegression so that a smaller dictionary can be at worse shrinkDictMaxRegression% worse than the max dict size dictionary. */
     ZDICT_params_t zParams;
 } ZDICT_cover_params_t;
-
+ 
 typedef struct {
     unsigned k;                  /* Segment size : constraint: 0 < k : Reasonable range [16, 2048+] */
     unsigned d;                  /* dmer size : constraint: 0 < d <= k : Reasonable range [6, 16] */
@@ -393,7 +393,7 @@ typedef struct {
     unsigned selectivityLevel;   /* 0 means default; larger => select more => larger dictionary */
     ZDICT_params_t zParams;
 } ZDICT_legacy_params_t;
-
+ 
 /*! ZDICT_trainFromBuffer_legacy():
  *  Train a dictionary from an array of samples.
  *  Samples must be stored concatenated in a single flat buffer `samplesBuffer`,
@@ -413,7 +413,7 @@ ZDICTLIB_API size_t ZDICT_trainFromBuffer_legacy(
     void* dictBuffer, size_t dictBufferCapacity,
     const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
     ZDICT_legacy_params_t parameters);
-
+ 
 
 /* Deprecation warnings */
 /* It is generally possible to disable deprecation warnings from compiler,
@@ -437,16 +437,16 @@ ZDICTLIB_API size_t ZDICT_trainFromBuffer_legacy(
 #    define ZDICT_DEPRECATED(message) ZDICTLIB_API
 #  endif
 #endif /* ZDICT_DISABLE_DEPRECATE_WARNINGS */
-
+ 
 ZDICT_DEPRECATED("use ZDICT_finalizeDictionary() instead")
-size_t ZDICT_addEntropyTablesFromBuffer(void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity,
+size_t ZDICT_addEntropyTablesFromBuffer(void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity, 
                                   const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples);
-
-
-#endif   /* ZDICT_STATIC_LINKING_ONLY */
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif   /* DICTBUILDER_H_001 */
+ 
+ 
+#endif   /* ZDICT_STATIC_LINKING_ONLY */ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
+#endif   /* DICTBUILDER_H_001 */ 
diff --git a/contrib/libs/zstd/lib/zstd.h b/contrib/libs/zstd/lib/zstd.h
index a88ae7bf8e..12f50fc44c 100644
--- a/contrib/libs/zstd/lib/zstd.h
+++ b/contrib/libs/zstd/lib/zstd.h
@@ -1,4 +1,4 @@
-/*
+/* 
  * Copyright (c) Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
@@ -10,15 +10,15 @@
 #if defined (__cplusplus)
 extern "C" {
 #endif
-
-#ifndef ZSTD_H_235446
-#define ZSTD_H_235446
-
+ 
+#ifndef ZSTD_H_235446 
+#define ZSTD_H_235446 
+ 
 /* ======   Dependency   ======*/
 #include <limits.h>   /* INT_MAX */
-#include <stddef.h>   /* size_t */
-
-
+#include <stddef.h>   /* size_t */ 
+ 
+ 
 /* =====   ZSTDLIB_API : control library symbols visibility   ===== */
 #ifndef ZSTDLIB_VISIBLE
 #  if defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__MINGW32__)
@@ -33,14 +33,14 @@ extern "C" {
 #  define ZSTDLIB_API __declspec(dllexport) ZSTDLIB_VISIBLE
 #elif defined(ZSTD_DLL_IMPORT) && (ZSTD_DLL_IMPORT==1)
 #  define ZSTDLIB_API __declspec(dllimport) ZSTDLIB_VISIBLE /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
-#else
+#else 
 #  define ZSTDLIB_API ZSTDLIB_VISIBLE
-#endif
-
-
+#endif 
+ 
+ 
 /*******************************************************************************
   Introduction
-
+ 
   zstd, short for Zstandard, is a fast lossless compression algorithm, targeting
   real-time compression scenarios at zlib-level and better compression ratios.
   The zstd compression library provides in-memory compression and decompression
@@ -81,11 +81,11 @@ extern "C" {
  *  Return runtime library version, the value is (MAJOR*100*100 + MINOR*100 + RELEASE). */
 ZSTDLIB_API unsigned ZSTD_versionNumber(void);
 
-#define ZSTD_LIB_VERSION ZSTD_VERSION_MAJOR.ZSTD_VERSION_MINOR.ZSTD_VERSION_RELEASE
-#define ZSTD_QUOTE(str) #str
-#define ZSTD_EXPAND_AND_QUOTE(str) ZSTD_QUOTE(str)
-#define ZSTD_VERSION_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_LIB_VERSION)
-
+#define ZSTD_LIB_VERSION ZSTD_VERSION_MAJOR.ZSTD_VERSION_MINOR.ZSTD_VERSION_RELEASE 
+#define ZSTD_QUOTE(str) #str 
+#define ZSTD_EXPAND_AND_QUOTE(str) ZSTD_QUOTE(str) 
+#define ZSTD_VERSION_STRING ZSTD_EXPAND_AND_QUOTE(ZSTD_LIB_VERSION) 
+ 
 /*! ZSTD_versionString() :
  *  Return runtime library version, like "1.4.5". Requires v1.3.0+. */
 ZSTDLIB_API const char* ZSTD_versionString(void);
@@ -96,7 +96,7 @@ ZSTDLIB_API const char* ZSTD_versionString(void);
 #ifndef ZSTD_CLEVEL_DEFAULT
 #  define ZSTD_CLEVEL_DEFAULT 3
 #endif
-
+ 
 /* *************************************
  *  Constants
  ***************************************/
@@ -112,26 +112,26 @@ ZSTDLIB_API const char* ZSTD_versionString(void);
 
 
 /***************************************
-*  Simple API
-***************************************/
-/*! ZSTD_compress() :
+*  Simple API 
+***************************************/ 
+/*! ZSTD_compress() : 
  *  Compresses `src` content as a single zstd compressed frame into already allocated `dst`.
  *  Hint : compression runs faster if `dstCapacity` >=  `ZSTD_compressBound(srcSize)`.
  *  @return : compressed size written into `dst` (<= `dstCapacity),
  *            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() :
+ZSTDLIB_API size_t ZSTD_compress( void* dst, size_t dstCapacity, 
+                            const void* src, size_t srcSize, 
+                                  int compressionLevel); 
+ 
+/*! ZSTD_decompress() : 
  *  `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames.
  *  `dstCapacity` is an upper bound of originalSize to regenerate.
  *  If user cannot imply a maximum upper bound, it's better to use streaming mode to decompress data.
  *  @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);
-
+ZSTDLIB_API size_t ZSTD_decompress( void* dst, size_t dstCapacity, 
+                              const void* src, size_t compressedSize); 
+ 
 /*! ZSTD_getFrameContentSize() : requires v1.3.0+
  *  `src` should point to the start of a ZSTD encoded frame.
  *  `srcSize` must be at least as large as the frame header.
@@ -166,7 +166,7 @@ ZSTDLIB_API unsigned long long ZSTD_getFrameContentSize(const void *src, size_t
  *  while ZSTD_getFrameContentSize() gives them separate return values.
  * @return : decompressed size of `src` frame content _if known and not empty_, 0 otherwise. */
 ZSTDLIB_API unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize);
-
+ 
 /*! ZSTD_findFrameCompressedSize() : Requires v1.4.0+
  * `src` should point to the start of a ZSTD frame or skippable frame.
  * `srcSize` must be >= first frame size
@@ -176,19 +176,19 @@ ZSTDLIB_API unsigned long long ZSTD_getDecompressedSize(const void* src, size_t
 ZSTDLIB_API size_t ZSTD_findFrameCompressedSize(const void* src, size_t srcSize);
 
 
-/*======  Helper functions  ======*/
+/*======  Helper functions  ======*/ 
 #define ZSTD_COMPRESSBOUND(srcSize)   ((srcSize) + ((srcSize)>>8) + (((srcSize) < (128<<10)) ? (((128<<10) - (srcSize)) >> 11) /* margin, from 64 to 0 */ : 0))  /* this formula ensures that bound(A) + bound(B) <= bound(A+B) as long as A and B >= 128 KB */
 ZSTDLIB_API size_t      ZSTD_compressBound(size_t srcSize); /*!< maximum compressed size in worst case single-pass scenario */
-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 from an error code */
+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 from an error code */ 
 ZSTDLIB_API int         ZSTD_minCLevel(void);               /*!< minimum negative compression level allowed, requires v1.4.0+ */
 ZSTDLIB_API int         ZSTD_maxCLevel(void);               /*!< maximum compression level available */
 ZSTDLIB_API int         ZSTD_defaultCLevel(void);           /*!< default compression level, specified by ZSTD_CLEVEL_DEFAULT, requires v1.5.0+ */
-
-
+ 
+ 
 /***************************************
 *  Explicit context
-***************************************/
+***************************************/ 
 /*= Compression context
  *  When compressing many times,
  *  it is recommended to allocate a context just once,
@@ -200,9 +200,9 @@ ZSTDLIB_API int         ZSTD_defaultCLevel(void);           /*!< default compres
  *         use one different context per thread for parallel execution.
  */
 typedef struct ZSTD_CCtx_s ZSTD_CCtx;
-ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx(void);
+ZSTDLIB_API ZSTD_CCtx* ZSTD_createCCtx(void); 
 ZSTDLIB_API size_t     ZSTD_freeCCtx(ZSTD_CCtx* cctx);  /* accept NULL pointer */
-
+ 
 /*! ZSTD_compressCCtx() :
  *  Same as ZSTD_compress(), using an explicit ZSTD_CCtx.
  *  Important : in order to behave similarly to `ZSTD_compress()`,
@@ -215,7 +215,7 @@ ZSTDLIB_API size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,
                                      void* dst, size_t dstCapacity,
                                const void* src, size_t srcSize,
                                      int compressionLevel);
-
+ 
 /*= Decompression context
  *  When decompressing many times,
  *  it is recommended to allocate a context only once,
@@ -223,9 +223,9 @@ ZSTDLIB_API size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,
  *  This will make workload friendlier for system's memory.
  *  Use one context per thread for parallel execution. */
 typedef struct ZSTD_DCtx_s ZSTD_DCtx;
-ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx(void);
+ZSTDLIB_API ZSTD_DCtx* ZSTD_createDCtx(void); 
 ZSTDLIB_API size_t     ZSTD_freeDCtx(ZSTD_DCtx* dctx);  /* accept NULL pointer */
-
+ 
 /*! ZSTD_decompressDCtx() :
  *  Same as ZSTD_decompress(),
  *  requires an allocated ZSTD_DCtx.
@@ -234,12 +234,12 @@ ZSTDLIB_API size_t     ZSTD_freeDCtx(ZSTD_DCtx* dctx);  /* accept NULL pointer *
 ZSTDLIB_API size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx,
                                        void* dst, size_t dstCapacity,
                                  const void* src, size_t srcSize);
-
-
+ 
+ 
 /*********************************************
 *  Advanced compression API (Requires v1.4.0+)
 **********************************************/
-
+ 
 /* API design :
  *   Parameters are pushed one by one into an existing context,
  *   using ZSTD_CCtx_set*() functions.
@@ -252,8 +252,8 @@ ZSTDLIB_API size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx,
  *   This API supersedes all other "advanced" API entry points in the experimental section.
  *   In the future, we expect to remove from experimental API entry points which are redundant with this API.
  */
-
-
+ 
+ 
 /* Compression strategies, listed from fastest to strongest */
 typedef enum { ZSTD_fast=1,
                ZSTD_dfast=2,
@@ -269,7 +269,7 @@ typedef enum { ZSTD_fast=1,
 } ZSTD_strategy;
 
 typedef enum {
-
+ 
     /* compression parameters
      * Note: When compressing with a ZSTD_CDict these parameters are superseded
      * by the parameters used to construct the ZSTD_CDict.
@@ -441,13 +441,13 @@ typedef enum {
      ZSTD_c_experimentalParam14=1011,
      ZSTD_c_experimentalParam15=1012
 } ZSTD_cParameter;
-
+ 
 typedef struct {
     size_t error;
     int lowerBound;
     int upperBound;
 } ZSTD_bounds;
-
+ 
 /*! ZSTD_cParam_getBounds() :
  *  All parameters must belong to an interval with lower and upper bounds,
  *  otherwise they will either trigger an error or be automatically clamped.
@@ -456,7 +456,7 @@ typedef struct {
  *         - lower and upper bounds, both inclusive
  */
 ZSTDLIB_API ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter cParam);
-
+ 
 /*! ZSTD_CCtx_setParameter() :
  *  Set one compression parameter, selected by enum ZSTD_cParameter.
  *  All parameters have valid bounds. Bounds can be queried using ZSTD_cParam_getBounds().
@@ -592,7 +592,7 @@ ZSTDLIB_API size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset);
 /****************************
 *  Streaming
 ****************************/
-
+ 
 typedef struct ZSTD_inBuffer_s {
   const void* src;    /**< start of input buffer */
   size_t size;        /**< size of input buffer */
@@ -1069,9 +1069,9 @@ ZSTDLIB_API size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict);
  * The definitions in the following section are considered experimental.
  * They are provided for advanced scenarios.
  * They should never be used with a dynamic library, as prototypes may change in the future.
- * Use them only in association with static linking.
+ * Use them only in association with static linking. 
  * ***************************************************************************************/
-
+ 
 #if defined(ZSTD_STATIC_LINKING_ONLY) && !defined(ZSTD_H_ZSTD_STATIC_LINKING_ONLY)
 #define ZSTD_H_ZSTD_STATIC_LINKING_ONLY
 
@@ -1117,12 +1117,12 @@ ZSTDLIB_API size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict);
  * Some of them are planned to remain in the static_only section indefinitely.
  * Some of them might be removed in the future (especially when redundant with existing stable functions)
  * ***************************************************************************************/
-
+ 
 #define ZSTD_FRAMEHEADERSIZE_PREFIX(format) ((format) == ZSTD_f_zstd1 ? 5 : 1)   /* minimum input size required to query frame header size */
 #define ZSTD_FRAMEHEADERSIZE_MIN(format)    ((format) == ZSTD_f_zstd1 ? 6 : 2)
 #define ZSTD_FRAMEHEADERSIZE_MAX   18   /* can be useful for static allocation */
 #define ZSTD_SKIPPABLEHEADERSIZE    8
-
+ 
 /* compression parameter bounds */
 #define ZSTD_WINDOWLOG_MAX_32    30
 #define ZSTD_WINDOWLOG_MAX_64    31
@@ -1142,8 +1142,8 @@ ZSTDLIB_API size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict);
 #define ZSTD_TARGETLENGTH_MIN     0   /* note : comparing this constant to an unsigned results in a tautological test */
 #define ZSTD_STRATEGY_MIN        ZSTD_fast
 #define ZSTD_STRATEGY_MAX        ZSTD_btultra2
-
-
+ 
+ 
 #define ZSTD_OVERLAPLOG_MIN       0
 #define ZSTD_OVERLAPLOG_MAX       9
 
@@ -1175,7 +1175,7 @@ ZSTDLIB_API size_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict);
 
 typedef struct ZSTD_CCtx_params_s ZSTD_CCtx_params;
 
-typedef struct {
+typedef struct { 
     unsigned int offset;      /* The offset of the match. (NOT the same as the offset code)
                                * If offset == 0 and matchLength == 0, this sequence represents the last
                                * literals in the block of litLength size.
@@ -1220,25 +1220,25 @@ typedef struct {
     unsigned minMatch;        /**< match length searched : larger == faster decompression, sometimes less compression */
     unsigned targetLength;    /**< acceptable match size for optimal parser (only) : larger == more compression, slower */
     ZSTD_strategy strategy;   /**< see ZSTD_strategy definition above */
-} ZSTD_compressionParameters;
-
-typedef struct {
+} ZSTD_compressionParameters; 
+ 
+typedef struct { 
     int contentSizeFlag; /**< 1: content size will be in frame header (when known) */
     int checksumFlag;    /**< 1: generate a 32-bits checksum using XXH64 algorithm at end of frame, for error detection */
     int noDictIDFlag;    /**< 1: no dictID will be saved into frame header (dictID is only useful for dictionary compression) */
-} ZSTD_frameParameters;
-
-typedef struct {
-    ZSTD_compressionParameters cParams;
-    ZSTD_frameParameters fParams;
-} ZSTD_parameters;
-
+} ZSTD_frameParameters; 
+ 
+typedef struct { 
+    ZSTD_compressionParameters cParams; 
+    ZSTD_frameParameters fParams; 
+} ZSTD_parameters; 
+ 
 typedef enum {
     ZSTD_dct_auto = 0,       /* dictionary is "full" when starting with ZSTD_MAGIC_DICTIONARY, otherwise it is "rawContent" */
     ZSTD_dct_rawContent = 1, /* ensures dictionary is always loaded as rawContent, even if it starts with ZSTD_MAGIC_DICTIONARY */
     ZSTD_dct_fullDict = 2    /* refuses to load a dictionary if it does not respect Zstandard's specification, starting with ZSTD_MAGIC_DICTIONARY */
 } ZSTD_dictContentType_e;
-
+ 
 typedef enum {
     ZSTD_dlm_byCopy = 0,  /**< Copy dictionary content internally */
     ZSTD_dlm_byRef = 1    /**< Reference dictionary content -- the dictionary buffer must outlive its users. */
@@ -1323,8 +1323,8 @@ typedef enum {
 
 /***************************************
 *  Frame size functions
-***************************************/
-
+***************************************/ 
+ 
 /*! ZSTD_findDecompressedSize() :
  *  `src` should point to the start of a series of ZSTD encoded and/or skippable frames
  *  `srcSize` must be the _exact_ size of this series
@@ -1601,7 +1601,7 @@ ZSTDLIB_STATIC_API ZSTD_CDict* ZSTD_createCDict_advanced(const void* dict, size_
                                                   ZSTD_dictContentType_e dictContentType,
                                                   ZSTD_compressionParameters cParams,
                                                   ZSTD_customMem customMem);
-
+ 
 /*! Thread pool :
  *  These prototypes make it possible to share a thread pool among multiple compression contexts.
  *  This can limit resources for applications with multiple threads where each one uses
@@ -1633,7 +1633,7 @@ ZSTDLIB_STATIC_API ZSTD_DDict* ZSTD_createDDict_advanced(
     ZSTD_dictLoadMethod_e dictLoadMethod,
     ZSTD_dictContentType_e dictContentType,
     ZSTD_customMem customMem);
-
+ 
 
 /***************************************
 *  Advanced compression functions
@@ -1652,25 +1652,25 @@ ZSTDLIB_STATIC_API ZSTD_CDict* ZSTD_createCDict_byReference(const void* dictBuff
  * `estimatedSrcSize` value is optional, select 0 if not known */
 ZSTDLIB_STATIC_API ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);
 
-/*! ZSTD_getParams() :
+/*! ZSTD_getParams() : 
  *  same as ZSTD_getCParams(), but @return a full `ZSTD_parameters` object instead of sub-component `ZSTD_compressionParameters`.
  *  All fields of `ZSTD_frameParameters` are set to default : contentSize=1, checksum=0, noDictID=0 */
 ZSTDLIB_STATIC_API ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);
-
-/*! ZSTD_checkCParams() :
+ 
+/*! ZSTD_checkCParams() : 
  *  Ensure param values remain within authorized range.
  * @return 0 on success, or an error code (can be checked with ZSTD_isError()) */
 ZSTDLIB_STATIC_API size_t ZSTD_checkCParams(ZSTD_compressionParameters params);
-
-/*! ZSTD_adjustCParams() :
+ 
+/*! ZSTD_adjustCParams() : 
  *  optimize params for a given `srcSize` and `dictSize`.
  * `srcSize` can be unknown, in which case use ZSTD_CONTENTSIZE_UNKNOWN.
  * `dictSize` must be `0` when there is no dictionary.
  *  cPar can be invalid : all parameters will be clamped within valid range in the @return struct.
  *  This function never fails (wide contract) */
 ZSTDLIB_STATIC_API ZSTD_compressionParameters ZSTD_adjustCParams(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize);
-
-/*! ZSTD_compress_advanced() :
+ 
+/*! ZSTD_compress_advanced() : 
  *  Note : this function is now DEPRECATED.
  *         It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_setParameter() and other parameter setters.
  *  This prototype will generate compilation warnings. */
@@ -1680,7 +1680,7 @@ size_t ZSTD_compress_advanced(ZSTD_CCtx* cctx,
                                     const void* src, size_t srcSize,
                                     const void* dict,size_t dictSize,
                                           ZSTD_parameters params);
-
+ 
 /*! ZSTD_compress_usingCDict_advanced() :
  *  Note : this function is now DEPRECATED.
  *         It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_loadDictionary() and other parameter setters.
@@ -1691,13 +1691,13 @@ size_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx,
                                         const void* src, size_t srcSize,
                                         const ZSTD_CDict* cdict,
                                               ZSTD_frameParameters fParams);
-
+ 
 
 /*! ZSTD_CCtx_loadDictionary_byReference() :
  *  Same as ZSTD_CCtx_loadDictionary(), but dictionary content is referenced, instead of being copied into CCtx.
  *  It saves some memory, but also requires that `dict` outlives its usage within `cctx` */
 ZSTDLIB_STATIC_API size_t ZSTD_CCtx_loadDictionary_byReference(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);
-
+ 
 /*! ZSTD_CCtx_loadDictionary_advanced() :
  *  Same as ZSTD_CCtx_loadDictionary(), but gives finer control over
  *  how to load the dictionary (by copy ? by reference ?)
@@ -2051,14 +2051,14 @@ ZSTDLIB_STATIC_API unsigned ZSTD_isFrame(const void* buffer, size_t size);
  *  It is important that dictBuffer outlives DDict,
  *  it must remain read accessible throughout the lifetime of DDict */
 ZSTDLIB_STATIC_API ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize);
-
+ 
 /*! ZSTD_DCtx_loadDictionary_byReference() :
  *  Same as ZSTD_DCtx_loadDictionary(),
  *  but references `dict` content instead of copying it into `dctx`.
  *  This saves memory if `dict` remains around.,
  *  However, it's imperative that `dict` remains accessible (and unmodified) while being used, so it must outlive decompression. */
 ZSTDLIB_STATIC_API size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
-
+ 
 /*! ZSTD_DCtx_loadDictionary_advanced() :
  *  Same as ZSTD_DCtx_loadDictionary(),
  *  but gives direct control over
@@ -2185,8 +2185,8 @@ ZSTDLIB_STATIC_API size_t ZSTD_decompressStream_simpleArgs (
 *  Warning : most of these functions are now redundant with the Advanced API.
 *  Once Advanced API reaches "stable" status,
 *  redundant functions will be deprecated, and then at some point removed.
-********************************************************************/
-
+********************************************************************/ 
+ 
 /*=====   Advanced Streaming compression functions  =====*/
 
 /*! ZSTD_initCStream_srcSize() :
@@ -2275,7 +2275,7 @@ size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
                                const ZSTD_CDict* cdict,
                                      ZSTD_frameParameters fParams,
                                      unsigned long long pledgedSrcSize);
-
+ 
 /*! ZSTD_resetCStream() :
  * This function is DEPRECATED, and is equivalent to:
  *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
@@ -2296,7 +2296,7 @@ size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
  */
 ZSTD_DEPRECATED("use ZSTD_CCtx_reset, see zstd.h for detailed instructions")
 size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);
-
+ 
 
 typedef struct {
     unsigned long long ingested;   /* nb input bytes read and buffered */
@@ -2377,33 +2377,33 @@ ZSTDLIB_STATIC_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);
 /**
   Buffer-less streaming compression (synchronous mode)
 
-  A ZSTD_CCtx object is required to track streaming operations.
-  Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource.
-  ZSTD_CCtx object can be re-used multiple times within successive compression operations.
-
-  Start by initializing a context.
+  A ZSTD_CCtx object is required to track streaming operations. 
+  Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource. 
+  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.
-  It's also possible to duplicate a reference context which has already been initialized, using ZSTD_copyCCtx()
-
-  Then, consume your input using ZSTD_compressContinue().
-  There are some important considerations to keep in mind when using this advanced function :
+  It's also possible to duplicate a reference context which has already been initialized, using ZSTD_copyCCtx() 
+ 
+  Then, consume your input using ZSTD_compressContinue(). 
+  There are some important considerations to keep in mind when using this advanced function : 
   - ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only.
   - Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks.
-  - Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario.
-    Worst case evaluation is provided by ZSTD_compressBound().
-    ZSTD_compressContinue() doesn't guarantee recover after a failed compression.
-  - ZSTD_compressContinue() presumes prior input ***is still accessible and unmodified*** (up to maximum distance size, see WindowLog).
-    It remembers all previous contiguous blocks, plus one separated memory segment (which can itself consists of multiple contiguous blocks)
-  - ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps.
-    In which case, it will "discard" the relevant memory section from its history.
-
-  Finish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum.
+  - Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario. 
+    Worst case evaluation is provided by ZSTD_compressBound(). 
+    ZSTD_compressContinue() doesn't guarantee recover after a failed compression. 
+  - ZSTD_compressContinue() presumes prior input ***is still accessible and unmodified*** (up to maximum distance size, see WindowLog). 
+    It remembers all previous contiguous blocks, plus one separated memory segment (which can itself consists of multiple contiguous blocks) 
+  - ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps. 
+    In which case, it will "discard" the relevant memory section from its history. 
+ 
+  Finish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum. 
   It's possible to use srcSize==0, in which case, it will write a final empty block to end the frame.
   Without last block mark, frames are considered unfinished (hence corrupted) by compliant decoders.
-
+ 
   `ZSTD_CCtx` object can be re-used (ZSTD_compressBegin()) to compress again.
-*/
-
+*/ 
+ 
 /*=====   Buffer-less streaming compression functions  =====*/
 ZSTDLIB_STATIC_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel);
 ZSTDLIB_STATIC_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);
@@ -2412,27 +2412,27 @@ ZSTDLIB_STATIC_API size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* prepar
 
 ZSTDLIB_STATIC_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
 ZSTDLIB_STATIC_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
-
+ 
 /* The ZSTD_compressBegin_advanced() and ZSTD_compressBegin_usingCDict_advanced() are now DEPRECATED and will generate a compiler warning */
 ZSTD_DEPRECATED("use advanced API to access custom parameters")
 size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); /**< pledgedSrcSize : If srcSize is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN */
 ZSTD_DEPRECATED("use advanced API to access custom parameters")
 size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict, ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize);   /* compression parameters are already set within cdict. pledgedSrcSize must be correct. If srcSize is not known, use macro ZSTD_CONTENTSIZE_UNKNOWN */
 /**
-  Buffer-less streaming decompression (synchronous 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.
-
+  Buffer-less streaming decompression (synchronous 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. 
+ 
   First typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader().
   Frame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough.
   Data fragment must be large enough to ensure successful decoding.
  `ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough.
   @result : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled.
-           >0 : `srcSize` is too small, please provide at least @result bytes on next attempt.
-           errorCode, which can be tested using ZSTD_isError().
-
+           >0 : `srcSize` is too small, please provide at least @result bytes on next attempt. 
+           errorCode, which can be tested using ZSTD_isError(). 
+ 
   It fills a ZSTD_frameHeader structure with important information to correctly decode the frame,
   such as the dictionary ID, content size, or maximum back-reference distance (`windowSize`).
   Note that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information.
@@ -2440,7 +2440,7 @@ size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_
   For example, do not allocate memory blindly, check that `windowSize` is within expectation.
   Each application can set its own limits, depending on local restrictions.
   For extended interoperability, it is recommended to support `windowSize` of at least 8 MB.
-
+ 
   ZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes.
   ZSTD_decompressContinue() is very sensitive to contiguity,
   if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,
@@ -2465,32 +2465,32 @@ size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_
   Once buffers are setup, start decompression, with ZSTD_decompressBegin().
   If decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict().
 
-  Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively.
-  ZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue().
-  ZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail.
-
+  Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively. 
+  ZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue(). 
+  ZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail. 
+ 
  @result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity).
   It can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item.
-  It can also be an error code, which can be tested with ZSTD_isError().
-
-  A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero.
-  Context can then be reset to start a new decompression.
-
-  Note : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType().
-  This information is not required to properly decode a frame.
-
-  == Special case : skippable frames ==
-
-  Skippable frames allow integration of user-defined data into a flow of concatenated frames.
+  It can also be an error code, which can be tested with ZSTD_isError(). 
+ 
+  A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero. 
+  Context can then be reset to start a new decompression. 
+ 
+  Note : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType(). 
+  This information is not required to properly decode a frame. 
+ 
+  == Special case : skippable frames == 
+ 
+  Skippable frames allow integration of user-defined data into a flow of concatenated frames. 
   Skippable frames will be ignored (skipped) by decompressor.
   The format of skippable frames is as follows :
-  a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F
-  b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits
-  c) Frame Content - any content (User Data) of length equal to Frame Size
+  a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F 
+  b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits 
+  c) Frame Content - any content (User Data) of length equal to Frame Size 
   For skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame.
   For skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content.
-*/
-
+*/ 
+ 
 /*=====   Buffer-less streaming decompression functions  =====*/
 typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_frameType_e;
 typedef struct {
@@ -2514,7 +2514,7 @@ ZSTDLIB_STATIC_API size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const vo
  *  with added capability to select a format (like ZSTD_f_zstd1_magicless) */
 ZSTDLIB_STATIC_API size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format);
 ZSTDLIB_STATIC_API size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize);  /**< when frame content size is not known, pass in frameContentSize == ZSTD_CONTENTSIZE_UNKNOWN */
-
+ 
 ZSTDLIB_STATIC_API size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx);
 ZSTDLIB_STATIC_API size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
 ZSTDLIB_STATIC_API size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
@@ -2538,11 +2538,11 @@ ZSTDLIB_STATIC_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx);
     Block functions produce and decode raw zstd blocks, without frame metadata.
     Frame metadata cost is typically ~12 bytes, which can be non-negligible for very small blocks (< 100 bytes).
     But users will have to take in charge needed metadata to regenerate data, such as compressed and content sizes.
-
-    A few rules to respect :
-    - Compressing and decompressing require a context structure
-      + Use ZSTD_createCCtx() and ZSTD_createDCtx()
-    - It is necessary to init context before starting
+ 
+    A few rules to respect : 
+    - Compressing and decompressing require a context structure 
+      + Use ZSTD_createCCtx() and ZSTD_createDCtx() 
+    - It is necessary to init context before starting 
       + compression : any ZSTD_compressBegin*() variant, including with dictionary
       + decompression : any ZSTD_decompressBegin*() variant, including with dictionary
       + copyCCtx() and copyDCtx() can be used too
@@ -2559,17 +2559,17 @@ ZSTDLIB_STATIC_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx);
       + In case of multiple successive blocks, should some of them be uncompressed,
         decoder must be informed of their existence in order to follow proper history.
         Use ZSTD_insertBlock() for such a case.
-*/
-
+*/ 
+ 
 /*=====   Raw zstd block functions  =====*/
 ZSTDLIB_STATIC_API size_t ZSTD_getBlockSize   (const ZSTD_CCtx* cctx);
 ZSTDLIB_STATIC_API size_t ZSTD_compressBlock  (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
 ZSTDLIB_STATIC_API size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
 ZSTDLIB_STATIC_API size_t ZSTD_insertBlock    (ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize);  /**< insert uncompressed block into `dctx` history. Useful for multi-blocks decompression. */
-
-
+ 
+ 
 #endif   /* ZSTD_H_ZSTD_STATIC_LINKING_ONLY */
-
-#if defined (__cplusplus)
-}
-#endif
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
diff --git a/contrib/libs/zstd/lib/zstd_errors.h b/contrib/libs/zstd/lib/zstd_errors.h
index fa3686b772..d7bd285f91 100644
--- a/contrib/libs/zstd/lib/zstd_errors.h
+++ b/contrib/libs/zstd/lib/zstd_errors.h
@@ -7,17 +7,17 @@
  * in the COPYING file in the root directory of this source tree).
  * You may select, at your option, one of the above-listed licenses.
  */
-
+ 
 #ifndef ZSTD_ERRORS_H_398273423
 #define ZSTD_ERRORS_H_398273423
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
+ 
+#if defined (__cplusplus) 
+extern "C" { 
+#endif 
+ 
 /*===== dependency =====*/
 #include <stddef.h>   /* size_t */
-
+ 
 
 /* =====   ZSTDERRORLIB_API : control library symbols visibility   ===== */
 #ifndef ZSTDERRORLIB_VISIBILITY
@@ -49,7 +49,7 @@ extern "C" {
  *           This is the only supported way to use the error list < v1.3.1
  *  note 3 : ZSTD_isError() is always correct, whatever the library version.
  **********************************************/
-typedef enum {
+typedef enum { 
   ZSTD_error_no_error = 0,
   ZSTD_error_GENERIC  = 1,
   ZSTD_error_prefix_unknown                = 10,
@@ -79,17 +79,17 @@ typedef enum {
   ZSTD_error_dstBuffer_wrong     = 104,
   ZSTD_error_srcBuffer_wrong     = 105,
   ZSTD_error_maxCode = 120  /* never EVER use this value directly, it can change in future versions! Use ZSTD_isError() instead */
-} ZSTD_ErrorCode;
-
-/*! ZSTD_getErrorCode() :
-    convert a `size_t` function result into a `ZSTD_ErrorCode` enum type,
+} ZSTD_ErrorCode; 
+ 
+/*! ZSTD_getErrorCode() : 
+    convert a `size_t` function result into a `ZSTD_ErrorCode` enum type, 
     which can be used to compare with enum list published above */
 ZSTDERRORLIB_API ZSTD_ErrorCode ZSTD_getErrorCode(size_t functionResult);
 ZSTDERRORLIB_API const char* ZSTD_getErrorString(ZSTD_ErrorCode code);   /**< Same as ZSTD_getErrorName, but using a `ZSTD_ErrorCode` enum argument */
-
-
-#if defined (__cplusplus)
-}
-#endif
-
+ 
+ 
+#if defined (__cplusplus) 
+} 
+#endif 
+ 
 #endif /* ZSTD_ERRORS_H_398273423 */