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

5 files changed, 2705 insertions, 2705 deletions

diff --git a/contrib/libs/zstd06/compress/fse_compress.c b/contrib/libs/zstd06/compress/fse_compress.c
index dad0be7942..38427e5ca3 100644
--- a/contrib/libs/zstd06/compress/fse_compress.c
+++ b/contrib/libs/zstd06/compress/fse_compress.c
@@ -1,803 +1,803 @@
-/* ******************************************************************
-   FSE : Finite State Entropy encoder
-   Copyright (C) 2013-2015, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    You can contact the author at :
-    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy
-    - Public forum : https://groups.google.com/forum/#!forum/lz4c
-****************************************************************** */
-
-/* **************************************************************
-*  Compiler specifics
-****************************************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  define FORCE_INLINE static __forceinline
-#  include <intrin.h>                    /* For Visual 2005 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
-#else
-#  ifdef __GNUC__
-#    define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#    define FORCE_INLINE static inline __attribute__((always_inline))
-#  else
-#    define FORCE_INLINE static inline
-#  endif
-#endif
-
-
-/* **************************************************************
-*  Includes
-****************************************************************/
-#include <stdlib.h>     /* malloc, free, qsort */
-#include <string.h>     /* memcpy, memset */
-#include <stdio.h>      /* printf (debug) */
-#include "bitstream.h"
-#include "fse_static.h"
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-
-
-/* **************************************************************
-*  Complex types
-****************************************************************/
-typedef U32 CTable_max_t[FSE_CTABLE_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE)];
-
-
-/* **************************************************************
-*  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 */
-size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
-{
-    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 cumul[FSE_MAX_SYMBOL_VALUE+2];
-
-    FSE_FUNCTION_TYPE tableSymbol[FSE_MAX_TABLESIZE]; /* memset() is not necessary, even if static analyzer complain about it */
-    U32 highThreshold = tableSize-1;
-
-    /* CTable header */
-
-
-    tableU16[-2] = (U16) tableLog;
-    tableU16[-1] = (U16) maxSymbolValue;
-
-    /* For explanations on how to distribute symbol values over the table :
-    *  http://fastcompression.blogspot.fr/2014/02/fse-distributing-symbol-values.html */
-
-    /* symbol start positions */
-    {   U32 u;
-        cumul[0] = 0;
-        for (u=1; u<=maxSymbolValue+1; u++) {
-            if (normalizedCounter[u-1]==-1) {  /* Low proba symbol */
-                cumul[u] = cumul[u-1] + 1;
-                tableSymbol[highThreshold--] = (FSE_FUNCTION_TYPE)(u-1);
-            } else {
-                cumul[u] = cumul[u-1] + normalizedCounter[u-1];
-        }   }
-        cumul[maxSymbolValue+1] = tableSize+1;
-    }
-
-    /* Spread symbols */
-    {   U32 position = 0;
-        U32 symbol;
-        for (symbol=0; symbol<=maxSymbolValue; symbol++) {
-            int nbOccurences;
-            for (nbOccurences=0; nbOccurences<normalizedCounter[symbol]; nbOccurences++) {
-                tableSymbol[position] = (FSE_FUNCTION_TYPE)symbol;
-                position = (position + step) & tableMask;
-                while (position > highThreshold) position = (position + step) & tableMask;   /* Low proba area */
-        }   }
-
-        if (position!=0) return ERROR(GENERIC);   /* Must have gone through 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])
-            {
-            case  0: break;
-
-            case -1:
-            case  1:
-                symbolTT[s].deltaNbBits = (tableLog << 16) - (1<<tableLog);
-                symbolTT[s].deltaFindState = total - 1;
-                total ++;
-                break;
-            default :
-                {
-                    U32 const maxBitsOut = tableLog - BIT_highbit32 (normalizedCounter[s]-1);
-                    U32 const minStatePlus = normalizedCounter[s] << maxBitsOut;
-                    symbolTT[s].deltaNbBits = (maxBitsOut << 16) - minStatePlus;
-                    symbolTT[s].deltaFindState = total - normalizedCounter[s];
-                    total +=  normalizedCounter[s];
-    }   }   }   }
-
-    return 0;
-}
-
-
-
-#ifndef FSE_COMMONDEFS_ONLY
-
-/*-**************************************************************
-*  FSE NCount encoding-decoding
-****************************************************************/
-size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog)
-{
-    size_t maxHeaderSize = (((maxSymbolValue+1) * tableLog) >> 3) + 3;
-    return maxSymbolValue ? maxHeaderSize : FSE_NCOUNTBOUND;  /* maxSymbolValue==0 ? use default */
-}
-
-static short FSE_abs(short a) { return a<0 ? -a : a; }
-
-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;
-    U32 bitStream;
-    int bitCount;
-    unsigned charnum = 0;
-    int previous0 = 0;
-
-    bitStream = 0;
-    bitCount  = 0;
-    /* Table Size */
-    bitStream += (tableLog-FSE_MIN_TABLELOG) << bitCount;
-    bitCount  += 4;
-
-    /* Init */
-    remaining = tableSize+1;   /* +1 for extra accuracy */
-    threshold = tableSize;
-    nbBits = tableLog+1;
-
-    while (remaining>1) {  /* stops at 1 */
-        if (previous0) {
-            unsigned start = charnum;
-            while (!normalizedCounter[charnum]) charnum++;
-            while (charnum >= start+24) {
-                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;
-            }
-            while (charnum >= start+3) {
-                start+=3;
-                bitStream += 3 << bitCount;
-                bitCount += 2;
-            }
-            bitStream += (charnum-start) << bitCount;
-            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;
-        }   }
-        {   short count = normalizedCounter[charnum++];
-            const short max = (short)((2*threshold-1)-remaining);
-            remaining -= FSE_abs(count);
-            if (remaining<1) return ERROR(GENERIC);
-            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);
-            previous0 = (count==1);
-            while (remaining<threshold) nbBits--, threshold>>=1;
-        }
-        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;
-    }   }
-
-    /* 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;
-
-    if (charnum > maxSymbolValue + 1) return ERROR(GENERIC);
-
-    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(GENERIC);   /* 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);
-
-    return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 1);
-}
-
-
-
-/*-**************************************************************
-*  Counting histogram
-****************************************************************/
-/*! FSE_count_simple
-    This function just counts byte values within `src`,
-    and store the histogram into table `count`.
-    This function is unsafe : it doesn't check that all values within `src` can fit into `count`.
-    For this reason, prefer using a table `count` with 256 elements.
-    @return : count of most numerous element
-*/
-static size_t FSE_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,
-                               const void* src, size_t srcSize)
-{
-    const BYTE* ip = (const BYTE*)src;
-    const BYTE* const end = ip + srcSize;
-    unsigned maxSymbolValue = *maxSymbolValuePtr;
-    unsigned max=0;
-
-
-    memset(count, 0, (maxSymbolValue+1)*sizeof(*count));
-    if (srcSize==0) { *maxSymbolValuePtr = 0; return 0; }
-
-    while (ip<end) count[*ip++]++;
-
-    while (!count[maxSymbolValue]) maxSymbolValue--;
-    *maxSymbolValuePtr = maxSymbolValue;
-
-    { U32 s; for (s=0; s<=maxSymbolValue; s++) if (count[s] > max) max = count[s]; }
-
-    return (size_t)max;
-}
-
-
-static size_t FSE_count_parallel(unsigned* count, unsigned* maxSymbolValuePtr,
-                                const void* source, size_t sourceSize,
-                                unsigned checkMax)
-{
-    const BYTE* ip = (const BYTE*)source;
-    const BYTE* const iend = ip+sourceSize;
-    unsigned maxSymbolValue = *maxSymbolValuePtr;
-    unsigned max=0;
-
-
-    U32 Counting1[256] = { 0 };
-    U32 Counting2[256] = { 0 };
-    U32 Counting3[256] = { 0 };
-    U32 Counting4[256] = { 0 };
-
-    /* safety checks */
-    if (!sourceSize) {
-        memset(count, 0, maxSymbolValue + 1);
-        *maxSymbolValuePtr = 0;
-        return 0;
-    }
-    if (!maxSymbolValue) maxSymbolValue = 255;            /* 0 == default */
-
-    /* by stripes of 16 bytes */
-    {   U32 cached = MEM_read32(ip); ip += 4;
-        while (ip < iend-15) {
-            U32 c = cached; cached = MEM_read32(ip); ip += 4;
-            Counting1[(BYTE) c     ]++;
-            Counting2[(BYTE)(c>>8) ]++;
-            Counting3[(BYTE)(c>>16)]++;
-            Counting4[       c>>24 ]++;
-            c = cached; cached = MEM_read32(ip); ip += 4;
-            Counting1[(BYTE) c     ]++;
-            Counting2[(BYTE)(c>>8) ]++;
-            Counting3[(BYTE)(c>>16)]++;
-            Counting4[       c>>24 ]++;
-            c = cached; cached = MEM_read32(ip); ip += 4;
-            Counting1[(BYTE) c     ]++;
-            Counting2[(BYTE)(c>>8) ]++;
-            Counting3[(BYTE)(c>>16)]++;
-            Counting4[       c>>24 ]++;
-            c = cached; cached = MEM_read32(ip); ip += 4;
-            Counting1[(BYTE) c     ]++;
-            Counting2[(BYTE)(c>>8) ]++;
-            Counting3[(BYTE)(c>>16)]++;
-            Counting4[       c>>24 ]++;
-        }
-        ip-=4;
-    }
-
-    /* finish last symbols */
-    while (ip<iend) Counting1[*ip++]++;
-
-    if (checkMax) {   /* verify stats will fit into destination table */
-        U32 s; for (s=255; s>maxSymbolValue; s--) {
-            Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s];
-            if (Counting1[s]) return ERROR(maxSymbolValue_tooSmall);
-    }   }
-
-    { U32 s; for (s=0; s<=maxSymbolValue; s++) {
-        count[s] = Counting1[s] + Counting2[s] + Counting3[s] + Counting4[s];
-        if (count[s] > max) max = count[s];
-    }}
-
-    while (!count[maxSymbolValue]) maxSymbolValue--;
-    *maxSymbolValuePtr = maxSymbolValue;
-    return (size_t)max;
-}
-
-/* fast variant (unsafe : won't check if src contains values beyond count[] limit) */
-size_t FSE_countFast(unsigned* count, unsigned* maxSymbolValuePtr,
-                     const void* source, size_t sourceSize)
-{
-    if (sourceSize < 1500) return FSE_count_simple(count, maxSymbolValuePtr, source, sourceSize);
-    return FSE_count_parallel(count, maxSymbolValuePtr, source, sourceSize, 0);
-}
-
-size_t FSE_count(unsigned* count, unsigned* maxSymbolValuePtr,
-                 const void* source, size_t sourceSize)
-{
-    if (*maxSymbolValuePtr <255)
-        return FSE_count_parallel(count, maxSymbolValuePtr, source, sourceSize, 1);
-    *maxSymbolValuePtr = 255;
-    return FSE_countFast(count, maxSymbolValuePtr, source, sourceSize);
-}
-
-
-
-/*-**************************************************************
-*  FSE Compression Code
-****************************************************************/
-/*! FSE_sizeof_CTable() :
-    FSE_CTable is a variable size structure which contains :
-    `U16 tableLog;`
-    `U16 maxSymbolValue;`
-    `U16 nextStateNumber[1 << tableLog];`                         // This size is variable
-    `FSE_symbolCompressionTransform symbolTT[maxSymbolValue+1];`  // This size is variable
-Allocation is manual (C standard does not support variable-size structures).
-*/
-
-size_t FSE_sizeof_CTable (unsigned maxSymbolValue, unsigned tableLog)
-{
-    size_t size;
-    FSE_STATIC_ASSERT((size_t)FSE_CTABLE_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE)*4 >= sizeof(CTable_max_t));   /* A compilation error here means FSE_CTABLE_SIZE_U32 is not large enough */
-    if (tableLog > FSE_MAX_TABLELOG) return ERROR(GENERIC);
-    size = FSE_CTABLE_SIZE_U32 (tableLog, maxSymbolValue) * sizeof(U32);
-    return size;
-}
-
-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*)malloc(size);
-}
-
-void  FSE_freeCTable (FSE_CTable* ct) { free(ct); }
-
-/* 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)) + 1;
-	U32 minBitsSymbols = BIT_highbit32(maxSymbolValue) + 2;
-	U32 minBits = minBitsSrc < minBitsSymbols ? minBitsSrc : minBitsSymbols;
-	return minBits;
-}
-
-unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue)
-{
-	U32 maxBitsSrc = BIT_highbit32((U32)(srcSize - 1)) - 2;
-    U32 tableLog = maxTableLog;
-	U32 minBits = FSE_minTableLog(srcSize, maxSymbolValue);
-    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;
-}
-
-
-/* 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)
-{
-    U32 s;
-    U32 distributed = 0;
-    U32 ToDistribute;
-
-    /* Init */
-    U32 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) {
-            norm[s] = -1;
-            distributed++;
-            total -= count[s];
-            continue;
-        }
-        if (count[s] <= lowOne) {
-            norm[s] = 1;
-            distributed++;
-            total -= count[s];
-            continue;
-        }
-        norm[s]=-2;
-    }
-    ToDistribute = (1 << tableLog) - distributed;
-
-    if ((total / ToDistribute) > lowOne) {
-        /* risk of rounding to zero */
-        lowOne = (U32)((total * 3) / (ToDistribute * 2));
-        for (s=0; s<=maxSymbolValue; s++) {
-            if ((norm[s] == -2) && (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++)
-            if (count[s] > maxC) maxV=s, maxC=count[s];
-        norm[maxV] += (short)ToDistribute;
-        return 0;
-    }
-
-    {
-        U64 const vStepLog = 62 - tableLog;
-        U64 const mid = (1ULL << (vStepLog-1)) - 1;
-        U64 const rStep = ((((U64)1<<vStepLog) * ToDistribute) + mid) / total;   /* scale on remaining */
-        U64 tmpTotal = mid;
-        for (s=0; s<=maxSymbolValue; s++) {
-            if (norm[s]==-2) {
-                U64 end = tmpTotal + (count[s] * rStep);
-                U32 sStart = (U32)(tmpTotal >> vStepLog);
-                U32 sEnd = (U32)(end >> vStepLog);
-                U32 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,
-                           unsigned maxSymbolValue)
-{
-    /* 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 */
-
-    {   U32 const rtbTable[] = {     0, 473195, 504333, 520860, 550000, 700000, 750000, 830000 };
-
-        U64 const scale = 62 - tableLog;
-        U64 const step = ((U64)1<<62) / 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) {
-                normalizedCounter[s] = -1;
-                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 */
-            size_t errorCode = FSE_normalizeM2(normalizedCounter, tableLog, count, total, maxSymbolValue);
-            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++)
-            printf("%3i: %4i \n", s, normalizedCounter[s]);
-        for (s=0; s<=maxSymbolValue; s++)
-            nTotal += abs(normalizedCounter[s]);
-        if (nTotal != (1U<<tableLog))
-            printf("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;
-}
-
-/* fake FSE_CTable, for rle (100% always same symbol) input */
-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 errorCode = BIT_initCStream(&bitC, dst, dstSize);
-      if (FSE_isError(errorCode)) return 0; }
-
-#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 */
-    for ( ; 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)
-{
-    const unsigned 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); }
-
-size_t FSE_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog)
-{
-    const BYTE* const istart = (const BYTE*) src;
-    const BYTE* ip = istart;
-
-    BYTE* const ostart = (BYTE*) dst;
-    BYTE* op = ostart;
-    BYTE* const oend = ostart + dstSize;
-
-    U32   count[FSE_MAX_SYMBOL_VALUE+1];
-    S16   norm[FSE_MAX_SYMBOL_VALUE+1];
-    CTable_max_t ct;
-    size_t errorCode;
-
-    /* init conditions */
-    if (srcSize <= 1) return 0;  /* Uncompressible */
-    if (!maxSymbolValue) maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
-    if (!tableLog) tableLog = FSE_DEFAULT_TABLELOG;
-
-    /* Scan input and build symbol stats */
-    errorCode = FSE_count (count, &maxSymbolValue, ip, srcSize);
-    if (FSE_isError(errorCode)) return errorCode;
-    if (errorCode == srcSize) return 1;
-    if (errorCode == 1) return 0;   /* each symbol only present once */
-    if (errorCode < (srcSize >> 7)) return 0;   /* Heuristic : not compressible enough */
-
-    tableLog = FSE_optimalTableLog(tableLog, srcSize, maxSymbolValue);
-    errorCode = FSE_normalizeCount (norm, tableLog, count, srcSize, maxSymbolValue);
-    if (FSE_isError(errorCode)) return errorCode;
-
-    /* Write table description header */
-    errorCode = FSE_writeNCount (op, oend-op, norm, maxSymbolValue, tableLog);
-    if (FSE_isError(errorCode)) return errorCode;
-    op += errorCode;
-
-    /* Compress */
-    errorCode = FSE_buildCTable (ct, norm, maxSymbolValue, tableLog);
-    if (FSE_isError(errorCode)) return errorCode;
-    errorCode = FSE_compress_usingCTable(op, oend - op, ip, srcSize, ct);
-    if (errorCode == 0) return 0;   /* not enough space for compressed data */
-    op += errorCode;
-
-    /* check compressibility */
-    if ( (size_t)(op-ostart) >= srcSize-1 )
-        return 0;
-
-    return op-ostart;
-}
-
-size_t FSE_compress (void* dst, size_t dstSize, const void* src, size_t srcSize)
-{
-    return FSE_compress2(dst, dstSize, src, (U32)srcSize, FSE_MAX_SYMBOL_VALUE, FSE_DEFAULT_TABLELOG);
-}
-
-
-#endif   /* FSE_COMMONDEFS_ONLY */
+/* ****************************************************************** 
+   FSE : Finite State Entropy encoder 
+   Copyright (C) 2013-2015, Yann Collet. 
+ 
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+   Redistribution and use in source and binary forms, with or without 
+   modification, are permitted provided that the following conditions are 
+   met: 
+ 
+       * Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer. 
+       * Redistributions in binary form must reproduce the above 
+   copyright notice, this list of conditions and the following disclaimer 
+   in the documentation and/or other materials provided with the 
+   distribution. 
+ 
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+    You can contact the author at : 
+    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy 
+    - Public forum : https://groups.google.com/forum/#!forum/lz4c 
+****************************************************************** */ 
+ 
+/* ************************************************************** 
+*  Compiler specifics 
+****************************************************************/ 
+#ifdef _MSC_VER    /* Visual Studio */ 
+#  define FORCE_INLINE static __forceinline 
+#  include <intrin.h>                    /* For Visual 2005 */ 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */ 
+#else 
+#  ifdef __GNUC__ 
+#    define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) 
+#    define FORCE_INLINE static inline __attribute__((always_inline)) 
+#  else 
+#    define FORCE_INLINE static inline 
+#  endif 
+#endif 
+ 
+ 
+/* ************************************************************** 
+*  Includes 
+****************************************************************/ 
+#include <stdlib.h>     /* malloc, free, qsort */ 
+#include <string.h>     /* memcpy, memset */ 
+#include <stdio.h>      /* printf (debug) */ 
+#include "bitstream.h" 
+#include "fse_static.h" 
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */ 
+ 
+ 
+/* ************************************************************** 
+*  Complex types 
+****************************************************************/ 
+typedef U32 CTable_max_t[FSE_CTABLE_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE)]; 
+ 
+ 
+/* ************************************************************** 
+*  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 */ 
+size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog) 
+{ 
+    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 cumul[FSE_MAX_SYMBOL_VALUE+2]; 
+ 
+    FSE_FUNCTION_TYPE tableSymbol[FSE_MAX_TABLESIZE]; /* memset() is not necessary, even if static analyzer complain about it */ 
+    U32 highThreshold = tableSize-1; 
+ 
+    /* CTable header */ 
+ 
+ 
+    tableU16[-2] = (U16) tableLog; 
+    tableU16[-1] = (U16) maxSymbolValue; 
+ 
+    /* For explanations on how to distribute symbol values over the table : 
+    *  http://fastcompression.blogspot.fr/2014/02/fse-distributing-symbol-values.html */ 
+ 
+    /* symbol start positions */ 
+    {   U32 u; 
+        cumul[0] = 0; 
+        for (u=1; u<=maxSymbolValue+1; u++) { 
+            if (normalizedCounter[u-1]==-1) {  /* Low proba symbol */ 
+                cumul[u] = cumul[u-1] + 1; 
+                tableSymbol[highThreshold--] = (FSE_FUNCTION_TYPE)(u-1); 
+            } else { 
+                cumul[u] = cumul[u-1] + normalizedCounter[u-1]; 
+        }   } 
+        cumul[maxSymbolValue+1] = tableSize+1; 
+    } 
+ 
+    /* Spread symbols */ 
+    {   U32 position = 0; 
+        U32 symbol; 
+        for (symbol=0; symbol<=maxSymbolValue; symbol++) { 
+            int nbOccurences; 
+            for (nbOccurences=0; nbOccurences<normalizedCounter[symbol]; nbOccurences++) { 
+                tableSymbol[position] = (FSE_FUNCTION_TYPE)symbol; 
+                position = (position + step) & tableMask; 
+                while (position > highThreshold) position = (position + step) & tableMask;   /* Low proba area */ 
+        }   } 
+ 
+        if (position!=0) return ERROR(GENERIC);   /* Must have gone through 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]) 
+            { 
+            case  0: break; 
+ 
+            case -1: 
+            case  1: 
+                symbolTT[s].deltaNbBits = (tableLog << 16) - (1<<tableLog); 
+                symbolTT[s].deltaFindState = total - 1; 
+                total ++; 
+                break; 
+            default : 
+                { 
+                    U32 const maxBitsOut = tableLog - BIT_highbit32 (normalizedCounter[s]-1); 
+                    U32 const minStatePlus = normalizedCounter[s] << maxBitsOut; 
+                    symbolTT[s].deltaNbBits = (maxBitsOut << 16) - minStatePlus; 
+                    symbolTT[s].deltaFindState = total - normalizedCounter[s]; 
+                    total +=  normalizedCounter[s]; 
+    }   }   }   } 
+ 
+    return 0; 
+} 
+ 
+ 
+ 
+#ifndef FSE_COMMONDEFS_ONLY 
+ 
+/*-************************************************************** 
+*  FSE NCount encoding-decoding 
+****************************************************************/ 
+size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog) 
+{ 
+    size_t maxHeaderSize = (((maxSymbolValue+1) * tableLog) >> 3) + 3; 
+    return maxSymbolValue ? maxHeaderSize : FSE_NCOUNTBOUND;  /* maxSymbolValue==0 ? use default */ 
+} 
+ 
+static short FSE_abs(short a) { return a<0 ? -a : a; } 
+ 
+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; 
+    U32 bitStream; 
+    int bitCount; 
+    unsigned charnum = 0; 
+    int previous0 = 0; 
+ 
+    bitStream = 0; 
+    bitCount  = 0; 
+    /* Table Size */ 
+    bitStream += (tableLog-FSE_MIN_TABLELOG) << bitCount; 
+    bitCount  += 4; 
+ 
+    /* Init */ 
+    remaining = tableSize+1;   /* +1 for extra accuracy */ 
+    threshold = tableSize; 
+    nbBits = tableLog+1; 
+ 
+    while (remaining>1) {  /* stops at 1 */ 
+        if (previous0) { 
+            unsigned start = charnum; 
+            while (!normalizedCounter[charnum]) charnum++; 
+            while (charnum >= start+24) { 
+                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; 
+            } 
+            while (charnum >= start+3) { 
+                start+=3; 
+                bitStream += 3 << bitCount; 
+                bitCount += 2; 
+            } 
+            bitStream += (charnum-start) << bitCount; 
+            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; 
+        }   } 
+        {   short count = normalizedCounter[charnum++]; 
+            const short max = (short)((2*threshold-1)-remaining); 
+            remaining -= FSE_abs(count); 
+            if (remaining<1) return ERROR(GENERIC); 
+            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); 
+            previous0 = (count==1); 
+            while (remaining<threshold) nbBits--, threshold>>=1; 
+        } 
+        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; 
+    }   } 
+ 
+    /* 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; 
+ 
+    if (charnum > maxSymbolValue + 1) return ERROR(GENERIC); 
+ 
+    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(GENERIC);   /* 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); 
+ 
+    return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 1); 
+} 
+ 
+ 
+ 
+/*-************************************************************** 
+*  Counting histogram 
+****************************************************************/ 
+/*! FSE_count_simple 
+    This function just counts byte values within `src`, 
+    and store the histogram into table `count`. 
+    This function is unsafe : it doesn't check that all values within `src` can fit into `count`. 
+    For this reason, prefer using a table `count` with 256 elements. 
+    @return : count of most numerous element 
+*/ 
+static size_t FSE_count_simple(unsigned* count, unsigned* maxSymbolValuePtr, 
+                               const void* src, size_t srcSize) 
+{ 
+    const BYTE* ip = (const BYTE*)src; 
+    const BYTE* const end = ip + srcSize; 
+    unsigned maxSymbolValue = *maxSymbolValuePtr; 
+    unsigned max=0; 
+ 
+ 
+    memset(count, 0, (maxSymbolValue+1)*sizeof(*count)); 
+    if (srcSize==0) { *maxSymbolValuePtr = 0; return 0; } 
+ 
+    while (ip<end) count[*ip++]++; 
+ 
+    while (!count[maxSymbolValue]) maxSymbolValue--; 
+    *maxSymbolValuePtr = maxSymbolValue; 
+ 
+    { U32 s; for (s=0; s<=maxSymbolValue; s++) if (count[s] > max) max = count[s]; } 
+ 
+    return (size_t)max; 
+} 
+ 
+ 
+static size_t FSE_count_parallel(unsigned* count, unsigned* maxSymbolValuePtr, 
+                                const void* source, size_t sourceSize, 
+                                unsigned checkMax) 
+{ 
+    const BYTE* ip = (const BYTE*)source; 
+    const BYTE* const iend = ip+sourceSize; 
+    unsigned maxSymbolValue = *maxSymbolValuePtr; 
+    unsigned max=0; 
+ 
+ 
+    U32 Counting1[256] = { 0 }; 
+    U32 Counting2[256] = { 0 }; 
+    U32 Counting3[256] = { 0 }; 
+    U32 Counting4[256] = { 0 }; 
+ 
+    /* safety checks */ 
+    if (!sourceSize) { 
+        memset(count, 0, maxSymbolValue + 1); 
+        *maxSymbolValuePtr = 0; 
+        return 0; 
+    } 
+    if (!maxSymbolValue) maxSymbolValue = 255;            /* 0 == default */ 
+ 
+    /* by stripes of 16 bytes */ 
+    {   U32 cached = MEM_read32(ip); ip += 4; 
+        while (ip < iend-15) { 
+            U32 c = cached; cached = MEM_read32(ip); ip += 4; 
+            Counting1[(BYTE) c     ]++; 
+            Counting2[(BYTE)(c>>8) ]++; 
+            Counting3[(BYTE)(c>>16)]++; 
+            Counting4[       c>>24 ]++; 
+            c = cached; cached = MEM_read32(ip); ip += 4; 
+            Counting1[(BYTE) c     ]++; 
+            Counting2[(BYTE)(c>>8) ]++; 
+            Counting3[(BYTE)(c>>16)]++; 
+            Counting4[       c>>24 ]++; 
+            c = cached; cached = MEM_read32(ip); ip += 4; 
+            Counting1[(BYTE) c     ]++; 
+            Counting2[(BYTE)(c>>8) ]++; 
+            Counting3[(BYTE)(c>>16)]++; 
+            Counting4[       c>>24 ]++; 
+            c = cached; cached = MEM_read32(ip); ip += 4; 
+            Counting1[(BYTE) c     ]++; 
+            Counting2[(BYTE)(c>>8) ]++; 
+            Counting3[(BYTE)(c>>16)]++; 
+            Counting4[       c>>24 ]++; 
+        } 
+        ip-=4; 
+    } 
+ 
+    /* finish last symbols */ 
+    while (ip<iend) Counting1[*ip++]++; 
+ 
+    if (checkMax) {   /* verify stats will fit into destination table */ 
+        U32 s; for (s=255; s>maxSymbolValue; s--) { 
+            Counting1[s] += Counting2[s] + Counting3[s] + Counting4[s]; 
+            if (Counting1[s]) return ERROR(maxSymbolValue_tooSmall); 
+    }   } 
+ 
+    { U32 s; for (s=0; s<=maxSymbolValue; s++) { 
+        count[s] = Counting1[s] + Counting2[s] + Counting3[s] + Counting4[s]; 
+        if (count[s] > max) max = count[s]; 
+    }} 
+ 
+    while (!count[maxSymbolValue]) maxSymbolValue--; 
+    *maxSymbolValuePtr = maxSymbolValue; 
+    return (size_t)max; 
+} 
+ 
+/* fast variant (unsafe : won't check if src contains values beyond count[] limit) */ 
+size_t FSE_countFast(unsigned* count, unsigned* maxSymbolValuePtr, 
+                     const void* source, size_t sourceSize) 
+{ 
+    if (sourceSize < 1500) return FSE_count_simple(count, maxSymbolValuePtr, source, sourceSize); 
+    return FSE_count_parallel(count, maxSymbolValuePtr, source, sourceSize, 0); 
+} 
+ 
+size_t FSE_count(unsigned* count, unsigned* maxSymbolValuePtr, 
+                 const void* source, size_t sourceSize) 
+{ 
+    if (*maxSymbolValuePtr <255) 
+        return FSE_count_parallel(count, maxSymbolValuePtr, source, sourceSize, 1); 
+    *maxSymbolValuePtr = 255; 
+    return FSE_countFast(count, maxSymbolValuePtr, source, sourceSize); 
+} 
+ 
+ 
+ 
+/*-************************************************************** 
+*  FSE Compression Code 
+****************************************************************/ 
+/*! FSE_sizeof_CTable() : 
+    FSE_CTable is a variable size structure which contains : 
+    `U16 tableLog;` 
+    `U16 maxSymbolValue;` 
+    `U16 nextStateNumber[1 << tableLog];`                         // This size is variable 
+    `FSE_symbolCompressionTransform symbolTT[maxSymbolValue+1];`  // This size is variable 
+Allocation is manual (C standard does not support variable-size structures). 
+*/ 
+ 
+size_t FSE_sizeof_CTable (unsigned maxSymbolValue, unsigned tableLog) 
+{ 
+    size_t size; 
+    FSE_STATIC_ASSERT((size_t)FSE_CTABLE_SIZE_U32(FSE_MAX_TABLELOG, FSE_MAX_SYMBOL_VALUE)*4 >= sizeof(CTable_max_t));   /* A compilation error here means FSE_CTABLE_SIZE_U32 is not large enough */ 
+    if (tableLog > FSE_MAX_TABLELOG) return ERROR(GENERIC); 
+    size = FSE_CTABLE_SIZE_U32 (tableLog, maxSymbolValue) * sizeof(U32); 
+    return size; 
+} 
+ 
+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*)malloc(size); 
+} 
+ 
+void  FSE_freeCTable (FSE_CTable* ct) { free(ct); } 
+ 
+/* 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)) + 1; 
+	U32 minBitsSymbols = BIT_highbit32(maxSymbolValue) + 2; 
+	U32 minBits = minBitsSrc < minBitsSymbols ? minBitsSrc : minBitsSymbols; 
+	return minBits; 
+} 
+ 
+unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue) 
+{ 
+	U32 maxBitsSrc = BIT_highbit32((U32)(srcSize - 1)) - 2; 
+    U32 tableLog = maxTableLog; 
+	U32 minBits = FSE_minTableLog(srcSize, maxSymbolValue); 
+    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; 
+} 
+ 
+ 
+/* 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) 
+{ 
+    U32 s; 
+    U32 distributed = 0; 
+    U32 ToDistribute; 
+ 
+    /* Init */ 
+    U32 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) { 
+            norm[s] = -1; 
+            distributed++; 
+            total -= count[s]; 
+            continue; 
+        } 
+        if (count[s] <= lowOne) { 
+            norm[s] = 1; 
+            distributed++; 
+            total -= count[s]; 
+            continue; 
+        } 
+        norm[s]=-2; 
+    } 
+    ToDistribute = (1 << tableLog) - distributed; 
+ 
+    if ((total / ToDistribute) > lowOne) { 
+        /* risk of rounding to zero */ 
+        lowOne = (U32)((total * 3) / (ToDistribute * 2)); 
+        for (s=0; s<=maxSymbolValue; s++) { 
+            if ((norm[s] == -2) && (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++) 
+            if (count[s] > maxC) maxV=s, maxC=count[s]; 
+        norm[maxV] += (short)ToDistribute; 
+        return 0; 
+    } 
+ 
+    { 
+        U64 const vStepLog = 62 - tableLog; 
+        U64 const mid = (1ULL << (vStepLog-1)) - 1; 
+        U64 const rStep = ((((U64)1<<vStepLog) * ToDistribute) + mid) / total;   /* scale on remaining */ 
+        U64 tmpTotal = mid; 
+        for (s=0; s<=maxSymbolValue; s++) { 
+            if (norm[s]==-2) { 
+                U64 end = tmpTotal + (count[s] * rStep); 
+                U32 sStart = (U32)(tmpTotal >> vStepLog); 
+                U32 sEnd = (U32)(end >> vStepLog); 
+                U32 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, 
+                           unsigned maxSymbolValue) 
+{ 
+    /* 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 */ 
+ 
+    {   U32 const rtbTable[] = {     0, 473195, 504333, 520860, 550000, 700000, 750000, 830000 }; 
+ 
+        U64 const scale = 62 - tableLog; 
+        U64 const step = ((U64)1<<62) / 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) { 
+                normalizedCounter[s] = -1; 
+                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 */ 
+            size_t errorCode = FSE_normalizeM2(normalizedCounter, tableLog, count, total, maxSymbolValue); 
+            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++) 
+            printf("%3i: %4i \n", s, normalizedCounter[s]); 
+        for (s=0; s<=maxSymbolValue; s++) 
+            nTotal += abs(normalizedCounter[s]); 
+        if (nTotal != (1U<<tableLog)) 
+            printf("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; 
+} 
+ 
+/* fake FSE_CTable, for rle (100% always same symbol) input */ 
+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 errorCode = BIT_initCStream(&bitC, dst, dstSize); 
+      if (FSE_isError(errorCode)) return 0; } 
+ 
+#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 */ 
+    for ( ; 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) 
+{ 
+    const unsigned 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); } 
+ 
+size_t FSE_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog) 
+{ 
+    const BYTE* const istart = (const BYTE*) src; 
+    const BYTE* ip = istart; 
+ 
+    BYTE* const ostart = (BYTE*) dst; 
+    BYTE* op = ostart; 
+    BYTE* const oend = ostart + dstSize; 
+ 
+    U32   count[FSE_MAX_SYMBOL_VALUE+1]; 
+    S16   norm[FSE_MAX_SYMBOL_VALUE+1]; 
+    CTable_max_t ct; 
+    size_t errorCode; 
+ 
+    /* init conditions */ 
+    if (srcSize <= 1) return 0;  /* Uncompressible */ 
+    if (!maxSymbolValue) maxSymbolValue = FSE_MAX_SYMBOL_VALUE; 
+    if (!tableLog) tableLog = FSE_DEFAULT_TABLELOG; 
+ 
+    /* Scan input and build symbol stats */ 
+    errorCode = FSE_count (count, &maxSymbolValue, ip, srcSize); 
+    if (FSE_isError(errorCode)) return errorCode; 
+    if (errorCode == srcSize) return 1; 
+    if (errorCode == 1) return 0;   /* each symbol only present once */ 
+    if (errorCode < (srcSize >> 7)) return 0;   /* Heuristic : not compressible enough */ 
+ 
+    tableLog = FSE_optimalTableLog(tableLog, srcSize, maxSymbolValue); 
+    errorCode = FSE_normalizeCount (norm, tableLog, count, srcSize, maxSymbolValue); 
+    if (FSE_isError(errorCode)) return errorCode; 
+ 
+    /* Write table description header */ 
+    errorCode = FSE_writeNCount (op, oend-op, norm, maxSymbolValue, tableLog); 
+    if (FSE_isError(errorCode)) return errorCode; 
+    op += errorCode; 
+ 
+    /* Compress */ 
+    errorCode = FSE_buildCTable (ct, norm, maxSymbolValue, tableLog); 
+    if (FSE_isError(errorCode)) return errorCode; 
+    errorCode = FSE_compress_usingCTable(op, oend - op, ip, srcSize, ct); 
+    if (errorCode == 0) return 0;   /* not enough space for compressed data */ 
+    op += errorCode; 
+ 
+    /* check compressibility */ 
+    if ( (size_t)(op-ostart) >= srcSize-1 ) 
+        return 0; 
+ 
+    return op-ostart; 
+} 
+ 
+size_t FSE_compress (void* dst, size_t dstSize, const void* src, size_t srcSize) 
+{ 
+    return FSE_compress2(dst, dstSize, src, (U32)srcSize, FSE_MAX_SYMBOL_VALUE, FSE_DEFAULT_TABLELOG); 
+} 
+ 
+ 
+#endif   /* FSE_COMMONDEFS_ONLY */ 
diff --git a/contrib/libs/zstd06/compress/huf_compress.c b/contrib/libs/zstd06/compress/huf_compress.c
index d126305c6f..a110d86719 100644
--- a/contrib/libs/zstd06/compress/huf_compress.c
+++ b/contrib/libs/zstd06/compress/huf_compress.c
@@ -1,560 +1,560 @@
-/* ******************************************************************
-   Huffman encoder, 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 */
-#  define FORCE_INLINE static __forceinline
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#else
-#  ifdef __GNUC__
-#    define FORCE_INLINE static inline __attribute__((always_inline))
-#  else
-#    define FORCE_INLINE static inline
-#  endif
-#endif
-
-
-/* **************************************************************
-*  Includes
-****************************************************************/
-#include <stdlib.h>     /* malloc, free, qsort */
-#include <string.h>     /* memcpy, memset */
-#include <stdio.h>      /* printf (debug) */
-#include "huf_static.h"
-#include "bitstream.h"
-#include "fse.h"        /* header compression */
-
-
-/* **************************************************************
-*  Error Management
-****************************************************************/
-#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-
-
-/* *******************************************************
-*  HUF : Huffman block compression
-*********************************************************/
-struct HUF_CElt_s {
-  U16  val;
-  BYTE nbBits;
-};   /* typedef'd to HUF_CElt within huf_static.h */
-
-typedef struct nodeElt_s {
-    U32 count;
-    U16 parent;
-    BYTE byte;
-    BYTE nbBits;
-} nodeElt;
-
-/*! HUF_writeCTable() :
-    `CTable` : huffman tree to save, using huf representation.
-    @return : size of saved CTable */
-size_t HUF_writeCTable (void* dst, size_t maxDstSize,
-                        const HUF_CElt* CTable, U32 maxSymbolValue, U32 huffLog)
-{
-    BYTE bitsToWeight[HUF_MAX_TABLELOG + 1];
-    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1];
-    U32 n;
-    BYTE* op = (BYTE*)dst;
-    size_t size;
-
-     /* check conditions */
-    if (maxSymbolValue > HUF_MAX_SYMBOL_VALUE + 1)
-        return ERROR(GENERIC);
-
-    /* convert to weight */
-    bitsToWeight[0] = 0;
-    for (n=1; n<=huffLog; n++)
-        bitsToWeight[n] = (BYTE)(huffLog + 1 - n);
-    for (n=0; n<maxSymbolValue; n++)
-        huffWeight[n] = bitsToWeight[CTable[n].nbBits];
-
-    size = FSE_compress(op+1, maxDstSize-1, huffWeight, maxSymbolValue);   /* don't need last symbol stat : implied */
-    if (HUF_isError(size)) return size;
-    if (size >= 128) return ERROR(GENERIC);   /* should never happen, since maxSymbolValue <= 255 */
-    if ((size <= 1) || (size >= maxSymbolValue/2)) {
-        if (size==1) {  /* RLE */
-            /* only possible case : serie of 1 (because there are at least 2) */
-            /* can only be 2^n or (2^n-1), otherwise not an huffman tree */
-            BYTE code;
-            switch(maxSymbolValue)
-            {
-            case 1: code = 0; break;
-            case 2: code = 1; break;
-            case 3: code = 2; break;
-            case 4: code = 3; break;
-            case 7: code = 4; break;
-            case 8: code = 5; break;
-            case 15: code = 6; break;
-            case 16: code = 7; break;
-            case 31: code = 8; break;
-            case 32: code = 9; break;
-            case 63: code = 10; break;
-            case 64: code = 11; break;
-            case 127: code = 12; break;
-            case 128: code = 13; break;
-            default : return ERROR(corruption_detected);
-            }
-            op[0] = (BYTE)(255-13 + code);
-            return 1;
-        }
-         /* Not compressible */
-        if (maxSymbolValue > (241-128)) return ERROR(GENERIC);   /* not implemented (not possible with current format) */
-        if (((maxSymbolValue+1)/2) + 1 > maxDstSize) return ERROR(dstSize_tooSmall);   /* not enough space within dst buffer */
-        op[0] = (BYTE)(128 /*special case*/ + 0 /* Not Compressible */ + (maxSymbolValue-1));
-        huffWeight[maxSymbolValue] = 0;   /* to be sure it doesn't cause issue in final combination */
-        for (n=0; n<maxSymbolValue; n+=2)
-            op[(n/2)+1] = (BYTE)((huffWeight[n] << 4) + huffWeight[n+1]);
-        return ((maxSymbolValue+1)/2) + 1;
-    }
-
-    /* normal header case */
-    op[0] = (BYTE)size;
-    return size+1;
-}
-
-
-
-size_t HUF_readCTable (HUF_CElt* CTable, U32 maxSymbolValue, 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 readSize;
-    U32 nbSymbols = 0;
-    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */
-
-    /* get symbol weights */
-    readSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE+1, rankVal, &nbSymbols, &tableLog, src, srcSize);
-    if (HUF_isError(readSize)) return readSize;
-
-    /* check result */
-    if (tableLog > HUF_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
-    if (nbSymbols > maxSymbolValue+1) return ERROR(maxSymbolValue_tooSmall);
-
-    /* Prepare base value per rank */
-    {   U32 n, nextRankStart = 0;
-        for (n=1; n<=tableLog; n++) {
-            U32 current = nextRankStart;
-            nextRankStart += (rankVal[n] << (n-1));
-            rankVal[n] = current;
-    }   }
-
-    /* fill nbBits */
-    { U32 n; for (n=0; n<nbSymbols; n++) {
-        const U32 w = huffWeight[n];
-        CTable[n].nbBits = (BYTE)(tableLog + 1 - w);
-    }}
-
-    /* fill val */
-    {   U16 nbPerRank[HUF_MAX_TABLELOG+1] = {0};
-        U16 valPerRank[HUF_MAX_TABLELOG+1] = {0};
-        { U32 n; for (n=0; n<nbSymbols; n++) nbPerRank[CTable[n].nbBits]++; }
-        /* determine stating value per rank */
-        {   U16 min = 0;
-            U32 n; for (n=HUF_MAX_TABLELOG; n>0; n--) {
-                valPerRank[n] = min;      /* get starting value within each rank */
-                min += nbPerRank[n];
-                min >>= 1;
-        }   }
-        /* assign value within rank, symbol order */
-        { U32 n; for (n=0; n<=maxSymbolValue; n++) CTable[n].val = valPerRank[CTable[n].nbBits]++; }
-    }
-
-    return readSize;
-}
-
-
-static U32 HUF_setMaxHeight(nodeElt* huffNode, U32 lastNonNull, U32 maxNbBits)
-{
-    const U32 largestBits = huffNode[lastNonNull].nbBits;
-    if (largestBits <= maxNbBits) return largestBits;   /* early exit : no elt > maxNbBits */
-
-    /* there are several too large elements (at least >= 2) */
-    {   int totalCost = 0;
-        const U32 baseCost = 1 << (largestBits - maxNbBits);
-        U32 n = lastNonNull;
-
-        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 */
-        while (huffNode[n].nbBits == maxNbBits) n--;   /* n end at index of smallest symbol using < maxNbBits */
-
-        /* renorm totalCost */
-        totalCost >>= (largestBits - maxNbBits);  /* note : totalCost is necessarily a multiple of baseCost */
-
-        /* repay normalized cost */
-        {   U32 const noSymbol = 0xF0F0F0F0;
-            U32 rankLast[HUF_MAX_TABLELOG+1];
-            int pos;
-
-            /* Get pos of last (smallest) symbol per rank */
-            memset(rankLast, 0xF0, sizeof(rankLast));
-            {   U32 currentNbBits = maxNbBits;
-                for (pos=n ; pos >= 0; pos--) {
-                    if (huffNode[pos].nbBits >= currentNbBits) continue;
-                    currentNbBits = huffNode[pos].nbBits;   /* < maxNbBits */
-                    rankLast[maxNbBits-currentNbBits] = pos;
-            }   }
-
-            while (totalCost > 0) {
-                U32 nBitsToDecrease = BIT_highbit32(totalCost) + 1;
-                for ( ; nBitsToDecrease > 1; nBitsToDecrease--) {
-                    U32 highPos = rankLast[nBitsToDecrease];
-                    U32 lowPos = rankLast[nBitsToDecrease-1];
-                    if (highPos == noSymbol) continue;
-                    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 !) */
-                while ((nBitsToDecrease<=HUF_MAX_TABLELOG) && (rankLast[nBitsToDecrease] == noSymbol))  /* HUF_MAX_TABLELOG test just to please gcc 5+; but it should not be necessary */
-                    nBitsToDecrease ++;
-                totalCost -= 1 << (nBitsToDecrease-1);
-                if (rankLast[nBitsToDecrease-1] == noSymbol)
-                    rankLast[nBitsToDecrease-1] = rankLast[nBitsToDecrease];   /* this rank is no longer empty */
-                huffNode[rankLast[nBitsToDecrease]].nbBits ++;
-                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) */
-
-            while (totalCost < 0) {  /* Sometimes, cost correction overshoot */
-                if (rankLast[1] == noSymbol) {  /* special case : no rank 1 symbol (using maxNbBits-1); let's create one from largest rank 0 (using maxNbBits) */
-                    while (huffNode[n].nbBits == maxNbBits) n--;
-                    huffNode[n+1].nbBits--;
-                    rankLast[1] = n+1;
-                    totalCost++;
-                    continue;
-                }
-                huffNode[ rankLast[1] + 1 ].nbBits--;
-                rankLast[1]++;
-                totalCost ++;
-    }   }   }   /* there are several too large elements (at least >= 2) */
-
-    return maxNbBits;
-}
-
-
-typedef struct {
-    U32 base;
-    U32 current;
-} rankPos;
-
-static void HUF_sort(nodeElt* huffNode, const U32* count, U32 maxSymbolValue)
-{
-    rankPos rank[32];
-    U32 n;
-
-    memset(rank, 0, sizeof(rank));
-    for (n=0; n<=maxSymbolValue; n++) {
-        U32 r = BIT_highbit32(count[n] + 1);
-        rank[r].base ++;
-    }
-    for (n=30; n>0; n--) rank[n-1].base += rank[n].base;
-    for (n=0; n<32; n++) rank[n].current = rank[n].base;
-    for (n=0; n<=maxSymbolValue; n++) {
-        U32 const c = count[n];
-        U32 const r = BIT_highbit32(c+1) + 1;
-        U32 pos = rank[r].current++;
-        while ((pos > rank[r].base) && (c > huffNode[pos-1].count)) huffNode[pos]=huffNode[pos-1], pos--;
-        huffNode[pos].count = c;
-        huffNode[pos].byte  = (BYTE)n;
-    }
-}
-
-
-#define STARTNODE (HUF_MAX_SYMBOL_VALUE+1)
-size_t HUF_buildCTable (HUF_CElt* tree, const U32* count, U32 maxSymbolValue, U32 maxNbBits)
-{
-    nodeElt huffNode0[2*HUF_MAX_SYMBOL_VALUE+1 +1];
-    nodeElt* huffNode = huffNode0 + 1;
-    U32 n, nonNullRank;
-    int lowS, lowN;
-    U16 nodeNb = STARTNODE;
-    U32 nodeRoot;
-
-    /* safety checks */
-    if (maxNbBits == 0) maxNbBits = HUF_DEFAULT_TABLELOG;
-    if (maxSymbolValue > HUF_MAX_SYMBOL_VALUE) return ERROR(GENERIC);
-    memset(huffNode0, 0, sizeof(huffNode0));
-
-    /* sort, decreasing order */
-    HUF_sort(huffNode, count, maxSymbolValue);
-
-    /* init for parents */
-    nonNullRank = 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;
-    huffNode[lowS].parent = huffNode[lowS-1].parent = nodeNb;
-    nodeNb++; lowS-=2;
-    for (n=nodeNb; n<=nodeRoot; n++) huffNode[n].count = (U32)(1U<<30);
-    huffNode0[0].count = (U32)(1U<<31);
-
-    /* create parents */
-    while (nodeNb <= nodeRoot) {
-        U32 n1 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++;
-        U32 n2 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++;
-        huffNode[nodeNb].count = huffNode[n1].count + huffNode[n2].count;
-        huffNode[n1].parent = huffNode[n2].parent = 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;
-
-    /* enforce maxTableLog */
-    maxNbBits = HUF_setMaxHeight(huffNode, nonNullRank, maxNbBits);
-
-    /* fill result into tree (val, nbBits) */
-    {   U16 nbPerRank[HUF_MAX_TABLELOG+1] = {0};
-        U16 valPerRank[HUF_MAX_TABLELOG+1] = {0};
-        if (maxNbBits > HUF_MAX_TABLELOG) return ERROR(GENERIC);   /* check fit into table */
-        for (n=0; n<=nonNullRank; n++)
-            nbPerRank[huffNode[n].nbBits]++;
-        /* determine stating value per rank */
-        {   U16 min = 0;
-            for (n=maxNbBits; n>0; n--) {
-                valPerRank[n] = min;      /* get starting value within each rank */
-                min += nbPerRank[n];
-                min >>= 1;
-        }   }
-        for (n=0; n<=maxSymbolValue; n++)
-            tree[huffNode[n].byte].nbBits = huffNode[n].nbBits;   /* push nbBits per symbol, symbol order */
-        for (n=0; n<=maxSymbolValue; n++)
-            tree[n].val = valPerRank[tree[n].nbBits]++;   /* assign value within rank, symbol order */
-    }
-
-    return maxNbBits;
-}
-
-static void HUF_encodeSymbol(BIT_CStream_t* bitCPtr, U32 symbol, const HUF_CElt* CTable)
-{
-    BIT_addBitsFast(bitCPtr, CTable[symbol].val, CTable[symbol].nbBits);
-}
-
-size_t HUF_compressBound(size_t size) { return HUF_COMPRESSBOUND(size); }
-
-#define HUF_FLUSHBITS(s)  (fast ? BIT_flushBitsFast(s) : BIT_flushBits(s))
-
-#define HUF_FLUSHBITS_1(stream) \
-    if (sizeof((stream)->bitContainer)*8 < HUF_MAX_TABLELOG*2+7) HUF_FLUSHBITS(stream)
-
-#define HUF_FLUSHBITS_2(stream) \
-    if (sizeof((stream)->bitContainer)*8 < HUF_MAX_TABLELOG*4+7) HUF_FLUSHBITS(stream)
-
-size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable)
-{
-    const BYTE* ip = (const BYTE*) src;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + dstSize;
-    BYTE* op = ostart;
-    size_t n;
-    const unsigned fast = (dstSize >= HUF_BLOCKBOUND(srcSize));
-    BIT_CStream_t bitC;
-
-    /* init */
-    if (dstSize < 8) return 0;   /* not enough space to compress */
-    { size_t const errorCode = BIT_initCStream(&bitC, op, oend-op);
-      if (HUF_isError(errorCode)) return 0; }
-
-    n = srcSize & ~3;  /* join to mod 4 */
-    switch (srcSize & 3)
-    {
-        case 3 : HUF_encodeSymbol(&bitC, ip[n+ 2], CTable);
-                 HUF_FLUSHBITS_2(&bitC);
-        case 2 : HUF_encodeSymbol(&bitC, ip[n+ 1], CTable);
-                 HUF_FLUSHBITS_1(&bitC);
-        case 1 : HUF_encodeSymbol(&bitC, ip[n+ 0], CTable);
-                 HUF_FLUSHBITS(&bitC);
-        case 0 :
-        default: ;
-    }
-
-    for (; n>0; n-=4) {  /* note : n&3==0 at this stage */
-        HUF_encodeSymbol(&bitC, ip[n- 1], CTable);
-        HUF_FLUSHBITS_1(&bitC);
-        HUF_encodeSymbol(&bitC, ip[n- 2], CTable);
-        HUF_FLUSHBITS_2(&bitC);
-        HUF_encodeSymbol(&bitC, ip[n- 3], CTable);
-        HUF_FLUSHBITS_1(&bitC);
-        HUF_encodeSymbol(&bitC, ip[n- 4], CTable);
-        HUF_FLUSHBITS(&bitC);
-    }
-
-    return BIT_closeCStream(&bitC);
-}
-
-
-size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable)
-{
-    size_t 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;
-    size_t errorCode;
-
-    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 */
-
-    errorCode = HUF_compress1X_usingCTable(op, oend-op, ip, segmentSize, CTable);
-    if (HUF_isError(errorCode)) return errorCode;
-    if (errorCode==0) return 0;
-    MEM_writeLE16(ostart, (U16)errorCode);
-
-    ip += segmentSize;
-    op += errorCode;
-    errorCode = HUF_compress1X_usingCTable(op, oend-op, ip, segmentSize, CTable);
-    if (HUF_isError(errorCode)) return errorCode;
-    if (errorCode==0) return 0;
-    MEM_writeLE16(ostart+2, (U16)errorCode);
-
-    ip += segmentSize;
-    op += errorCode;
-    errorCode = HUF_compress1X_usingCTable(op, oend-op, ip, segmentSize, CTable);
-    if (HUF_isError(errorCode)) return errorCode;
-    if (errorCode==0) return 0;
-    MEM_writeLE16(ostart+4, (U16)errorCode);
-
-    ip += segmentSize;
-    op += errorCode;
-    errorCode = HUF_compress1X_usingCTable(op, oend-op, ip, iend-ip, CTable);
-    if (HUF_isError(errorCode)) return errorCode;
-    if (errorCode==0) return 0;
-
-    op += errorCode;
-    return op-ostart;
-}
-
-
-static size_t HUF_compress_internal (
-                void* dst, size_t dstSize,
-                const void* src, size_t srcSize,
-                unsigned maxSymbolValue, unsigned huffLog,
-                unsigned singleStream)
-{
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + dstSize;
-    BYTE* op = ostart;
-
-    U32 count[HUF_MAX_SYMBOL_VALUE+1];
-    HUF_CElt CTable[HUF_MAX_SYMBOL_VALUE+1];
-    size_t errorCode;
-
-    /* checks & inits */
-    if (srcSize < 1) return 0;  /* Uncompressed - note : 1 means rle, so first byte must be correct */
-    if (dstSize < 1) return 0;  /* not compressible within dst budget */
-    if (srcSize > 128 * 1024) return ERROR(srcSize_wrong);   /* current block size limit */
-    if (huffLog > HUF_MAX_TABLELOG) return ERROR(tableLog_tooLarge);
-    if (!maxSymbolValue) maxSymbolValue = HUF_MAX_SYMBOL_VALUE;
-    if (!huffLog) huffLog = HUF_DEFAULT_TABLELOG;
-
-    /* Scan input and build symbol stats */
-    errorCode = FSE_count (count, &maxSymbolValue, (const BYTE*)src, srcSize);
-    if (HUF_isError(errorCode)) return errorCode;
-    if (errorCode == srcSize) { *ostart = ((const BYTE*)src)[0]; return 1; }
-    if (errorCode <= (srcSize >> 7)+1) return 0;   /* Heuristic : not compressible enough */
-
-    /* Build Huffman Tree */
-    errorCode = HUF_buildCTable (CTable, count, maxSymbolValue, huffLog);
-    if (HUF_isError(errorCode)) return errorCode;
-    huffLog = (U32)errorCode;
-
-    /* Write table description header */
-    errorCode = HUF_writeCTable (op, dstSize, CTable, maxSymbolValue, huffLog);
-    if (HUF_isError(errorCode)) return errorCode;
-    if (errorCode + 12 >= srcSize) return 0;   /* not useful to try compression */
-    op += errorCode;
-
-    /* Compress */
-    if (singleStream)
-        errorCode = HUF_compress1X_usingCTable(op, oend - op, src, srcSize, CTable);   /* single segment */
-    else
-        errorCode = HUF_compress4X_usingCTable(op, oend - op, src, srcSize, CTable);
-    if (HUF_isError(errorCode)) return errorCode;
-    if (errorCode==0) return 0;
-    op += errorCode;
-
-    /* check compressibility */
-    if ((size_t)(op-ostart) >= srcSize-1)
-        return 0;
-
-    return op-ostart;
-}
-
-
-size_t HUF_compress1X (void* dst, size_t dstSize,
-                 const void* src, size_t srcSize,
-                 unsigned maxSymbolValue, unsigned huffLog)
-{
-    return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 1);
-}
-
-size_t HUF_compress2 (void* dst, size_t dstSize,
-                const void* src, size_t srcSize,
-                unsigned maxSymbolValue, unsigned huffLog)
-{
-    return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 0);
-}
-
-
-size_t HUF_compress (void* dst, size_t maxDstSize, const void* src, size_t srcSize)
-{
-    return HUF_compress2(dst, maxDstSize, src, (U32)srcSize, 255, HUF_DEFAULT_TABLELOG);
-}
+/* ****************************************************************** 
+   Huffman encoder, 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 */ 
+#  define FORCE_INLINE static __forceinline 
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */ 
+#else 
+#  ifdef __GNUC__ 
+#    define FORCE_INLINE static inline __attribute__((always_inline)) 
+#  else 
+#    define FORCE_INLINE static inline 
+#  endif 
+#endif 
+ 
+ 
+/* ************************************************************** 
+*  Includes 
+****************************************************************/ 
+#include <stdlib.h>     /* malloc, free, qsort */ 
+#include <string.h>     /* memcpy, memset */ 
+#include <stdio.h>      /* printf (debug) */ 
+#include "huf_static.h" 
+#include "bitstream.h" 
+#include "fse.h"        /* header compression */ 
+ 
+ 
+/* ************************************************************** 
+*  Error Management 
+****************************************************************/ 
+#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */ 
+ 
+ 
+/* ******************************************************* 
+*  HUF : Huffman block compression 
+*********************************************************/ 
+struct HUF_CElt_s { 
+  U16  val; 
+  BYTE nbBits; 
+};   /* typedef'd to HUF_CElt within huf_static.h */ 
+ 
+typedef struct nodeElt_s { 
+    U32 count; 
+    U16 parent; 
+    BYTE byte; 
+    BYTE nbBits; 
+} nodeElt; 
+ 
+/*! HUF_writeCTable() : 
+    `CTable` : huffman tree to save, using huf representation. 
+    @return : size of saved CTable */ 
+size_t HUF_writeCTable (void* dst, size_t maxDstSize, 
+                        const HUF_CElt* CTable, U32 maxSymbolValue, U32 huffLog) 
+{ 
+    BYTE bitsToWeight[HUF_MAX_TABLELOG + 1]; 
+    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1]; 
+    U32 n; 
+    BYTE* op = (BYTE*)dst; 
+    size_t size; 
+ 
+     /* check conditions */ 
+    if (maxSymbolValue > HUF_MAX_SYMBOL_VALUE + 1) 
+        return ERROR(GENERIC); 
+ 
+    /* convert to weight */ 
+    bitsToWeight[0] = 0; 
+    for (n=1; n<=huffLog; n++) 
+        bitsToWeight[n] = (BYTE)(huffLog + 1 - n); 
+    for (n=0; n<maxSymbolValue; n++) 
+        huffWeight[n] = bitsToWeight[CTable[n].nbBits]; 
+ 
+    size = FSE_compress(op+1, maxDstSize-1, huffWeight, maxSymbolValue);   /* don't need last symbol stat : implied */ 
+    if (HUF_isError(size)) return size; 
+    if (size >= 128) return ERROR(GENERIC);   /* should never happen, since maxSymbolValue <= 255 */ 
+    if ((size <= 1) || (size >= maxSymbolValue/2)) { 
+        if (size==1) {  /* RLE */ 
+            /* only possible case : serie of 1 (because there are at least 2) */ 
+            /* can only be 2^n or (2^n-1), otherwise not an huffman tree */ 
+            BYTE code; 
+            switch(maxSymbolValue) 
+            { 
+            case 1: code = 0; break; 
+            case 2: code = 1; break; 
+            case 3: code = 2; break; 
+            case 4: code = 3; break; 
+            case 7: code = 4; break; 
+            case 8: code = 5; break; 
+            case 15: code = 6; break; 
+            case 16: code = 7; break; 
+            case 31: code = 8; break; 
+            case 32: code = 9; break; 
+            case 63: code = 10; break; 
+            case 64: code = 11; break; 
+            case 127: code = 12; break; 
+            case 128: code = 13; break; 
+            default : return ERROR(corruption_detected); 
+            } 
+            op[0] = (BYTE)(255-13 + code); 
+            return 1; 
+        } 
+         /* Not compressible */ 
+        if (maxSymbolValue > (241-128)) return ERROR(GENERIC);   /* not implemented (not possible with current format) */ 
+        if (((maxSymbolValue+1)/2) + 1 > maxDstSize) return ERROR(dstSize_tooSmall);   /* not enough space within dst buffer */ 
+        op[0] = (BYTE)(128 /*special case*/ + 0 /* Not Compressible */ + (maxSymbolValue-1)); 
+        huffWeight[maxSymbolValue] = 0;   /* to be sure it doesn't cause issue in final combination */ 
+        for (n=0; n<maxSymbolValue; n+=2) 
+            op[(n/2)+1] = (BYTE)((huffWeight[n] << 4) + huffWeight[n+1]); 
+        return ((maxSymbolValue+1)/2) + 1; 
+    } 
+ 
+    /* normal header case */ 
+    op[0] = (BYTE)size; 
+    return size+1; 
+} 
+ 
+ 
+ 
+size_t HUF_readCTable (HUF_CElt* CTable, U32 maxSymbolValue, 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 readSize; 
+    U32 nbSymbols = 0; 
+    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */ 
+ 
+    /* get symbol weights */ 
+    readSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE+1, rankVal, &nbSymbols, &tableLog, src, srcSize); 
+    if (HUF_isError(readSize)) return readSize; 
+ 
+    /* check result */ 
+    if (tableLog > HUF_MAX_TABLELOG) return ERROR(tableLog_tooLarge); 
+    if (nbSymbols > maxSymbolValue+1) return ERROR(maxSymbolValue_tooSmall); 
+ 
+    /* Prepare base value per rank */ 
+    {   U32 n, nextRankStart = 0; 
+        for (n=1; n<=tableLog; n++) { 
+            U32 current = nextRankStart; 
+            nextRankStart += (rankVal[n] << (n-1)); 
+            rankVal[n] = current; 
+    }   } 
+ 
+    /* fill nbBits */ 
+    { U32 n; for (n=0; n<nbSymbols; n++) { 
+        const U32 w = huffWeight[n]; 
+        CTable[n].nbBits = (BYTE)(tableLog + 1 - w); 
+    }} 
+ 
+    /* fill val */ 
+    {   U16 nbPerRank[HUF_MAX_TABLELOG+1] = {0}; 
+        U16 valPerRank[HUF_MAX_TABLELOG+1] = {0}; 
+        { U32 n; for (n=0; n<nbSymbols; n++) nbPerRank[CTable[n].nbBits]++; } 
+        /* determine stating value per rank */ 
+        {   U16 min = 0; 
+            U32 n; for (n=HUF_MAX_TABLELOG; n>0; n--) { 
+                valPerRank[n] = min;      /* get starting value within each rank */ 
+                min += nbPerRank[n]; 
+                min >>= 1; 
+        }   } 
+        /* assign value within rank, symbol order */ 
+        { U32 n; for (n=0; n<=maxSymbolValue; n++) CTable[n].val = valPerRank[CTable[n].nbBits]++; } 
+    } 
+ 
+    return readSize; 
+} 
+ 
+ 
+static U32 HUF_setMaxHeight(nodeElt* huffNode, U32 lastNonNull, U32 maxNbBits) 
+{ 
+    const U32 largestBits = huffNode[lastNonNull].nbBits; 
+    if (largestBits <= maxNbBits) return largestBits;   /* early exit : no elt > maxNbBits */ 
+ 
+    /* there are several too large elements (at least >= 2) */ 
+    {   int totalCost = 0; 
+        const U32 baseCost = 1 << (largestBits - maxNbBits); 
+        U32 n = lastNonNull; 
+ 
+        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 */ 
+        while (huffNode[n].nbBits == maxNbBits) n--;   /* n end at index of smallest symbol using < maxNbBits */ 
+ 
+        /* renorm totalCost */ 
+        totalCost >>= (largestBits - maxNbBits);  /* note : totalCost is necessarily a multiple of baseCost */ 
+ 
+        /* repay normalized cost */ 
+        {   U32 const noSymbol = 0xF0F0F0F0; 
+            U32 rankLast[HUF_MAX_TABLELOG+1]; 
+            int pos; 
+ 
+            /* Get pos of last (smallest) symbol per rank */ 
+            memset(rankLast, 0xF0, sizeof(rankLast)); 
+            {   U32 currentNbBits = maxNbBits; 
+                for (pos=n ; pos >= 0; pos--) { 
+                    if (huffNode[pos].nbBits >= currentNbBits) continue; 
+                    currentNbBits = huffNode[pos].nbBits;   /* < maxNbBits */ 
+                    rankLast[maxNbBits-currentNbBits] = pos; 
+            }   } 
+ 
+            while (totalCost > 0) { 
+                U32 nBitsToDecrease = BIT_highbit32(totalCost) + 1; 
+                for ( ; nBitsToDecrease > 1; nBitsToDecrease--) { 
+                    U32 highPos = rankLast[nBitsToDecrease]; 
+                    U32 lowPos = rankLast[nBitsToDecrease-1]; 
+                    if (highPos == noSymbol) continue; 
+                    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 !) */ 
+                while ((nBitsToDecrease<=HUF_MAX_TABLELOG) && (rankLast[nBitsToDecrease] == noSymbol))  /* HUF_MAX_TABLELOG test just to please gcc 5+; but it should not be necessary */ 
+                    nBitsToDecrease ++; 
+                totalCost -= 1 << (nBitsToDecrease-1); 
+                if (rankLast[nBitsToDecrease-1] == noSymbol) 
+                    rankLast[nBitsToDecrease-1] = rankLast[nBitsToDecrease];   /* this rank is no longer empty */ 
+                huffNode[rankLast[nBitsToDecrease]].nbBits ++; 
+                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) */ 
+ 
+            while (totalCost < 0) {  /* Sometimes, cost correction overshoot */ 
+                if (rankLast[1] == noSymbol) {  /* special case : no rank 1 symbol (using maxNbBits-1); let's create one from largest rank 0 (using maxNbBits) */ 
+                    while (huffNode[n].nbBits == maxNbBits) n--; 
+                    huffNode[n+1].nbBits--; 
+                    rankLast[1] = n+1; 
+                    totalCost++; 
+                    continue; 
+                } 
+                huffNode[ rankLast[1] + 1 ].nbBits--; 
+                rankLast[1]++; 
+                totalCost ++; 
+    }   }   }   /* there are several too large elements (at least >= 2) */ 
+ 
+    return maxNbBits; 
+} 
+ 
+ 
+typedef struct { 
+    U32 base; 
+    U32 current; 
+} rankPos; 
+ 
+static void HUF_sort(nodeElt* huffNode, const U32* count, U32 maxSymbolValue) 
+{ 
+    rankPos rank[32]; 
+    U32 n; 
+ 
+    memset(rank, 0, sizeof(rank)); 
+    for (n=0; n<=maxSymbolValue; n++) { 
+        U32 r = BIT_highbit32(count[n] + 1); 
+        rank[r].base ++; 
+    } 
+    for (n=30; n>0; n--) rank[n-1].base += rank[n].base; 
+    for (n=0; n<32; n++) rank[n].current = rank[n].base; 
+    for (n=0; n<=maxSymbolValue; n++) { 
+        U32 const c = count[n]; 
+        U32 const r = BIT_highbit32(c+1) + 1; 
+        U32 pos = rank[r].current++; 
+        while ((pos > rank[r].base) && (c > huffNode[pos-1].count)) huffNode[pos]=huffNode[pos-1], pos--; 
+        huffNode[pos].count = c; 
+        huffNode[pos].byte  = (BYTE)n; 
+    } 
+} 
+ 
+ 
+#define STARTNODE (HUF_MAX_SYMBOL_VALUE+1) 
+size_t HUF_buildCTable (HUF_CElt* tree, const U32* count, U32 maxSymbolValue, U32 maxNbBits) 
+{ 
+    nodeElt huffNode0[2*HUF_MAX_SYMBOL_VALUE+1 +1]; 
+    nodeElt* huffNode = huffNode0 + 1; 
+    U32 n, nonNullRank; 
+    int lowS, lowN; 
+    U16 nodeNb = STARTNODE; 
+    U32 nodeRoot; 
+ 
+    /* safety checks */ 
+    if (maxNbBits == 0) maxNbBits = HUF_DEFAULT_TABLELOG; 
+    if (maxSymbolValue > HUF_MAX_SYMBOL_VALUE) return ERROR(GENERIC); 
+    memset(huffNode0, 0, sizeof(huffNode0)); 
+ 
+    /* sort, decreasing order */ 
+    HUF_sort(huffNode, count, maxSymbolValue); 
+ 
+    /* init for parents */ 
+    nonNullRank = 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; 
+    huffNode[lowS].parent = huffNode[lowS-1].parent = nodeNb; 
+    nodeNb++; lowS-=2; 
+    for (n=nodeNb; n<=nodeRoot; n++) huffNode[n].count = (U32)(1U<<30); 
+    huffNode0[0].count = (U32)(1U<<31); 
+ 
+    /* create parents */ 
+    while (nodeNb <= nodeRoot) { 
+        U32 n1 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++; 
+        U32 n2 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++; 
+        huffNode[nodeNb].count = huffNode[n1].count + huffNode[n2].count; 
+        huffNode[n1].parent = huffNode[n2].parent = 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; 
+ 
+    /* enforce maxTableLog */ 
+    maxNbBits = HUF_setMaxHeight(huffNode, nonNullRank, maxNbBits); 
+ 
+    /* fill result into tree (val, nbBits) */ 
+    {   U16 nbPerRank[HUF_MAX_TABLELOG+1] = {0}; 
+        U16 valPerRank[HUF_MAX_TABLELOG+1] = {0}; 
+        if (maxNbBits > HUF_MAX_TABLELOG) return ERROR(GENERIC);   /* check fit into table */ 
+        for (n=0; n<=nonNullRank; n++) 
+            nbPerRank[huffNode[n].nbBits]++; 
+        /* determine stating value per rank */ 
+        {   U16 min = 0; 
+            for (n=maxNbBits; n>0; n--) { 
+                valPerRank[n] = min;      /* get starting value within each rank */ 
+                min += nbPerRank[n]; 
+                min >>= 1; 
+        }   } 
+        for (n=0; n<=maxSymbolValue; n++) 
+            tree[huffNode[n].byte].nbBits = huffNode[n].nbBits;   /* push nbBits per symbol, symbol order */ 
+        for (n=0; n<=maxSymbolValue; n++) 
+            tree[n].val = valPerRank[tree[n].nbBits]++;   /* assign value within rank, symbol order */ 
+    } 
+ 
+    return maxNbBits; 
+} 
+ 
+static void HUF_encodeSymbol(BIT_CStream_t* bitCPtr, U32 symbol, const HUF_CElt* CTable) 
+{ 
+    BIT_addBitsFast(bitCPtr, CTable[symbol].val, CTable[symbol].nbBits); 
+} 
+ 
+size_t HUF_compressBound(size_t size) { return HUF_COMPRESSBOUND(size); } 
+ 
+#define HUF_FLUSHBITS(s)  (fast ? BIT_flushBitsFast(s) : BIT_flushBits(s)) 
+ 
+#define HUF_FLUSHBITS_1(stream) \ 
+    if (sizeof((stream)->bitContainer)*8 < HUF_MAX_TABLELOG*2+7) HUF_FLUSHBITS(stream) 
+ 
+#define HUF_FLUSHBITS_2(stream) \ 
+    if (sizeof((stream)->bitContainer)*8 < HUF_MAX_TABLELOG*4+7) HUF_FLUSHBITS(stream) 
+ 
+size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable) 
+{ 
+    const BYTE* ip = (const BYTE*) src; 
+    BYTE* const ostart = (BYTE*)dst; 
+    BYTE* const oend = ostart + dstSize; 
+    BYTE* op = ostart; 
+    size_t n; 
+    const unsigned fast = (dstSize >= HUF_BLOCKBOUND(srcSize)); 
+    BIT_CStream_t bitC; 
+ 
+    /* init */ 
+    if (dstSize < 8) return 0;   /* not enough space to compress */ 
+    { size_t const errorCode = BIT_initCStream(&bitC, op, oend-op); 
+      if (HUF_isError(errorCode)) return 0; } 
+ 
+    n = srcSize & ~3;  /* join to mod 4 */ 
+    switch (srcSize & 3) 
+    { 
+        case 3 : HUF_encodeSymbol(&bitC, ip[n+ 2], CTable); 
+                 HUF_FLUSHBITS_2(&bitC); 
+        case 2 : HUF_encodeSymbol(&bitC, ip[n+ 1], CTable); 
+                 HUF_FLUSHBITS_1(&bitC); 
+        case 1 : HUF_encodeSymbol(&bitC, ip[n+ 0], CTable); 
+                 HUF_FLUSHBITS(&bitC); 
+        case 0 : 
+        default: ; 
+    } 
+ 
+    for (; n>0; n-=4) {  /* note : n&3==0 at this stage */ 
+        HUF_encodeSymbol(&bitC, ip[n- 1], CTable); 
+        HUF_FLUSHBITS_1(&bitC); 
+        HUF_encodeSymbol(&bitC, ip[n- 2], CTable); 
+        HUF_FLUSHBITS_2(&bitC); 
+        HUF_encodeSymbol(&bitC, ip[n- 3], CTable); 
+        HUF_FLUSHBITS_1(&bitC); 
+        HUF_encodeSymbol(&bitC, ip[n- 4], CTable); 
+        HUF_FLUSHBITS(&bitC); 
+    } 
+ 
+    return BIT_closeCStream(&bitC); 
+} 
+ 
+ 
+size_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable) 
+{ 
+    size_t 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; 
+    size_t errorCode; 
+ 
+    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 */ 
+ 
+    errorCode = HUF_compress1X_usingCTable(op, oend-op, ip, segmentSize, CTable); 
+    if (HUF_isError(errorCode)) return errorCode; 
+    if (errorCode==0) return 0; 
+    MEM_writeLE16(ostart, (U16)errorCode); 
+ 
+    ip += segmentSize; 
+    op += errorCode; 
+    errorCode = HUF_compress1X_usingCTable(op, oend-op, ip, segmentSize, CTable); 
+    if (HUF_isError(errorCode)) return errorCode; 
+    if (errorCode==0) return 0; 
+    MEM_writeLE16(ostart+2, (U16)errorCode); 
+ 
+    ip += segmentSize; 
+    op += errorCode; 
+    errorCode = HUF_compress1X_usingCTable(op, oend-op, ip, segmentSize, CTable); 
+    if (HUF_isError(errorCode)) return errorCode; 
+    if (errorCode==0) return 0; 
+    MEM_writeLE16(ostart+4, (U16)errorCode); 
+ 
+    ip += segmentSize; 
+    op += errorCode; 
+    errorCode = HUF_compress1X_usingCTable(op, oend-op, ip, iend-ip, CTable); 
+    if (HUF_isError(errorCode)) return errorCode; 
+    if (errorCode==0) return 0; 
+ 
+    op += errorCode; 
+    return op-ostart; 
+} 
+ 
+ 
+static size_t HUF_compress_internal ( 
+                void* dst, size_t dstSize, 
+                const void* src, size_t srcSize, 
+                unsigned maxSymbolValue, unsigned huffLog, 
+                unsigned singleStream) 
+{ 
+    BYTE* const ostart = (BYTE*)dst; 
+    BYTE* const oend = ostart + dstSize; 
+    BYTE* op = ostart; 
+ 
+    U32 count[HUF_MAX_SYMBOL_VALUE+1]; 
+    HUF_CElt CTable[HUF_MAX_SYMBOL_VALUE+1]; 
+    size_t errorCode; 
+ 
+    /* checks & inits */ 
+    if (srcSize < 1) return 0;  /* Uncompressed - note : 1 means rle, so first byte must be correct */ 
+    if (dstSize < 1) return 0;  /* not compressible within dst budget */ 
+    if (srcSize > 128 * 1024) return ERROR(srcSize_wrong);   /* current block size limit */ 
+    if (huffLog > HUF_MAX_TABLELOG) return ERROR(tableLog_tooLarge); 
+    if (!maxSymbolValue) maxSymbolValue = HUF_MAX_SYMBOL_VALUE; 
+    if (!huffLog) huffLog = HUF_DEFAULT_TABLELOG; 
+ 
+    /* Scan input and build symbol stats */ 
+    errorCode = FSE_count (count, &maxSymbolValue, (const BYTE*)src, srcSize); 
+    if (HUF_isError(errorCode)) return errorCode; 
+    if (errorCode == srcSize) { *ostart = ((const BYTE*)src)[0]; return 1; } 
+    if (errorCode <= (srcSize >> 7)+1) return 0;   /* Heuristic : not compressible enough */ 
+ 
+    /* Build Huffman Tree */ 
+    errorCode = HUF_buildCTable (CTable, count, maxSymbolValue, huffLog); 
+    if (HUF_isError(errorCode)) return errorCode; 
+    huffLog = (U32)errorCode; 
+ 
+    /* Write table description header */ 
+    errorCode = HUF_writeCTable (op, dstSize, CTable, maxSymbolValue, huffLog); 
+    if (HUF_isError(errorCode)) return errorCode; 
+    if (errorCode + 12 >= srcSize) return 0;   /* not useful to try compression */ 
+    op += errorCode; 
+ 
+    /* Compress */ 
+    if (singleStream) 
+        errorCode = HUF_compress1X_usingCTable(op, oend - op, src, srcSize, CTable);   /* single segment */ 
+    else 
+        errorCode = HUF_compress4X_usingCTable(op, oend - op, src, srcSize, CTable); 
+    if (HUF_isError(errorCode)) return errorCode; 
+    if (errorCode==0) return 0; 
+    op += errorCode; 
+ 
+    /* check compressibility */ 
+    if ((size_t)(op-ostart) >= srcSize-1) 
+        return 0; 
+ 
+    return op-ostart; 
+} 
+ 
+ 
+size_t HUF_compress1X (void* dst, size_t dstSize, 
+                 const void* src, size_t srcSize, 
+                 unsigned maxSymbolValue, unsigned huffLog) 
+{ 
+    return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 1); 
+} 
+ 
+size_t HUF_compress2 (void* dst, size_t dstSize, 
+                const void* src, size_t srcSize, 
+                unsigned maxSymbolValue, unsigned huffLog) 
+{ 
+    return HUF_compress_internal(dst, dstSize, src, srcSize, maxSymbolValue, huffLog, 0); 
+} 
+ 
+ 
+size_t HUF_compress (void* dst, size_t maxDstSize, const void* src, size_t srcSize) 
+{ 
+    return HUF_compress2(dst, maxDstSize, src, (U32)srcSize, 255, HUF_DEFAULT_TABLELOG); 
+} 
diff --git a/contrib/libs/zstd06/compress/zbuff_compress.c b/contrib/libs/zstd06/compress/zbuff_compress.c
index 260aca0870..ec9d0ada60 100644
--- a/contrib/libs/zstd06/compress/zbuff_compress.c
+++ b/contrib/libs/zstd06/compress/zbuff_compress.c
@@ -1,291 +1,291 @@
-/*
-    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/
-*/
-
-
-/* *************************************
-*  Dependencies
-***************************************/
-#include <stdlib.h>
-#include "error_private.h"
-#include "zstd_internal.h"  /* MIN, ZSTD_blockHeaderSize */
-#include "zstd_static.h"    /* ZSTD_BLOCKSIZE_MAX */
-#include "zbuff_static.h"
-
-
-/* *************************************
-*  Constants
-***************************************/
-static size_t const ZBUFF_endFrameSize = ZSTD_BLOCKHEADERSIZE;
-
-
-/*_**************************************************
-*  Streaming compression
-*
-*  A ZBUFF_CCtx object is required to track streaming operation.
-*  Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources.
-*  Use ZBUFF_compressInit() to start a new compression operation.
-*  ZBUFF_CCtx objects can be reused multiple times.
-*
-*  Use ZBUFF_compressContinue() 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 call again the function with remaining input.
-*  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 improve latency)
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  ZBUFF_compressFlush() can be used to instruct ZBUFF to compress and output whatever remains within its buffer.
-*  Note that it will not output more than *dstCapacityPtr.
-*  Therefore, some content might still be left into its internal buffer if dst buffer is too small.
-*  @return : nb of bytes still present into internal buffer (0 if it's empty)
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  ZBUFF_compressEnd() instructs to finish a frame.
-*  It will perform a flush and write frame epilogue.
-*  Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small.
-*  @return : nb of bytes still present into internal buffer (0 if it's empty)
-*            or an error code, which can be tested using ZBUFF_isError().
-*
-*  Hint : recommended buffer sizes (not compulsory)
-*  input : ZSTD_BLOCKSIZE_MAX (128 KB), internal unit size, it improves latency to use this value.
-*  output : ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + ZBUFF_endFrameSize : ensures it's always possible to write/flush/end a full block at best speed.
-* **************************************************/
-
-typedef enum { ZBUFFcs_init, ZBUFFcs_load, ZBUFFcs_flush } ZBUFF_cStage;
-
-/* *** Ressources *** */
-struct ZBUFF_CCtx_s {
-    ZSTD_CCtx* zc;
-    char*  inBuff;
-    size_t inBuffSize;
-    size_t inToCompress;
-    size_t inBuffPos;
-    size_t inBuffTarget;
-    size_t blockSize;
-    char*  outBuff;
-    size_t outBuffSize;
-    size_t outBuffContentSize;
-    size_t outBuffFlushedSize;
-    ZBUFF_cStage stage;
-};   /* typedef'd tp ZBUFF_CCtx within "zstd_buffered.h" */
-
-ZBUFF_CCtx* ZBUFF_createCCtx(void)
-{
-    ZBUFF_CCtx* zbc = (ZBUFF_CCtx*)malloc(sizeof(ZBUFF_CCtx));
-    if (zbc==NULL) return NULL;
-    memset(zbc, 0, sizeof(*zbc));
-    zbc->zc = ZSTD_createCCtx();
-    return zbc;
-}
-
-size_t ZBUFF_freeCCtx(ZBUFF_CCtx* zbc)
-{
-    if (zbc==NULL) return 0;   /* support free on NULL */
-    ZSTD_freeCCtx(zbc->zc);
-    free(zbc->inBuff);
-    free(zbc->outBuff);
-    free(zbc);
-    return 0;
-}
-
-
-/* *** Initialization *** */
-
-size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc,
-                                   const void* dict, size_t dictSize,
-                                   ZSTD_parameters params, U64 pledgedSrcSize)
-{
-    /* allocate buffers */
-    {   size_t const neededInBuffSize = (size_t)1 << params.cParams.windowLog;
-        if (zbc->inBuffSize < neededInBuffSize) {
-            zbc->inBuffSize = neededInBuffSize;
-            free(zbc->inBuff);   /* should not be necessary */
-            zbc->inBuff = (char*)malloc(neededInBuffSize);
-            if (zbc->inBuff == NULL) return ERROR(memory_allocation);
-        }
-        zbc->blockSize = MIN(ZSTD_BLOCKSIZE_MAX, neededInBuffSize/2);
-    }
-    if (zbc->outBuffSize < ZSTD_compressBound(zbc->blockSize)+1) {
-        zbc->outBuffSize = ZSTD_compressBound(zbc->blockSize)+1;
-        free(zbc->outBuff);   /* should not be necessary */
-        zbc->outBuff = (char*)malloc(zbc->outBuffSize);
-        if (zbc->outBuff == NULL) return ERROR(memory_allocation);
-    }
-
-    { size_t const errorCode = ZSTD_compressBegin_advanced(zbc->zc, dict, dictSize, params, pledgedSrcSize);
-      if (ZSTD_isError(errorCode)) return errorCode; }
-
-    zbc->inToCompress = 0;
-    zbc->inBuffPos = 0;
-    zbc->inBuffTarget = zbc->blockSize;
-    zbc->outBuffFlushedSize = 0;
-    zbc->stage = ZBUFFcs_load;
-    return 0;   /* ready to go */
-}
-
-
-size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* zbc, const void* dict, size_t dictSize, int compressionLevel)
-{
-    ZSTD_parameters params;
-    params.cParams = ZSTD_getCParams(compressionLevel, 0, dictSize);
-    params.fParams.contentSizeFlag = 0;
-    ZSTD_adjustCParams(&params.cParams, 0, dictSize);
-    return ZBUFF_compressInit_advanced(zbc, dict, dictSize, params, 0);
-}
-
-size_t ZBUFF_compressInit(ZBUFF_CCtx* zbc, int compressionLevel)
-{
-    return ZBUFF_compressInitDictionary(zbc, NULL, 0, compressionLevel);
-}
-
-
-/* *** Compression *** */
-
-static size_t ZBUFF_compressContinue_generic(ZBUFF_CCtx* zbc,
-                              void* dst, size_t* dstCapacityPtr,
-                        const void* src, size_t* srcSizePtr,
-                              int flush)   /* aggregate : wait for full block before compressing */
-{
-    U32 notDone = 1;
-    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;
-
-    while (notDone) {
-        switch(zbc->stage)
-        {
-        case ZBUFFcs_init: return ERROR(init_missing);   /* call ZBUFF_compressInit() first ! */
-
-        case ZBUFFcs_load:
-            /* complete inBuffer */
-            {   size_t const toLoad = zbc->inBuffTarget - zbc->inBuffPos;
-                size_t const loaded = ZBUFF_limitCopy(zbc->inBuff + zbc->inBuffPos, toLoad, ip, iend-ip);
-                zbc->inBuffPos += loaded;
-                ip += loaded;
-                if ( (zbc->inBuffPos==zbc->inToCompress) || (!flush && (toLoad != loaded)) ) {
-                    notDone = 0; break;  /* not enough input to get a full block : stop there, wait for more */
-            }   }
-            /* compress current block (note : this stage cannot be stopped in the middle) */
-            {   void* cDst;
-                size_t cSize;
-                size_t const iSize = zbc->inBuffPos - zbc->inToCompress;
-                size_t oSize = oend-op;
-                if (oSize >= ZSTD_compressBound(iSize))
-                    cDst = op;   /* compress directly into output buffer (avoid flush stage) */
-                else
-                    cDst = zbc->outBuff, oSize = zbc->outBuffSize;
-                cSize = ZSTD_compressContinue(zbc->zc, cDst, oSize, zbc->inBuff + zbc->inToCompress, iSize);
-                if (ZSTD_isError(cSize)) return cSize;
-                /* prepare next block */
-                zbc->inBuffTarget = zbc->inBuffPos + zbc->blockSize;
-                if (zbc->inBuffTarget > zbc->inBuffSize)
-                    zbc->inBuffPos = 0, zbc->inBuffTarget = zbc->blockSize;   /* note : inBuffSize >= blockSize */
-                zbc->inToCompress = zbc->inBuffPos;
-                if (cDst == op) { op += cSize; break; }   /* no need to flush */
-                zbc->outBuffContentSize = cSize;
-                zbc->outBuffFlushedSize = 0;
-                zbc->stage = ZBUFFcs_flush;   /* continue to flush stage */
-            }
-
-        case ZBUFFcs_flush:
-            /* flush into dst */
-            {   size_t const toFlush = zbc->outBuffContentSize - zbc->outBuffFlushedSize;
-                size_t const flushed = ZBUFF_limitCopy(op, oend-op, zbc->outBuff + zbc->outBuffFlushedSize, toFlush);
-                op += flushed;
-                zbc->outBuffFlushedSize += flushed;
-                if (toFlush!=flushed) { notDone = 0; break; } /* not enough space within dst to store compressed block : stop there */
-                zbc->outBuffContentSize = 0;
-                zbc->outBuffFlushedSize = 0;
-                zbc->stage = ZBUFFcs_load;
-                break;
-            }
-        default:
-            return ERROR(GENERIC);   /* impossible */
-        }
-    }
-
-    *srcSizePtr = ip - istart;
-    *dstCapacityPtr = op - ostart;
-    {   size_t hintInSize = zbc->inBuffTarget - zbc->inBuffPos;
-        if (hintInSize==0) hintInSize = zbc->blockSize;
-        return hintInSize;
-    }
-}
-
-size_t ZBUFF_compressContinue(ZBUFF_CCtx* zbc,
-                              void* dst, size_t* dstCapacityPtr,
-                        const void* src, size_t* srcSizePtr)
-{
-    return ZBUFF_compressContinue_generic(zbc, dst, dstCapacityPtr, src, srcSizePtr, 0);
-}
-
-
-
-/* *** Finalize *** */
-
-size_t ZBUFF_compressFlush(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr)
-{
-    size_t srcSize = 0;
-    ZBUFF_compressContinue_generic(zbc, dst, dstCapacityPtr, &srcSize, &srcSize, 1);  /* use a valid src address instead of NULL */
-    return zbc->outBuffContentSize - zbc->outBuffFlushedSize;
-}
-
-
-size_t ZBUFF_compressEnd(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr)
-{
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + *dstCapacityPtr;
-    BYTE* op = ostart;
-    size_t outSize = *dstCapacityPtr;
-    size_t epilogueSize, remaining;
-    ZBUFF_compressFlush(zbc, dst, &outSize);     /* flush any remaining inBuff */
-    op += outSize;
-    epilogueSize = ZSTD_compressEnd(zbc->zc, zbc->outBuff + zbc->outBuffContentSize, zbc->outBuffSize - zbc->outBuffContentSize);   /* epilogue into outBuff */
-    zbc->outBuffContentSize += epilogueSize;
-    outSize = oend-op;
-    zbc->stage = ZBUFFcs_flush;
-    remaining = ZBUFF_compressFlush(zbc, op, &outSize);   /* attempt to flush epilogue into dst */
-    op += outSize;
-    if (!remaining) zbc->stage = ZBUFFcs_init;   /* close only if nothing left to flush */
-    *dstCapacityPtr = op-ostart;                 /* tells how many bytes were written */
-    return remaining;
-}
-
-
-
-/* *************************************
-*  Tool functions
-***************************************/
-size_t ZBUFF_recommendedCInSize(void)  { return ZSTD_BLOCKSIZE_MAX; }
-size_t ZBUFF_recommendedCOutSize(void) { return ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + ZBUFF_endFrameSize; }
+/* 
+    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/ 
+*/ 
+ 
+ 
+/* ************************************* 
+*  Dependencies 
+***************************************/ 
+#include <stdlib.h> 
+#include "error_private.h" 
+#include "zstd_internal.h"  /* MIN, ZSTD_blockHeaderSize */ 
+#include "zstd_static.h"    /* ZSTD_BLOCKSIZE_MAX */ 
+#include "zbuff_static.h" 
+ 
+ 
+/* ************************************* 
+*  Constants 
+***************************************/ 
+static size_t const ZBUFF_endFrameSize = ZSTD_BLOCKHEADERSIZE; 
+ 
+ 
+/*_************************************************** 
+*  Streaming compression 
+* 
+*  A ZBUFF_CCtx object is required to track streaming operation. 
+*  Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources. 
+*  Use ZBUFF_compressInit() to start a new compression operation. 
+*  ZBUFF_CCtx objects can be reused multiple times. 
+* 
+*  Use ZBUFF_compressContinue() 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 call again the function with remaining input. 
+*  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 improve latency) 
+*            or an error code, which can be tested using ZBUFF_isError(). 
+* 
+*  ZBUFF_compressFlush() can be used to instruct ZBUFF to compress and output whatever remains within its buffer. 
+*  Note that it will not output more than *dstCapacityPtr. 
+*  Therefore, some content might still be left into its internal buffer if dst buffer is too small. 
+*  @return : nb of bytes still present into internal buffer (0 if it's empty) 
+*            or an error code, which can be tested using ZBUFF_isError(). 
+* 
+*  ZBUFF_compressEnd() instructs to finish a frame. 
+*  It will perform a flush and write frame epilogue. 
+*  Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small. 
+*  @return : nb of bytes still present into internal buffer (0 if it's empty) 
+*            or an error code, which can be tested using ZBUFF_isError(). 
+* 
+*  Hint : recommended buffer sizes (not compulsory) 
+*  input : ZSTD_BLOCKSIZE_MAX (128 KB), internal unit size, it improves latency to use this value. 
+*  output : ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + ZBUFF_endFrameSize : ensures it's always possible to write/flush/end a full block at best speed. 
+* **************************************************/ 
+ 
+typedef enum { ZBUFFcs_init, ZBUFFcs_load, ZBUFFcs_flush } ZBUFF_cStage; 
+ 
+/* *** Ressources *** */ 
+struct ZBUFF_CCtx_s { 
+    ZSTD_CCtx* zc; 
+    char*  inBuff; 
+    size_t inBuffSize; 
+    size_t inToCompress; 
+    size_t inBuffPos; 
+    size_t inBuffTarget; 
+    size_t blockSize; 
+    char*  outBuff; 
+    size_t outBuffSize; 
+    size_t outBuffContentSize; 
+    size_t outBuffFlushedSize; 
+    ZBUFF_cStage stage; 
+};   /* typedef'd tp ZBUFF_CCtx within "zstd_buffered.h" */ 
+ 
+ZBUFF_CCtx* ZBUFF_createCCtx(void) 
+{ 
+    ZBUFF_CCtx* zbc = (ZBUFF_CCtx*)malloc(sizeof(ZBUFF_CCtx)); 
+    if (zbc==NULL) return NULL; 
+    memset(zbc, 0, sizeof(*zbc)); 
+    zbc->zc = ZSTD_createCCtx(); 
+    return zbc; 
+} 
+ 
+size_t ZBUFF_freeCCtx(ZBUFF_CCtx* zbc) 
+{ 
+    if (zbc==NULL) return 0;   /* support free on NULL */ 
+    ZSTD_freeCCtx(zbc->zc); 
+    free(zbc->inBuff); 
+    free(zbc->outBuff); 
+    free(zbc); 
+    return 0; 
+} 
+ 
+ 
+/* *** Initialization *** */ 
+ 
+size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc, 
+                                   const void* dict, size_t dictSize, 
+                                   ZSTD_parameters params, U64 pledgedSrcSize) 
+{ 
+    /* allocate buffers */ 
+    {   size_t const neededInBuffSize = (size_t)1 << params.cParams.windowLog; 
+        if (zbc->inBuffSize < neededInBuffSize) { 
+            zbc->inBuffSize = neededInBuffSize; 
+            free(zbc->inBuff);   /* should not be necessary */ 
+            zbc->inBuff = (char*)malloc(neededInBuffSize); 
+            if (zbc->inBuff == NULL) return ERROR(memory_allocation); 
+        } 
+        zbc->blockSize = MIN(ZSTD_BLOCKSIZE_MAX, neededInBuffSize/2); 
+    } 
+    if (zbc->outBuffSize < ZSTD_compressBound(zbc->blockSize)+1) { 
+        zbc->outBuffSize = ZSTD_compressBound(zbc->blockSize)+1; 
+        free(zbc->outBuff);   /* should not be necessary */ 
+        zbc->outBuff = (char*)malloc(zbc->outBuffSize); 
+        if (zbc->outBuff == NULL) return ERROR(memory_allocation); 
+    } 
+ 
+    { size_t const errorCode = ZSTD_compressBegin_advanced(zbc->zc, dict, dictSize, params, pledgedSrcSize); 
+      if (ZSTD_isError(errorCode)) return errorCode; } 
+ 
+    zbc->inToCompress = 0; 
+    zbc->inBuffPos = 0; 
+    zbc->inBuffTarget = zbc->blockSize; 
+    zbc->outBuffFlushedSize = 0; 
+    zbc->stage = ZBUFFcs_load; 
+    return 0;   /* ready to go */ 
+} 
+ 
+ 
+size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* zbc, const void* dict, size_t dictSize, int compressionLevel) 
+{ 
+    ZSTD_parameters params; 
+    params.cParams = ZSTD_getCParams(compressionLevel, 0, dictSize); 
+    params.fParams.contentSizeFlag = 0; 
+    ZSTD_adjustCParams(&params.cParams, 0, dictSize); 
+    return ZBUFF_compressInit_advanced(zbc, dict, dictSize, params, 0); 
+} 
+ 
+size_t ZBUFF_compressInit(ZBUFF_CCtx* zbc, int compressionLevel) 
+{ 
+    return ZBUFF_compressInitDictionary(zbc, NULL, 0, compressionLevel); 
+} 
+ 
+ 
+/* *** Compression *** */ 
+ 
+static size_t ZBUFF_compressContinue_generic(ZBUFF_CCtx* zbc, 
+                              void* dst, size_t* dstCapacityPtr, 
+                        const void* src, size_t* srcSizePtr, 
+                              int flush)   /* aggregate : wait for full block before compressing */ 
+{ 
+    U32 notDone = 1; 
+    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; 
+ 
+    while (notDone) { 
+        switch(zbc->stage) 
+        { 
+        case ZBUFFcs_init: return ERROR(init_missing);   /* call ZBUFF_compressInit() first ! */ 
+ 
+        case ZBUFFcs_load: 
+            /* complete inBuffer */ 
+            {   size_t const toLoad = zbc->inBuffTarget - zbc->inBuffPos; 
+                size_t const loaded = ZBUFF_limitCopy(zbc->inBuff + zbc->inBuffPos, toLoad, ip, iend-ip); 
+                zbc->inBuffPos += loaded; 
+                ip += loaded; 
+                if ( (zbc->inBuffPos==zbc->inToCompress) || (!flush && (toLoad != loaded)) ) { 
+                    notDone = 0; break;  /* not enough input to get a full block : stop there, wait for more */ 
+            }   } 
+            /* compress current block (note : this stage cannot be stopped in the middle) */ 
+            {   void* cDst; 
+                size_t cSize; 
+                size_t const iSize = zbc->inBuffPos - zbc->inToCompress; 
+                size_t oSize = oend-op; 
+                if (oSize >= ZSTD_compressBound(iSize)) 
+                    cDst = op;   /* compress directly into output buffer (avoid flush stage) */ 
+                else 
+                    cDst = zbc->outBuff, oSize = zbc->outBuffSize; 
+                cSize = ZSTD_compressContinue(zbc->zc, cDst, oSize, zbc->inBuff + zbc->inToCompress, iSize); 
+                if (ZSTD_isError(cSize)) return cSize; 
+                /* prepare next block */ 
+                zbc->inBuffTarget = zbc->inBuffPos + zbc->blockSize; 
+                if (zbc->inBuffTarget > zbc->inBuffSize) 
+                    zbc->inBuffPos = 0, zbc->inBuffTarget = zbc->blockSize;   /* note : inBuffSize >= blockSize */ 
+                zbc->inToCompress = zbc->inBuffPos; 
+                if (cDst == op) { op += cSize; break; }   /* no need to flush */ 
+                zbc->outBuffContentSize = cSize; 
+                zbc->outBuffFlushedSize = 0; 
+                zbc->stage = ZBUFFcs_flush;   /* continue to flush stage */ 
+            } 
+ 
+        case ZBUFFcs_flush: 
+            /* flush into dst */ 
+            {   size_t const toFlush = zbc->outBuffContentSize - zbc->outBuffFlushedSize; 
+                size_t const flushed = ZBUFF_limitCopy(op, oend-op, zbc->outBuff + zbc->outBuffFlushedSize, toFlush); 
+                op += flushed; 
+                zbc->outBuffFlushedSize += flushed; 
+                if (toFlush!=flushed) { notDone = 0; break; } /* not enough space within dst to store compressed block : stop there */ 
+                zbc->outBuffContentSize = 0; 
+                zbc->outBuffFlushedSize = 0; 
+                zbc->stage = ZBUFFcs_load; 
+                break; 
+            } 
+        default: 
+            return ERROR(GENERIC);   /* impossible */ 
+        } 
+    } 
+ 
+    *srcSizePtr = ip - istart; 
+    *dstCapacityPtr = op - ostart; 
+    {   size_t hintInSize = zbc->inBuffTarget - zbc->inBuffPos; 
+        if (hintInSize==0) hintInSize = zbc->blockSize; 
+        return hintInSize; 
+    } 
+} 
+ 
+size_t ZBUFF_compressContinue(ZBUFF_CCtx* zbc, 
+                              void* dst, size_t* dstCapacityPtr, 
+                        const void* src, size_t* srcSizePtr) 
+{ 
+    return ZBUFF_compressContinue_generic(zbc, dst, dstCapacityPtr, src, srcSizePtr, 0); 
+} 
+ 
+ 
+ 
+/* *** Finalize *** */ 
+ 
+size_t ZBUFF_compressFlush(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr) 
+{ 
+    size_t srcSize = 0; 
+    ZBUFF_compressContinue_generic(zbc, dst, dstCapacityPtr, &srcSize, &srcSize, 1);  /* use a valid src address instead of NULL */ 
+    return zbc->outBuffContentSize - zbc->outBuffFlushedSize; 
+} 
+ 
+ 
+size_t ZBUFF_compressEnd(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr) 
+{ 
+    BYTE* const ostart = (BYTE*)dst; 
+    BYTE* const oend = ostart + *dstCapacityPtr; 
+    BYTE* op = ostart; 
+    size_t outSize = *dstCapacityPtr; 
+    size_t epilogueSize, remaining; 
+    ZBUFF_compressFlush(zbc, dst, &outSize);     /* flush any remaining inBuff */ 
+    op += outSize; 
+    epilogueSize = ZSTD_compressEnd(zbc->zc, zbc->outBuff + zbc->outBuffContentSize, zbc->outBuffSize - zbc->outBuffContentSize);   /* epilogue into outBuff */ 
+    zbc->outBuffContentSize += epilogueSize; 
+    outSize = oend-op; 
+    zbc->stage = ZBUFFcs_flush; 
+    remaining = ZBUFF_compressFlush(zbc, op, &outSize);   /* attempt to flush epilogue into dst */ 
+    op += outSize; 
+    if (!remaining) zbc->stage = ZBUFFcs_init;   /* close only if nothing left to flush */ 
+    *dstCapacityPtr = op-ostart;                 /* tells how many bytes were written */ 
+    return remaining; 
+} 
+ 
+ 
+ 
+/* ************************************* 
+*  Tool functions 
+***************************************/ 
+size_t ZBUFF_recommendedCInSize(void)  { return ZSTD_BLOCKSIZE_MAX; } 
+size_t ZBUFF_recommendedCOutSize(void) { return ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + ZBUFF_endFrameSize; } 
diff --git a/contrib/libs/zstd06/compress/zstd_compress.c b/contrib/libs/zstd06/compress/zstd_compress.c
index 1bb75c68cc..8072d19ae1 100644
--- a/contrib/libs/zstd06/compress/zstd_compress.c
+++ b/contrib/libs/zstd06/compress/zstd_compress.c
@@ -55,7 +55,7 @@
 #include <string.h>   /* memset */
 #include "mem.h"
 #include "fse_static.h"
-#include "huf_static.h"
+#include "huf_static.h" 
 #include "zstd_internal.h"
 
 
@@ -218,7 +218,7 @@ static size_t ZSTD_resetCCtx_advanced (ZSTD_CCtx* zc,
     const size_t maxNbSeq = blockSize / divider;
     const size_t tokenSpace = blockSize + 11*maxNbSeq;
     const size_t chainSize = (params.cParams.strategy == ZSTD_fast) ? 0 : (1 << params.cParams.chainLog);
-    const size_t hSize = ((size_t)1) << params.cParams.hashLog;
+    const size_t hSize = ((size_t)1) << params.cParams.hashLog; 
     const size_t h3Size = (zc->hashLog3) ? 1 << zc->hashLog3 : 0;
     const size_t tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);
 
@@ -291,7 +291,7 @@ size_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx)
 
     /* copy tables */
     {   const size_t chainSize = (srcCCtx->params.cParams.strategy == ZSTD_fast) ? 0 : (1 << srcCCtx->params.cParams.chainLog);
-        const size_t hSize = ((size_t)1) << srcCCtx->params.cParams.hashLog;
+        const size_t hSize = ((size_t)1) << srcCCtx->params.cParams.hashLog; 
         const size_t h3Size = (srcCCtx->hashLog3) ? 1 << srcCCtx->hashLog3 : 0;
         const size_t tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);
         memcpy(dstCCtx->workSpace, srcCCtx->workSpace, tableSpace);
@@ -852,7 +852,7 @@ MEM_STATIC void ZSTD_storeSeq(seqStore_t* seqStorePtr, size_t litLength, const B
     static const BYTE* g_start = NULL;
     const U32 pos = (U32)(literals - g_start);
     if (g_start==NULL) g_start = literals;
-    if ((pos > 2587900) && (pos < 2588050))
+    if ((pos > 2587900) && (pos < 2588050)) 
         printf("Cpos %6u :%5u literals & match %3u bytes at distance %6u \n",
                pos, (U32)litLength, (U32)matchCode+MINMATCH, (U32)offsetCode);
 #endif
@@ -1966,16 +1966,16 @@ static void ZSTD_compressBlock_btlazy2_extDict(ZSTD_CCtx* ctx, const void* src,
     ZSTD_compressBlock_lazy_extDict_generic(ctx, src, srcSize, 1, 2);
 }
 
-
-
-/* The optimal parser */
-#include "zstd_opt.h"
-
-static void ZSTD_compressBlock_btopt(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
-{
-    ZSTD_compressBlock_opt_generic(ctx, src, srcSize);
-}
-
+ 
+ 
+/* The optimal parser */ 
+#include "zstd_opt.h" 
+ 
+static void ZSTD_compressBlock_btopt(ZSTD_CCtx* ctx, const void* src, size_t srcSize) 
+{ 
+    ZSTD_compressBlock_opt_generic(ctx, src, srcSize); 
+} 
+ 
 static void ZSTD_compressBlock_btopt_extDict(ZSTD_CCtx* ctx, const void* src, size_t srcSize)
 {
     ZSTD_compressBlock_opt_extDict_generic(ctx, src, srcSize);
@@ -2432,8 +2432,8 @@ size_t ZSTD_compress(void* dst, size_t dstCapacity, const void* src, size_t srcS
 
 /*-=====  Pre-defined compression levels  =====-*/
 
-#define ZSTD_DEFAULT_CLEVEL 5
-#define ZSTD_MAX_CLEVEL     22
+#define ZSTD_DEFAULT_CLEVEL 5 
+#define ZSTD_MAX_CLEVEL     22 
 unsigned ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
 
 static const ZSTD_compressionParameters ZSTD_defaultCParameters[4][ZSTD_MAX_CLEVEL+1] = {
@@ -2552,8 +2552,8 @@ ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, U64 srcSize, si
     size_t const addedSize = srcSize ? 0 : 500;
     U64 const rSize = srcSize+dictSize ? srcSize+dictSize+addedSize : (U64)-1;
     U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);   /* intentional underflow for srcSizeHint == 0 */
-    if (compressionLevel < 0) compressionLevel = ZSTD_DEFAULT_CLEVEL;
-    if (compressionLevel==0) compressionLevel = 1;
+    if (compressionLevel < 0) compressionLevel = ZSTD_DEFAULT_CLEVEL; 
+    if (compressionLevel==0) compressionLevel = 1; 
     if (compressionLevel > ZSTD_MAX_CLEVEL) compressionLevel = ZSTD_MAX_CLEVEL;
     cp = ZSTD_defaultCParameters[tableID][compressionLevel];
     if (MEM_32bits()) {   /* auto-correction, for 32-bits mode */
diff --git a/contrib/libs/zstd06/compress/zstd_opt.h b/contrib/libs/zstd06/compress/zstd_opt.h
index 200eaf02a3..1bcba2732e 100644
--- a/contrib/libs/zstd06/compress/zstd_opt.h
+++ b/contrib/libs/zstd06/compress/zstd_opt.h
@@ -1,1033 +1,1033 @@
-#include <contrib/libs/zstd06/renames.h>
-/*
-    ZSTD Optimal mode
-    Copyright (C) 2016, Przemyslaw Skibinski, Yann Collet.
-
-    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are
-    met:
-
-    * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-    copyright notice, this list of conditions and the following disclaimer
-    in the documentation and/or other materials provided with the
-    distribution.
-
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    You can contact the author at :
-       - Zstd source repository : https://www.zstd.net
-*/
-
-/* Note : this file is intended to be included within zstd_compress.c */
-
-
-#define ZSTD_FREQ_DIV   5
-
-/*-*************************************
-*  Price functions for optimal parser
-***************************************/
-FORCE_INLINE void ZSTD_setLog2Prices(seqStore_t* ssPtr)
-{
-    ssPtr->log2matchLengthSum = ZSTD_highbit(ssPtr->matchLengthSum+1);
-    ssPtr->log2litLengthSum = ZSTD_highbit(ssPtr->litLengthSum+1);
-    ssPtr->log2litSum = ZSTD_highbit(ssPtr->litSum+1);
-    ssPtr->log2offCodeSum = ZSTD_highbit(ssPtr->offCodeSum+1);
-    ssPtr->factor = 1 + ((ssPtr->litSum>>5) / ssPtr->litLengthSum) + ((ssPtr->litSum<<1) / (ssPtr->litSum + ssPtr->matchSum));
-}
-
-
-MEM_STATIC void ZSTD_rescaleFreqs(seqStore_t* ssPtr)
-{
-    unsigned u;
-
-    ssPtr->cachedLiterals = NULL;
-    ssPtr->cachedPrice = ssPtr->cachedLitLength = 0;
-
-    if (ssPtr->litLengthSum == 0) {
-        ssPtr->litSum = (2<<Litbits);
-        ssPtr->litLengthSum = MaxLL+1;
-        ssPtr->matchLengthSum = MaxML+1;
-        ssPtr->offCodeSum = (MaxOff+1);
-        ssPtr->matchSum = (2<<Litbits);
-
-        for (u=0; u<=MaxLit; u++)
-            ssPtr->litFreq[u] = 2;
-        for (u=0; u<=MaxLL; u++)
-            ssPtr->litLengthFreq[u] = 1;
-        for (u=0; u<=MaxML; u++)
-            ssPtr->matchLengthFreq[u] = 1;
-        for (u=0; u<=MaxOff; u++)
-            ssPtr->offCodeFreq[u] = 1;
-    } else {
-        ssPtr->matchLengthSum = 0;
-        ssPtr->litLengthSum = 0;
-        ssPtr->offCodeSum = 0;
-        ssPtr->matchSum = 0;
-        ssPtr->litSum = 0;
-
-        for (u=0; u<=MaxLit; u++) {
-            ssPtr->litFreq[u] = 1 + (ssPtr->litFreq[u]>>ZSTD_FREQ_DIV);
-            ssPtr->litSum += ssPtr->litFreq[u];
-        }
-        for (u=0; u<=MaxLL; u++) {
-            ssPtr->litLengthFreq[u] = 1 + (ssPtr->litLengthFreq[u]>>ZSTD_FREQ_DIV);
-            ssPtr->litLengthSum += ssPtr->litLengthFreq[u];
-        }
-        for (u=0; u<=MaxML; u++) {
-            ssPtr->matchLengthFreq[u] = 1 + (ssPtr->matchLengthFreq[u]>>ZSTD_FREQ_DIV);
-            ssPtr->matchLengthSum += ssPtr->matchLengthFreq[u];
-            ssPtr->matchSum += ssPtr->matchLengthFreq[u] * (u + 3);
-        }
-        for (u=0; u<=MaxOff; u++) {
-            ssPtr->offCodeFreq[u] = 1 + (ssPtr->offCodeFreq[u]>>ZSTD_FREQ_DIV);
-            ssPtr->offCodeSum += ssPtr->offCodeFreq[u];
-        }
-    }
-
-    ZSTD_setLog2Prices(ssPtr);
-}
-
-
-FORCE_INLINE U32 ZSTD_getLiteralPrice(seqStore_t* ssPtr, U32 litLength, const BYTE* literals)
-{
-    U32 price, u;
-
-    if (litLength == 0)
-        return ssPtr->log2litLengthSum - ZSTD_highbit(ssPtr->litLengthFreq[0]+1);
-
-    /* literals */
-    if (ssPtr->cachedLiterals == literals) {
-        U32 additional = litLength - ssPtr->cachedLitLength;
-        const BYTE* literals2 = ssPtr->cachedLiterals + ssPtr->cachedLitLength;
-        price = ssPtr->cachedPrice + additional * ssPtr->log2litSum;
-        for (u=0; u < additional; u++)
-            price -= ZSTD_highbit(ssPtr->litFreq[literals2[u]]+1);
-        ssPtr->cachedPrice = price;
-        ssPtr->cachedLitLength = litLength;
-    } else {
-        price = litLength * ssPtr->log2litSum;
-        for (u=0; u < litLength; u++)
-            price -= ZSTD_highbit(ssPtr->litFreq[literals[u]]+1);
-
-        if (litLength >= 12) {
-            ssPtr->cachedLiterals = literals;
-            ssPtr->cachedPrice = price;
-            ssPtr->cachedLitLength = litLength;
-        }
-    }
-
-    /* literal Length */
-    {   static const BYTE LL_Code[64] = {  0,  1,  2,  3,  4,  5,  6,  7,
-                                           8,  9, 10, 11, 12, 13, 14, 15,
-                                          16, 16, 17, 17, 18, 18, 19, 19,
-                                          20, 20, 20, 20, 21, 21, 21, 21,
-                                          22, 22, 22, 22, 22, 22, 22, 22,
-                                          23, 23, 23, 23, 23, 23, 23, 23,
-                                          24, 24, 24, 24, 24, 24, 24, 24,
-                                          24, 24, 24, 24, 24, 24, 24, 24 };
-        const BYTE LL_deltaCode = 19;
-        const BYTE llCode = (litLength>63) ? (BYTE)ZSTD_highbit(litLength) + LL_deltaCode : LL_Code[litLength];
-        price += LL_bits[llCode] + ssPtr->log2litLengthSum - ZSTD_highbit(ssPtr->litLengthFreq[llCode]+1);
-    }
-
-    return price;
-}
-
-
-FORCE_INLINE U32 ZSTD_getPrice(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength)
-{
-    /* offset */
-    BYTE offCode = (BYTE)ZSTD_highbit(offset+1);
-    U32 price = offCode + seqStorePtr->log2offCodeSum - ZSTD_highbit(seqStorePtr->offCodeFreq[offCode]+1);
-
-    /* match Length */
-    {   static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
-                                          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
-                                          32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37,
-                                          38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39,
-                                          40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
-                                          41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
-                                          42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
-                                          42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 };
-        const BYTE ML_deltaCode = 36;
-        const BYTE mlCode = (matchLength>127) ? (BYTE)ZSTD_highbit(matchLength) + ML_deltaCode : ML_Code[matchLength];
-        price += ML_bits[mlCode] + seqStorePtr->log2matchLengthSum - ZSTD_highbit(seqStorePtr->matchLengthFreq[mlCode]+1);
-    }
-
-    return price + ZSTD_getLiteralPrice(seqStorePtr, litLength, literals) + seqStorePtr->factor;
-}
-
-
-MEM_STATIC void ZSTD_updatePrice(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength)
-{
-    U32 u;
-
-    /* literals */
-    seqStorePtr->litSum += litLength;
-    for (u=0; u < litLength; u++)
-        seqStorePtr->litFreq[literals[u]]++;
-
-    /* literal Length */
-    {   static const BYTE LL_Code[64] = {  0,  1,  2,  3,  4,  5,  6,  7,
-                                           8,  9, 10, 11, 12, 13, 14, 15,
-                                          16, 16, 17, 17, 18, 18, 19, 19,
-                                          20, 20, 20, 20, 21, 21, 21, 21,
-                                          22, 22, 22, 22, 22, 22, 22, 22,
-                                          23, 23, 23, 23, 23, 23, 23, 23,
-                                          24, 24, 24, 24, 24, 24, 24, 24,
-                                          24, 24, 24, 24, 24, 24, 24, 24 };
-        const BYTE LL_deltaCode = 19;
-        const BYTE llCode = (litLength>63) ? (BYTE)ZSTD_highbit(litLength) + LL_deltaCode : LL_Code[litLength];
-        seqStorePtr->litLengthFreq[llCode]++;
-        seqStorePtr->litLengthSum++;
-    }
-
-    /* match offset */
-	{   BYTE offCode = (BYTE)ZSTD_highbit(offset+1);
-		seqStorePtr->offCodeSum++;
-		seqStorePtr->offCodeFreq[offCode]++;
-	}
-
-    /* match Length */
-    {   static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
-                                          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
-                                          32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37,
-                                          38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39,
-                                          40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
-                                          41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
-                                          42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
-                                          42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 };
-        const BYTE ML_deltaCode = 36;
-        const BYTE mlCode = (matchLength>127) ? (BYTE)ZSTD_highbit(matchLength) + ML_deltaCode : ML_Code[matchLength];
-        seqStorePtr->matchLengthFreq[mlCode]++;
-        seqStorePtr->matchLengthSum++;
-    }
-
-    ZSTD_setLog2Prices(seqStorePtr);
-}
-
-
-#define SET_PRICE(pos, mlen_, offset_, litlen_, price_)   \
-    {                                                 \
-        while (last_pos < pos)  { opt[last_pos+1].price = 1<<30; last_pos++; } \
-        opt[pos].mlen = mlen_;                         \
-        opt[pos].off = offset_;                        \
-        opt[pos].litlen = litlen_;                     \
-        opt[pos].price = price_;                       \
-        ZSTD_LOG_PARSER("%d: SET price[%d/%d]=%d litlen=%d len=%d off=%d\n", (int)(inr-base), (int)pos, (int)last_pos, opt[pos].price, opt[pos].litlen, opt[pos].mlen, opt[pos].off); \
-    }
-
-
-
-
-/* Update hashTable3 up to ip (excluded)
-   Assumption : always within prefix (ie. not within extDict) */
-FORCE_INLINE
-U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip)
-{
-    U32* const hashTable3  = zc->hashTable3;
-    U32 const hashLog3  = zc->hashLog3;
-    const BYTE* const base = zc->base;
-    U32 idx = zc->nextToUpdate3;
-    const U32 target = zc->nextToUpdate3 = (U32)(ip - base);
-    const size_t hash3 = ZSTD_hash3Ptr(ip, hashLog3);
-
-    while(idx < target) {
-        hashTable3[ZSTD_hash3Ptr(base+idx, hashLog3)] = idx;
-        idx++;
-    }
-
-    return hashTable3[hash3];
-}
-
-
-/*-*************************************
-*  Binary Tree search
-***************************************/
-static U32 ZSTD_insertBtAndGetAllMatches (
-                        ZSTD_CCtx* zc,
-                        const BYTE* const ip, const BYTE* const iLimit,
-                        U32 nbCompares, const U32 mls,
-                        U32 extDict, ZSTD_match_t* matches, const U32 minMatchLen)
-{
-    const BYTE* const base = zc->base;
-    const U32 current = (U32)(ip-base);
-    const U32 hashLog = zc->params.cParams.hashLog;
-    const size_t h  = ZSTD_hashPtr(ip, hashLog, mls);
-    U32* const hashTable = zc->hashTable;
-    U32 matchIndex  = hashTable[h];
-    U32* const bt   = zc->chainTable;
-    const U32 btLog = zc->params.cParams.chainLog - 1;
-    const U32 btMask= (1U << btLog) - 1;
-    size_t commonLengthSmaller=0, commonLengthLarger=0;
-    const BYTE* const dictBase = zc->dictBase;
-    const U32 dictLimit = zc->dictLimit;
-    const BYTE* const dictEnd = dictBase + dictLimit;
-    const BYTE* const prefixStart = base + dictLimit;
-    const U32 btLow = btMask >= current ? 0 : current - btMask;
-    const U32 windowLow = zc->lowLimit;
-    U32* smallerPtr = bt + 2*(current&btMask);
-    U32* largerPtr  = bt + 2*(current&btMask) + 1;
-    U32 matchEndIdx = current+8;
-    U32 dummy32;   /* to be nullified at the end */
-    U32 mnum = 0;
-
-    const U32 minMatch = (mls == 3) ? 3 : 4;
-    size_t bestLength = minMatchLen-1;
-
-    if (minMatch == 3) { /* HC3 match finder */
-        U32 const matchIndex3 = ZSTD_insertAndFindFirstIndexHash3 (zc, ip);
-        if (matchIndex3>windowLow && (current - matchIndex3 < (1<<18))) {
-            const BYTE* match;
-            size_t currentMl=0;
-            if ((!extDict) || matchIndex3 >= dictLimit) {
-                match = base + matchIndex3;
-                if (match[bestLength] == ip[bestLength]) currentMl = ZSTD_count(ip, match, iLimit);
-            } else {
-                match = dictBase + matchIndex3;
-                if (MEM_readMINMATCH(match, MINMATCH) == MEM_readMINMATCH(ip, MINMATCH))    /* assumption : matchIndex3 <= dictLimit-4 (by table construction) */
-                    currentMl = ZSTD_count_2segments(ip+MINMATCH, match+MINMATCH, iLimit, dictEnd, prefixStart) + MINMATCH;
-            }
-
-            /* save best solution */
-            if (currentMl > bestLength) {
-                bestLength = currentMl;
-                matches[mnum].off = ZSTD_REP_MOVE + current - matchIndex3;
-                matches[mnum].len = (U32)currentMl;
-                mnum++;
-                if (currentMl > ZSTD_OPT_NUM) goto update;
-                if (ip+currentMl == iLimit) goto update; /* best possible, and avoid read overflow*/
-            }
-        }
-    }
-
-    hashTable[h] = current;   /* Update Hash Table */
-
-    while (nbCompares-- && (matchIndex > windowLow)) {
-        U32* nextPtr = bt + 2*(matchIndex & btMask);
-        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */
-        const BYTE* match;
-
-        if ((!extDict) || (matchIndex+matchLength >= dictLimit)) {
-            match = base + matchIndex;
-            if (match[matchLength] == ip[matchLength]) {
-#if ZSTD_OPT_DEBUG >= 5
-            size_t ml;
-            if (matchIndex < dictLimit)
-                ml = ZSTD_count_2segments(ip, dictBase + matchIndex, iLimit, dictEnd, prefixStart);
-            else
-                ml = ZSTD_count(ip, match, ip+matchLength);
-            if (ml < matchLength)
-                printf("%d: ERROR_NOEXT: offset=%d matchLength=%d matchIndex=%d dictLimit=%d ml=%d\n", current, (int)(current - matchIndex), (int)matchLength, (int)matchIndex, (int)dictLimit, (int)ml), exit(0);
-#endif
-                matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iLimit) +1;
-            }
-        } else {
-            match = dictBase + matchIndex;
-#if ZSTD_OPT_DEBUG >= 5
-            if (memcmp(match, ip, matchLength) != 0)
-                 printf("%d: ERROR_EXT: matchLength=%d ZSTD_count=%d\n", current, (int)matchLength, (int)ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dictEnd, prefixStart)), exit(0);
-#endif
-            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dictEnd, prefixStart);
-            ZSTD_LOG_PARSER("%d: ZSTD_INSERTBTANDGETALLMATCHES=%d offset=%d dictBase=%p dictEnd=%p prefixStart=%p ip=%p match=%p\n", (int)current, (int)matchLength, (int)(current - matchIndex), dictBase, dictEnd, prefixStart, ip, match);
-            if (matchIndex+matchLength >= dictLimit)
-                match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */
-        }
-
-        if (matchLength > bestLength) {
-            if (matchLength > matchEndIdx - matchIndex) matchEndIdx = matchIndex + (U32)matchLength;
-            bestLength = matchLength;
-            matches[mnum].off = ZSTD_REP_MOVE + current - matchIndex;
-            matches[mnum].len = (U32)matchLength;
-            mnum++;
-            if (matchLength > ZSTD_OPT_NUM) break;
-            if (ip+matchLength == iLimit)   /* equal : no way to know if inf or sup */
-                break;   /* drop, to guarantee consistency (miss a little bit of compression) */
-        }
-
-        if (match[matchLength] < ip[matchLength]) {
-            /* match is smaller than current */
-            *smallerPtr = matchIndex;             /* update smaller idx */
-            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */
-            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-            smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */
-            matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */
-        } else {
-            /* match is larger than current */
-            *largerPtr = matchIndex;
-            commonLengthLarger = matchLength;
-            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */
-            largerPtr = nextPtr;
-            matchIndex = nextPtr[0];
-    }   }
-
-    *smallerPtr = *largerPtr = 0;
-
-update:
-    zc->nextToUpdate = (matchEndIdx > current + 8) ? matchEndIdx - 8 : current+1;
-    return mnum;
-}
-
-
-/** Tree updater, providing best match */
-static U32 ZSTD_BtGetAllMatches (
-                        ZSTD_CCtx* zc,
-                        const BYTE* const ip, const BYTE* const iLimit,
-                        const U32 maxNbAttempts, const U32 mls, ZSTD_match_t* matches, const U32 minMatchLen)
-{
-    if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
-    ZSTD_updateTree(zc, ip, iLimit, maxNbAttempts, mls);
-    return ZSTD_insertBtAndGetAllMatches(zc, ip, iLimit, maxNbAttempts, mls, 0, matches, minMatchLen);
-}
-
-
-static U32 ZSTD_BtGetAllMatches_selectMLS (
-                        ZSTD_CCtx* zc,   /* Index table will be updated */
-                        const BYTE* ip, const BYTE* const iHighLimit,
-                        const U32 maxNbAttempts, const U32 matchLengthSearch, ZSTD_match_t* matches, const U32 minMatchLen)
-{
-    switch(matchLengthSearch)
-    {
-    case 3 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 3, matches, minMatchLen);
-    default :
-    case 4 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 4, matches, minMatchLen);
-    case 5 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 5, matches, minMatchLen);
-    case 6 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 6, matches, minMatchLen);
-    }
-}
-
-/** Tree updater, providing best match */
-static U32 ZSTD_BtGetAllMatches_extDict (
-                        ZSTD_CCtx* zc,
-                        const BYTE* const ip, const BYTE* const iLimit,
-                        const U32 maxNbAttempts, const U32 mls, ZSTD_match_t* matches, const U32 minMatchLen)
-{
-    if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */
-    ZSTD_updateTree_extDict(zc, ip, iLimit, maxNbAttempts, mls);
-    return ZSTD_insertBtAndGetAllMatches(zc, ip, iLimit, maxNbAttempts, mls, 1, matches, minMatchLen);
-}
-
-
-static U32 ZSTD_BtGetAllMatches_selectMLS_extDict (
-                        ZSTD_CCtx* zc,   /* Index table will be updated */
-                        const BYTE* ip, const BYTE* const iHighLimit,
-                        const U32 maxNbAttempts, const U32 matchLengthSearch, ZSTD_match_t* matches, const U32 minMatchLen)
-{
-    switch(matchLengthSearch)
-    {
-    case 3 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 3, matches, minMatchLen);
-    default :
-    case 4 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 4, matches, minMatchLen);
-    case 5 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 5, matches, minMatchLen);
-    case 6 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 6, matches, minMatchLen);
-    }
-}
-
-
-/*-*******************************
-*  Optimal parser
-*********************************/
-FORCE_INLINE
-void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
-                                    const void* src, size_t srcSize)
-{
-    seqStore_t* seqStorePtr = &(ctx->seqStore);
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - 8;
-    const BYTE* const base = ctx->base;
-    const BYTE* const prefixStart = base + ctx->dictLimit;
-
-    const U32 maxSearches = 1U << ctx->params.cParams.searchLog;
-    const U32 sufficient_len = ctx->params.cParams.targetLength;
-    const U32 mls = ctx->params.cParams.searchLength;
-    const U32 minMatch = (ctx->params.cParams.searchLength == 3) ? 3 : 4;
-
-    ZSTD_optimal_t* opt = seqStorePtr->priceTable;
-    ZSTD_match_t* matches = seqStorePtr->matchTable;
-    const BYTE* inr;
-
-    /* init */
-    U32 offset, rep[ZSTD_REP_INIT];
-    { U32 i; for (i=0; i<ZSTD_REP_INIT; i++) rep[i]=REPCODE_STARTVALUE; }
-
-    ctx->nextToUpdate3 = ctx->nextToUpdate;
-    ZSTD_resetSeqStore(seqStorePtr);
-    ZSTD_rescaleFreqs(seqStorePtr);
-    if ((ip-prefixStart) < REPCODE_STARTVALUE) ip = prefixStart + REPCODE_STARTVALUE;
-
-    ZSTD_LOG_BLOCK("%d: COMPBLOCK_OPT_GENERIC srcSz=%d maxSrch=%d mls=%d sufLen=%d\n", (int)(ip-base), (int)srcSize, maxSearches, mls, sufficient_len);
-
-    /* Match Loop */
-    while (ip < ilimit) {
-        U32 cur, match_num, last_pos, litlen, price;
-        U32 u, mlen, best_mlen, best_off, litLength;
-        memset(opt, 0, sizeof(ZSTD_optimal_t));
-        last_pos = 0;
-        litlen = (U32)(ip - anchor);
-
-        /* check repCode */
-        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++)
-        if (MEM_readMINMATCH(ip, minMatch) == MEM_readMINMATCH(ip - rep[i], minMatch)) {
-            /* repcode : we take it */
-            mlen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-rep[i], iend) + minMatch;
-            ZSTD_LOG_PARSER("%d: start try REP rep[%d]=%d mlen=%d\n", (int)(ip-base), i, (int)rep[i], (int)mlen);
-            if (mlen > sufficient_len || mlen >= ZSTD_OPT_NUM) {
-                best_mlen = mlen; best_off = i; cur = 0; last_pos = 1;
-                goto _storeSequence;
-            }
-            best_off = (i<=1 && ip == anchor) ? 1-i : i;
-            do {
-                price = ZSTD_getPrice(seqStorePtr, litlen, anchor, best_off, mlen - MINMATCH);
-                if (mlen > last_pos || price < opt[mlen].price)
-                    SET_PRICE(mlen, mlen, i, litlen, price);   /* note : macro modifies last_pos */
-                mlen--;
-            } while (mlen >= minMatch);
-        } }
-
-        match_num = ZSTD_BtGetAllMatches_selectMLS(ctx, ip, iend, maxSearches, mls, matches, minMatch);
-
-        ZSTD_LOG_PARSER("%d: match_num=%d last_pos=%d\n", (int)(ip-base), match_num, last_pos);
-        if (!last_pos && !match_num) { ip++; continue; }
-
-        if (match_num && (matches[match_num-1].len > sufficient_len || matches[match_num-1].len >= ZSTD_OPT_NUM)) {
-            best_mlen = matches[match_num-1].len;
-            best_off = matches[match_num-1].off;
-            cur = 0;
-            last_pos = 1;
-            goto _storeSequence;
-        }
-
-        /* set prices using matches at position = 0 */
-        best_mlen = (last_pos) ? last_pos : minMatch;
-        for (u = 0; u < match_num; u++) {
-           mlen = (u>0) ? matches[u-1].len+1 : best_mlen;
-           best_mlen = matches[u].len;
-           ZSTD_LOG_PARSER("%d: start Found mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(ip-base), matches[u].len, matches[u].off, (int)best_mlen, (int)last_pos);
-           while (mlen <= best_mlen) {
-                price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off, mlen - MINMATCH);
-                if (mlen > last_pos || price < opt[mlen].price)
-                    SET_PRICE(mlen, mlen, matches[u].off, litlen, price);   /* note : macro modifies last_pos */
-                mlen++;
-        }  }
-
-        if (last_pos < minMatch) { ip++; continue; }
-
-        /* initialize opt[0] */
-        { U32 i ; for (i=0; i<ZSTD_REP_INIT; i++) opt[0].rep[i] = rep[i]; }
-        opt[0].mlen = 1;
-        opt[0].litlen = litlen;
-
-         /* check further positions */
-        for (cur = 1; cur <= last_pos; cur++) {
-           inr = ip + cur;
-
-           if (opt[cur-1].mlen == 1) {
-                litlen = opt[cur-1].litlen + 1;
-                if (cur > litlen) {
-                    price = opt[cur - litlen].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-litlen);
-                } else
-                    price = ZSTD_getLiteralPrice(seqStorePtr, litlen, anchor);
-           } else {
-                litlen = 1;
-                price = opt[cur - 1].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-1);
-           }
-
-           if (cur > last_pos || price <= opt[cur].price) // || ((price == opt[cur].price) && (opt[cur-1].mlen == 1) && (cur != litlen)))
-                SET_PRICE(cur, 1, 0, litlen, price);
-
-           if (cur == last_pos) break;
-
-           if (inr > ilimit)  /* last match must start at a minimum distance of 8 from oend */
-               continue;
-
-           mlen = opt[cur].mlen;
-           if (opt[cur].off >= ZSTD_REP_NUM) {
-                opt[cur].rep[2] = opt[cur-mlen].rep[1];
-                opt[cur].rep[1] = opt[cur-mlen].rep[0];
-                opt[cur].rep[0] = opt[cur].off - ZSTD_REP_MOVE;
-                ZSTD_LOG_ENCODE("%d: COPYREP_OFF cur=%d mlen=%d rep[0]=%d rep[1]=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep[0], opt[cur].rep[1]);
-           } else {
-                opt[cur].rep[2] = (opt[cur].off > 1) ? opt[cur-mlen].rep[1] : opt[cur-mlen].rep[2];
-                opt[cur].rep[1] = (opt[cur].off > 0) ? opt[cur-mlen].rep[0] : opt[cur-mlen].rep[1];
-                opt[cur].rep[0] = opt[cur-mlen].rep[opt[cur].off];
-                ZSTD_LOG_ENCODE("%d: COPYREP_NOR cur=%d mlen=%d rep[0]=%d rep[1]=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep[0], opt[cur].rep[1]);
-           }
-
-           ZSTD_LOG_PARSER("%d: CURRENT_NoExt price[%d/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(inr-base), cur, last_pos, opt[cur].price, opt[cur].off, opt[cur].mlen, opt[cur].litlen, opt[cur].rep[0], opt[cur].rep[1]);
-
-           best_mlen = minMatch;
-           { U32 i; for (i=0; i<ZSTD_REP_NUM; i++)
-           if (MEM_readMINMATCH(inr, minMatch) == MEM_readMINMATCH(inr - opt[cur].rep[i], minMatch)) {  /* check rep */
-               mlen = (U32)ZSTD_count(inr+minMatch, inr+minMatch - opt[cur].rep[i], iend) + minMatch;
-               ZSTD_LOG_PARSER("%d: Found REP %d/%d mlen=%d off=%d rep=%d opt[%d].off=%d\n", (int)(inr-base), i, ZSTD_REP_NUM, mlen, i, opt[cur].rep[i], cur, opt[cur].off);
-
-               if (mlen > sufficient_len || cur + mlen >= ZSTD_OPT_NUM) {
-                    ZSTD_LOG_PARSER("%d: REP sufficient_len=%d best_mlen=%d best_off=%d last_pos=%d\n", (int)(inr-base), sufficient_len, best_mlen, best_off, last_pos);
-                    best_mlen = mlen; best_off = i; last_pos = cur + 1;
-                    goto _storeSequence;
-               }
-
-               best_off = (i<=1 && opt[cur].mlen != 1) ? 1-i : i;
-               if (opt[cur].mlen == 1) {
-                    litlen = opt[cur].litlen;
-                    if (cur > litlen) {
-                        price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, inr-litlen, best_off, mlen - MINMATCH);
-                    } else
-                        price = ZSTD_getPrice(seqStorePtr, litlen, anchor, best_off, mlen - MINMATCH);
-                } else {
-                    litlen = 0;
-                    price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, best_off, mlen - MINMATCH);
-                }
-
-                if (mlen > best_mlen) best_mlen = mlen;
-                ZSTD_LOG_PARSER("%d: Found REP mlen=%d off=%d price=%d litlen=%d\n", (int)(inr-base), mlen, best_off, price, litlen);
-
-                do {
-                    if (cur + mlen > last_pos || price <= opt[cur + mlen].price)
-                        SET_PRICE(cur + mlen, mlen, i, litlen, price);
-                    mlen--;
-                } while (mlen >= minMatch);
-            } }
-
-            match_num = ZSTD_BtGetAllMatches_selectMLS(ctx, inr, iend, maxSearches, mls, matches, best_mlen);
-            ZSTD_LOG_PARSER("%d: ZSTD_GetAllMatches match_num=%d\n", (int)(inr-base), match_num);
-
-            if (match_num > 0 && (matches[match_num-1].len > sufficient_len || cur + matches[match_num-1].len >= ZSTD_OPT_NUM)) {
-                best_mlen = matches[match_num-1].len;
-                best_off = matches[match_num-1].off;
-                last_pos = cur + 1;
-                goto _storeSequence;
-            }
-
-            /* set prices using matches at position = cur */
-            for (u = 0; u < match_num; u++) {
-                mlen = (u>0) ? matches[u-1].len+1 : best_mlen;
-                best_mlen = matches[u].len;
-
-              //  ZSTD_LOG_PARSER("%d: Found1 cur=%d mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(inr-base), cur, matches[u].len, matches[u].off, best_mlen, last_pos);
-                while (mlen <= best_mlen) {
-                    if (opt[cur].mlen == 1) {
-                        litlen = opt[cur].litlen;
-                        if (cur > litlen)
-                            price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip+cur-litlen, matches[u].off, mlen - MINMATCH);
-                        else
-                            price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off, mlen - MINMATCH);
-                    } else {
-                        litlen = 0;
-                        price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, matches[u].off, mlen - MINMATCH);
-                    }
-
-                  //  ZSTD_LOG_PARSER("%d: Found2 mlen=%d best_mlen=%d off=%d price=%d litlen=%d\n", (int)(inr-base), mlen, best_mlen, matches[u].off, price, litlen);
-                    if (cur + mlen > last_pos || (price < opt[cur + mlen].price))
-                        SET_PRICE(cur + mlen, mlen, matches[u].off, litlen, price);
-
-                    mlen++;
-        }   }   }   //  for (cur = 1; cur <= last_pos; cur++)
-
-        best_mlen = opt[last_pos].mlen;
-        best_off = opt[last_pos].off;
-        cur = last_pos - best_mlen;
-
-        /* store sequence */
-_storeSequence:   /* cur, last_pos, best_mlen, best_off have to be set */
-        for (u = 1; u <= last_pos; u++)
-            ZSTD_LOG_PARSER("%d: price[%d/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base+u), u, last_pos, opt[u].price, opt[u].off, opt[u].mlen, opt[u].litlen, opt[u].rep[0], opt[u].rep[1]);
-        ZSTD_LOG_PARSER("%d: cur=%d/%d best_mlen=%d best_off=%d rep[0]=%d\n", (int)(ip-base+cur), (int)cur, (int)last_pos, (int)best_mlen, (int)best_off, opt[cur].rep[0]);
-
-        opt[0].mlen = 1;
-
-        while (1) {
-            mlen = opt[cur].mlen;
-            offset = opt[cur].off;
-            opt[cur].mlen = best_mlen;
-            opt[cur].off = best_off;
-            best_mlen = mlen;
-            best_off = offset;
-            if (mlen > cur) break;
-            cur -= mlen;
-        }
-
-        for (u = 0; u <= last_pos;) {
-            ZSTD_LOG_PARSER("%d: price2[%d/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base+u), u, last_pos, opt[u].price, opt[u].off, opt[u].mlen, opt[u].litlen, opt[u].rep[0], opt[u].rep[1]);
-            u += opt[u].mlen;
-        }
-
-        for (cur=0; cur < last_pos; ) {
-            ZSTD_LOG_PARSER("%d: price3[%d/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base+cur), cur, last_pos, opt[cur].price, opt[cur].off, opt[cur].mlen, opt[cur].litlen, opt[cur].rep[0], opt[cur].rep[1]);
-            mlen = opt[cur].mlen;
-            if (mlen == 1) { ip++; cur++; continue; }
-            offset = opt[cur].off;
-            cur += mlen;
-            litLength = (U32)(ip - anchor);
-           // ZSTD_LOG_ENCODE("%d/%d: ENCODE literals=%d mlen=%d off=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base), (int)(iend-base), (int)(litLength), (int)mlen, (int)(offset), (int)rep[0], (int)rep[1]);
-
-            if (offset >= ZSTD_REP_NUM) {
-                rep[2] = rep[1];
-                rep[1] = rep[0];
-                rep[0] = offset - ZSTD_REP_MOVE;
-            } else {
-                if (offset != 0) {
-                    best_off = rep[offset];
-                    if (offset != 1) rep[2] = rep[1];
-                    rep[1] = rep[0];
-                    rep[0] = best_off;
-                }
-                if (litLength == 0 && offset<=1) offset = 1-offset;
-            }
-
-            ZSTD_LOG_ENCODE("%d/%d: ENCODE literals=%d mlen=%d off=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base), (int)(iend-base), (int)(litLength), (int)mlen, (int)(offset), (int)rep[0], (int)rep[1]);
-
-#if ZSTD_OPT_DEBUG >= 5
-            U32 ml2;
-            if (offset >= ZSTD_REP_NUM)
-                ml2 = (U32)ZSTD_count(ip, ip-(offset-ZSTD_REP_MOVE), iend);
-            else
-                ml2 = (U32)ZSTD_count(ip, ip-rep[0], iend);
-            if ((offset >= 8) && (ml2 < mlen || ml2 < minMatch)) {
-                printf("%d: ERROR_NoExt iend=%d mlen=%d offset=%d ml2=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset, (int)ml2); exit(0); }
-            if (ip < anchor) {
-                printf("%d: ERROR_NoExt ip < anchor iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
-            if (ip + mlen > iend) {
-                printf("%d: ERROR_NoExt ip + mlen >= iend iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
-#endif
-
-            ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
-            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
-            anchor = ip = ip + mlen;
-    }    }   /* for (cur=0; cur < last_pos; ) */
-
-    {   /* Last Literals */
-        size_t lastLLSize = iend - anchor;
-        ZSTD_LOG_ENCODE("%d: lastLLSize literals=%u\n", (int)(ip-base), (U32)lastLLSize);
-        memcpy(seqStorePtr->lit, anchor, lastLLSize);
-        seqStorePtr->lit += lastLLSize;
-    }
-}
-
-
-FORCE_INLINE
-void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
-                                     const void* src, size_t srcSize)
-{
-    seqStore_t* seqStorePtr = &(ctx->seqStore);
-    const BYTE* const istart = (const BYTE*)src;
-    const BYTE* ip = istart;
-    const BYTE* anchor = istart;
-    const BYTE* const iend = istart + srcSize;
-    const BYTE* const ilimit = iend - 8;
-    const BYTE* const base = ctx->base;
-    const U32 dictLimit = ctx->dictLimit;
-    const BYTE* const prefixStart = base + dictLimit;
-    const BYTE* const dictBase = ctx->dictBase;
-    const BYTE* const dictEnd  = dictBase + dictLimit;
-
-    const U32 maxSearches = 1U << ctx->params.cParams.searchLog;
-    const U32 sufficient_len = ctx->params.cParams.targetLength;
-    const U32 mls = ctx->params.cParams.searchLength;
-    const U32 minMatch = (ctx->params.cParams.searchLength == 3) ? 3 : 4;
-
-    ZSTD_optimal_t* opt = seqStorePtr->priceTable;
-    ZSTD_match_t* matches = seqStorePtr->matchTable;
-    const BYTE* inr;
-
-    /* init */
-    U32 offset, rep[ZSTD_REP_INIT];
-    { U32 i; for (i=0; i<ZSTD_REP_INIT; i++) rep[i]=REPCODE_STARTVALUE; }
-
-    ctx->nextToUpdate3 = ctx->nextToUpdate;
-    ZSTD_resetSeqStore(seqStorePtr);
-    ZSTD_rescaleFreqs(seqStorePtr);
-    if ((ip - prefixStart) < REPCODE_STARTVALUE) ip += REPCODE_STARTVALUE;
-
-    ZSTD_LOG_BLOCK("%d: COMPBLOCK_OPT_EXTDICT srcSz=%d maxSrch=%d mls=%d sufLen=%d\n", (int)(ip-base), (int)srcSize, maxSearches, mls, sufficient_len);
-
-    /* Match Loop */
-    while (ip < ilimit) {
-        U32 cur, match_num, last_pos, litlen, price;
-        U32 u, mlen, best_mlen, best_off, litLength;
-        U32 current = (U32)(ip-base);
-        memset(opt, 0, sizeof(ZSTD_optimal_t));
-        last_pos = 0;
-        inr = ip;
-        opt[0].litlen = (U32)(ip - anchor);
-
-        /* check repCode */
-        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) {
-            const U32 repIndex = (U32)(current - rep[i]);
-            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
-            const BYTE* const repMatch = repBase + repIndex;
-            if ( ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */
-               && (MEM_readMINMATCH(ip, minMatch) == MEM_readMINMATCH(repMatch, minMatch)) ) {
-                /* repcode detected we should take it */
-                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                mlen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iend, repEnd, prefixStart) + minMatch;
-
-                ZSTD_LOG_PARSER("%d: start try REP rep[%d]=%d mlen=%d\n", (int)(ip-base), i, (int)rep[i], (int)mlen);
-                if (mlen > sufficient_len || mlen >= ZSTD_OPT_NUM) {
-                    best_mlen = mlen; best_off = i; cur = 0; last_pos = 1;
-                    goto _storeSequence;
-                }
-
-                best_off = (i<=1 && ip == anchor) ? 1-i : i;
-                litlen = opt[0].litlen;
-                do {
-                    price = ZSTD_getPrice(seqStorePtr, litlen, anchor, best_off, mlen - MINMATCH);
-                    if (mlen > last_pos || price < opt[mlen].price)
-                        SET_PRICE(mlen, mlen, i, litlen, price);   /* note : macro modifies last_pos */
-                    mlen--;
-                } while (mlen >= minMatch);
-        }   } }
-
-        match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, ip, iend, maxSearches, mls, matches, minMatch);  /* first search (depth 0) */
-
-        ZSTD_LOG_PARSER("%d: match_num=%d last_pos=%d\n", (int)(ip-base), match_num, last_pos);
-        if (!last_pos && !match_num) { ip++; continue; }
-
-        { U32 i; for (i=0; i<ZSTD_REP_INIT; i++) opt[0].rep[i] = rep[i]; }
-        opt[0].mlen = 1;
-
-        if (match_num && (matches[match_num-1].len > sufficient_len || matches[match_num-1].len >= ZSTD_OPT_NUM)) {
-            best_mlen = matches[match_num-1].len;
-            best_off = matches[match_num-1].off;
-            cur = 0;
-            last_pos = 1;
-            goto _storeSequence;
-        }
-
-        best_mlen = (last_pos) ? last_pos : minMatch;
-
-        // set prices using matches at position = 0
-        for (u = 0; u < match_num; u++) {
-            mlen = (u>0) ? matches[u-1].len+1 : best_mlen;
-            best_mlen = matches[u].len;
-            ZSTD_LOG_PARSER("%d: start Found mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(ip-base), matches[u].len, matches[u].off, (int)best_mlen, (int)last_pos);
-            litlen = opt[0].litlen;
-            while (mlen <= best_mlen) {
-                price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off, mlen - MINMATCH);
-                if (mlen > last_pos || price < opt[mlen].price)
-                    SET_PRICE(mlen, mlen, matches[u].off, litlen, price);
-                mlen++;
-        }   }
-
-        if (last_pos < minMatch) {
-            // ip += ((ip-anchor) >> g_searchStrength) + 1;   /* jump faster over incompressible sections */
-            ip++; continue;
-        }
-
-        /* check further positions */
-        for (cur = 1; cur <= last_pos; cur++) {
-            inr = ip + cur;
-
-            if (opt[cur-1].mlen == 1) {
-                litlen = opt[cur-1].litlen + 1;
-                if (cur > litlen) {
-                    price = opt[cur - litlen].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-litlen);
-                } else
-                    price = ZSTD_getLiteralPrice(seqStorePtr, litlen, anchor);
-            } else {
-                litlen = 1;
-                price = opt[cur - 1].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-1);
-            }
-
-            if (cur > last_pos || price <= opt[cur].price) // || ((price == opt[cur].price) && (opt[cur-1].mlen == 1) && (cur != litlen)))
-                SET_PRICE(cur, 1, 0, litlen, price);
-
-            if (cur == last_pos) break;
-
-            if (inr > ilimit)  /* last match must start at a minimum distance of 8 from oend */
-                continue;
-
-            mlen = opt[cur].mlen;
-            if (opt[cur].off >= ZSTD_REP_NUM) {
-                opt[cur].rep[2] = opt[cur-mlen].rep[1];
-                opt[cur].rep[1] = opt[cur-mlen].rep[0];
-                opt[cur].rep[0] = opt[cur].off - ZSTD_REP_MOVE;
-                ZSTD_LOG_ENCODE("%d: COPYREP_OFF cur=%d mlen=%d rep[0]=%d rep[1]=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep[0], opt[cur].rep[1]);
-            } else {
-                opt[cur].rep[2] = (opt[cur].off > 1) ? opt[cur-mlen].rep[1] : opt[cur-mlen].rep[2];
-                opt[cur].rep[1] = (opt[cur].off > 0) ? opt[cur-mlen].rep[0] : opt[cur-mlen].rep[1];
-                opt[cur].rep[0] = opt[cur-mlen].rep[opt[cur].off];
-                ZSTD_LOG_ENCODE("%d: COPYREP_NOR cur=%d mlen=%d rep[0]=%d rep[1]=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep[0], opt[cur].rep[1]);
-            }
-
-            ZSTD_LOG_PARSER("%d: CURRENT_Ext price[%d/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(inr-base), cur, last_pos, opt[cur].price, opt[cur].off, opt[cur].mlen, opt[cur].litlen, opt[cur].rep[0], opt[cur].rep[1]);
-            best_mlen = 0;
-
-            { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) {
-                const U32 repIndex = (U32)(current+cur - opt[cur].rep[i]);
-                const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;
-                const BYTE* const repMatch = repBase + repIndex;
-                if ( ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */
-                  && (MEM_readMINMATCH(inr, minMatch) == MEM_readMINMATCH(repMatch, minMatch)) ) {
-                    /* repcode detected */
-                    const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;
-                    mlen = (U32)ZSTD_count_2segments(inr+minMatch, repMatch+minMatch, iend, repEnd, prefixStart) + minMatch;
-                    ZSTD_LOG_PARSER("%d: Found REP %d/%d mlen=%d off=%d rep=%d opt[%d].off=%d\n", (int)(inr-base), i, ZSTD_REP_NUM, mlen, i, opt[cur].rep[i], cur, opt[cur].off);
-
-                    if (mlen > sufficient_len || cur + mlen >= ZSTD_OPT_NUM) {
-                        ZSTD_LOG_PARSER("%d: REP sufficient_len=%d best_mlen=%d best_off=%d last_pos=%d\n", (int)(inr-base), sufficient_len, best_mlen, best_off, last_pos);
-                        best_mlen = mlen; best_off = i; last_pos = cur + 1;
-                        goto _storeSequence;
-                    }
-
-                    best_off = (i<=1 && opt[cur].mlen != 1) ? 1-i : i;
-                    if (opt[cur].mlen == 1) {
-                        litlen = opt[cur].litlen;
-                        if (cur > litlen) {
-                            price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, inr-litlen, best_off, mlen - MINMATCH);
-                        } else
-                            price = ZSTD_getPrice(seqStorePtr, litlen, anchor, best_off, mlen - MINMATCH);
-                    } else {
-                        litlen = 0;
-                        price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, best_off, mlen - MINMATCH);
-                    }
-
-                    best_mlen = mlen;
-                    ZSTD_LOG_PARSER("%d: Found REP mlen=%d off=%d price=%d litlen=%d\n", (int)(inr-base), mlen, best_off, price, litlen);
-
-                    do {
-                        if (cur + mlen > last_pos || price <= opt[cur + mlen].price)
-                            SET_PRICE(cur + mlen, mlen, i, litlen, price);
-                        mlen--;
-                    } while (mlen >= minMatch);
-            }   } }
-
-            match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, inr, iend, maxSearches, mls, matches, minMatch);
-            ZSTD_LOG_PARSER("%d: ZSTD_GetAllMatches match_num=%d\n", (int)(inr-base), match_num);
-
-            if (match_num > 0 && matches[match_num-1].len > sufficient_len) {
-                best_mlen = matches[match_num-1].len;
-                best_off = matches[match_num-1].off;
-                last_pos = cur + 1;
-                goto _storeSequence;
-            }
-
-            best_mlen = (best_mlen > minMatch) ? best_mlen : minMatch;
-
-            /* set prices using matches at position = cur */
-            for (u = 0; u < match_num; u++) {
-                mlen = (u>0) ? matches[u-1].len+1 : best_mlen;
-                best_mlen = (cur + matches[u].len < ZSTD_OPT_NUM) ? matches[u].len : ZSTD_OPT_NUM - cur;
-
-            //    ZSTD_LOG_PARSER("%d: Found1 cur=%d mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(inr-base), cur, matches[u].len, matches[u].off, best_mlen, last_pos);
-                while (mlen <= best_mlen) {
-                    if (opt[cur].mlen == 1) {
-                        litlen = opt[cur].litlen;
-                        if (cur > litlen)
-                            price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip+cur-litlen, matches[u].off, mlen - MINMATCH);
-                        else
-                            price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off, mlen - MINMATCH);
-                    } else {
-                        litlen = 0;
-                        price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, matches[u].off, mlen - MINMATCH);
-                    }
-
-                //    ZSTD_LOG_PARSER("%d: Found2 mlen=%d best_mlen=%d off=%d price=%d litlen=%d\n", (int)(inr-base), mlen, best_mlen, matches[u].off, price, litlen);
-                    if (cur + mlen > last_pos || (price < opt[cur + mlen].price))
-                        SET_PRICE(cur + mlen, mlen, matches[u].off, litlen, price);
-
-                    mlen++;
-        }   }   }   /* for (cur = 1; cur <= last_pos; cur++) */
-
-        best_mlen = opt[last_pos].mlen;
-        best_off = opt[last_pos].off;
-        cur = last_pos - best_mlen;
-
-        /* store sequence */
-_storeSequence:   /* cur, last_pos, best_mlen, best_off have to be set */
-        for (u = 1; u <= last_pos; u++)
-            ZSTD_LOG_PARSER("%d: price[%u/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base+u), u, last_pos, opt[u].price, opt[u].off, opt[u].mlen, opt[u].litlen, opt[u].rep[0], opt[u].rep[1]);
-        ZSTD_LOG_PARSER("%d: cur=%d/%d best_mlen=%d best_off=%d rep[0]=%d\n", (int)(ip-base+cur), (int)cur, (int)last_pos, (int)best_mlen, (int)best_off, opt[cur].rep[0]);
-
-        opt[0].mlen = 1;
-
-        while (1) {
-            mlen = opt[cur].mlen;
-            offset = opt[cur].off;
-            opt[cur].mlen = best_mlen;
-            opt[cur].off = best_off;
-            best_mlen = mlen;
-            best_off = offset;
-            if (mlen > cur) break;
-            cur -= mlen;
-        }
-
-        for (u = 0; u <= last_pos; ) {
-            ZSTD_LOG_PARSER("%d: price2[%d/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base+u), u, last_pos, opt[u].price, opt[u].off, opt[u].mlen, opt[u].litlen, opt[u].rep[0], opt[u].rep[1]);
-            u += opt[u].mlen;
-        }
-
-        for (cur=0; cur < last_pos; ) {
-            ZSTD_LOG_PARSER("%d: price3[%d/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base+cur), cur, last_pos, opt[cur].price, opt[cur].off, opt[cur].mlen, opt[cur].litlen, opt[cur].rep[0], opt[cur].rep[1]);
-            mlen = opt[cur].mlen;
-            if (mlen == 1) { ip++; cur++; continue; }
-            offset = opt[cur].off;
-            cur += mlen;
-            litLength = (U32)(ip - anchor);
-         //   ZSTD_LOG_ENCODE("%d/%d: ENCODE1 literals=%d mlen=%d off=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base), (int)(iend-base), (int)(litLength), (int)mlen, (int)(offset), (int)rep[0], (int)rep[1]);
-
-            if (offset >= ZSTD_REP_NUM) {
-                rep[2] = rep[1];
-                rep[1] = rep[0];
-                rep[0] = offset - ZSTD_REP_MOVE;
-            } else {
-                if (offset != 0) {
-                    best_off = rep[offset];
-                    if (offset != 1) rep[2] = rep[1];
-                    rep[1] = rep[0];
-                    rep[0] = best_off;
-                 }
-                 if (litLength == 0 && offset<=1) offset = 1-offset;
-            }
-
-            ZSTD_LOG_ENCODE("%d/%d: ENCODE literals=%d mlen=%d off=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base), (int)(iend-base), (int)(litLength), (int)mlen, (int)(offset), (int)rep[0], (int)rep[1]);
-
-#if ZSTD_OPT_DEBUG >= 5
-            U32 ml2;
-            if (offset >= ZSTD_REP_NUM) {
-                best_off = offset - ZSTD_REP_MOVE;
-                if (best_off > (size_t)(ip - prefixStart))  {
-                    const BYTE* match = dictEnd - (best_off - (ip - prefixStart));
-                    ml2 = ZSTD_count_2segments(ip, match, iend, dictEnd, prefixStart);
-                    ZSTD_LOG_PARSER("%d: ZSTD_count_2segments=%d offset=%d dictBase=%p dictEnd=%p prefixStart=%p ip=%p match=%p\n", (int)current, (int)ml2, (int)best_off, dictBase, dictEnd, prefixStart, ip, match);
-                }
-                else ml2 = (U32)ZSTD_count(ip, ip-offset, iend);
-            }
-            else ml2 = (U32)ZSTD_count(ip, ip-rep[0], iend);
-            if ((offset >= 8) && (ml2 < mlen || ml2 < minMatch)) {
-                printf("%d: ERROR_Ext iend=%d mlen=%d offset=%d ml2=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset, (int)ml2); exit(0); }
-            if (ip < anchor) {
-                printf("%d: ERROR_Ext ip < anchor iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
-            if (ip + mlen > iend) {
-                printf("%d: ERROR_Ext ip + mlen >= iend iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); }
-#endif
-
-            ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
-            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
-            anchor = ip = ip + mlen;
-    }    }   /* for (cur=0; cur < last_pos; ) */
-
-    {   /* Last Literals */
-        size_t lastLLSize = iend - anchor;
-        ZSTD_LOG_ENCODE("%d: lastLLSize literals=%u\n", (int)(ip-base), (U32)(lastLLSize));
-        memcpy(seqStorePtr->lit, anchor, lastLLSize);
-        seqStorePtr->lit += lastLLSize;
-    }
-}
+#include <contrib/libs/zstd06/renames.h> 
+/* 
+    ZSTD Optimal mode 
+    Copyright (C) 2016, Przemyslaw Skibinski, Yann Collet. 
+ 
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) 
+ 
+    Redistribution and use in source and binary forms, with or without 
+    modification, are permitted provided that the following conditions are 
+    met: 
+ 
+    * Redistributions of source code must retain the above copyright 
+    notice, this list of conditions and the following disclaimer. 
+    * Redistributions in binary form must reproduce the above 
+    copyright notice, this list of conditions and the following disclaimer 
+    in the documentation and/or other materials provided with the 
+    distribution. 
+ 
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ 
+    You can contact the author at : 
+       - Zstd source repository : https://www.zstd.net 
+*/ 
+ 
+/* Note : this file is intended to be included within zstd_compress.c */ 
+ 
+ 
+#define ZSTD_FREQ_DIV   5 
+ 
+/*-************************************* 
+*  Price functions for optimal parser 
+***************************************/ 
+FORCE_INLINE void ZSTD_setLog2Prices(seqStore_t* ssPtr) 
+{ 
+    ssPtr->log2matchLengthSum = ZSTD_highbit(ssPtr->matchLengthSum+1); 
+    ssPtr->log2litLengthSum = ZSTD_highbit(ssPtr->litLengthSum+1); 
+    ssPtr->log2litSum = ZSTD_highbit(ssPtr->litSum+1); 
+    ssPtr->log2offCodeSum = ZSTD_highbit(ssPtr->offCodeSum+1); 
+    ssPtr->factor = 1 + ((ssPtr->litSum>>5) / ssPtr->litLengthSum) + ((ssPtr->litSum<<1) / (ssPtr->litSum + ssPtr->matchSum)); 
+} 
+ 
+ 
+MEM_STATIC void ZSTD_rescaleFreqs(seqStore_t* ssPtr) 
+{ 
+    unsigned u; 
+ 
+    ssPtr->cachedLiterals = NULL; 
+    ssPtr->cachedPrice = ssPtr->cachedLitLength = 0; 
+ 
+    if (ssPtr->litLengthSum == 0) { 
+        ssPtr->litSum = (2<<Litbits); 
+        ssPtr->litLengthSum = MaxLL+1; 
+        ssPtr->matchLengthSum = MaxML+1; 
+        ssPtr->offCodeSum = (MaxOff+1); 
+        ssPtr->matchSum = (2<<Litbits); 
+ 
+        for (u=0; u<=MaxLit; u++) 
+            ssPtr->litFreq[u] = 2; 
+        for (u=0; u<=MaxLL; u++) 
+            ssPtr->litLengthFreq[u] = 1; 
+        for (u=0; u<=MaxML; u++) 
+            ssPtr->matchLengthFreq[u] = 1; 
+        for (u=0; u<=MaxOff; u++) 
+            ssPtr->offCodeFreq[u] = 1; 
+    } else { 
+        ssPtr->matchLengthSum = 0; 
+        ssPtr->litLengthSum = 0; 
+        ssPtr->offCodeSum = 0; 
+        ssPtr->matchSum = 0; 
+        ssPtr->litSum = 0; 
+ 
+        for (u=0; u<=MaxLit; u++) { 
+            ssPtr->litFreq[u] = 1 + (ssPtr->litFreq[u]>>ZSTD_FREQ_DIV); 
+            ssPtr->litSum += ssPtr->litFreq[u]; 
+        } 
+        for (u=0; u<=MaxLL; u++) { 
+            ssPtr->litLengthFreq[u] = 1 + (ssPtr->litLengthFreq[u]>>ZSTD_FREQ_DIV); 
+            ssPtr->litLengthSum += ssPtr->litLengthFreq[u]; 
+        } 
+        for (u=0; u<=MaxML; u++) { 
+            ssPtr->matchLengthFreq[u] = 1 + (ssPtr->matchLengthFreq[u]>>ZSTD_FREQ_DIV); 
+            ssPtr->matchLengthSum += ssPtr->matchLengthFreq[u]; 
+            ssPtr->matchSum += ssPtr->matchLengthFreq[u] * (u + 3); 
+        } 
+        for (u=0; u<=MaxOff; u++) { 
+            ssPtr->offCodeFreq[u] = 1 + (ssPtr->offCodeFreq[u]>>ZSTD_FREQ_DIV); 
+            ssPtr->offCodeSum += ssPtr->offCodeFreq[u]; 
+        } 
+    } 
+ 
+    ZSTD_setLog2Prices(ssPtr); 
+} 
+ 
+ 
+FORCE_INLINE U32 ZSTD_getLiteralPrice(seqStore_t* ssPtr, U32 litLength, const BYTE* literals) 
+{ 
+    U32 price, u; 
+ 
+    if (litLength == 0) 
+        return ssPtr->log2litLengthSum - ZSTD_highbit(ssPtr->litLengthFreq[0]+1); 
+ 
+    /* literals */ 
+    if (ssPtr->cachedLiterals == literals) { 
+        U32 additional = litLength - ssPtr->cachedLitLength; 
+        const BYTE* literals2 = ssPtr->cachedLiterals + ssPtr->cachedLitLength; 
+        price = ssPtr->cachedPrice + additional * ssPtr->log2litSum; 
+        for (u=0; u < additional; u++) 
+            price -= ZSTD_highbit(ssPtr->litFreq[literals2[u]]+1); 
+        ssPtr->cachedPrice = price; 
+        ssPtr->cachedLitLength = litLength; 
+    } else { 
+        price = litLength * ssPtr->log2litSum; 
+        for (u=0; u < litLength; u++) 
+            price -= ZSTD_highbit(ssPtr->litFreq[literals[u]]+1); 
+ 
+        if (litLength >= 12) { 
+            ssPtr->cachedLiterals = literals; 
+            ssPtr->cachedPrice = price; 
+            ssPtr->cachedLitLength = litLength; 
+        } 
+    } 
+ 
+    /* literal Length */ 
+    {   static const BYTE LL_Code[64] = {  0,  1,  2,  3,  4,  5,  6,  7, 
+                                           8,  9, 10, 11, 12, 13, 14, 15, 
+                                          16, 16, 17, 17, 18, 18, 19, 19, 
+                                          20, 20, 20, 20, 21, 21, 21, 21, 
+                                          22, 22, 22, 22, 22, 22, 22, 22, 
+                                          23, 23, 23, 23, 23, 23, 23, 23, 
+                                          24, 24, 24, 24, 24, 24, 24, 24, 
+                                          24, 24, 24, 24, 24, 24, 24, 24 }; 
+        const BYTE LL_deltaCode = 19; 
+        const BYTE llCode = (litLength>63) ? (BYTE)ZSTD_highbit(litLength) + LL_deltaCode : LL_Code[litLength]; 
+        price += LL_bits[llCode] + ssPtr->log2litLengthSum - ZSTD_highbit(ssPtr->litLengthFreq[llCode]+1); 
+    } 
+ 
+    return price; 
+} 
+ 
+ 
+FORCE_INLINE U32 ZSTD_getPrice(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength) 
+{ 
+    /* offset */ 
+    BYTE offCode = (BYTE)ZSTD_highbit(offset+1); 
+    U32 price = offCode + seqStorePtr->log2offCodeSum - ZSTD_highbit(seqStorePtr->offCodeFreq[offCode]+1); 
+ 
+    /* match Length */ 
+    {   static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 
+                                          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 
+                                          32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37, 
+                                          38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 
+                                          40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 
+                                          41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 
+                                          42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+                                          42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 }; 
+        const BYTE ML_deltaCode = 36; 
+        const BYTE mlCode = (matchLength>127) ? (BYTE)ZSTD_highbit(matchLength) + ML_deltaCode : ML_Code[matchLength]; 
+        price += ML_bits[mlCode] + seqStorePtr->log2matchLengthSum - ZSTD_highbit(seqStorePtr->matchLengthFreq[mlCode]+1); 
+    } 
+ 
+    return price + ZSTD_getLiteralPrice(seqStorePtr, litLength, literals) + seqStorePtr->factor; 
+} 
+ 
+ 
+MEM_STATIC void ZSTD_updatePrice(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength) 
+{ 
+    U32 u; 
+ 
+    /* literals */ 
+    seqStorePtr->litSum += litLength; 
+    for (u=0; u < litLength; u++) 
+        seqStorePtr->litFreq[literals[u]]++; 
+ 
+    /* literal Length */ 
+    {   static const BYTE LL_Code[64] = {  0,  1,  2,  3,  4,  5,  6,  7, 
+                                           8,  9, 10, 11, 12, 13, 14, 15, 
+                                          16, 16, 17, 17, 18, 18, 19, 19, 
+                                          20, 20, 20, 20, 21, 21, 21, 21, 
+                                          22, 22, 22, 22, 22, 22, 22, 22, 
+                                          23, 23, 23, 23, 23, 23, 23, 23, 
+                                          24, 24, 24, 24, 24, 24, 24, 24, 
+                                          24, 24, 24, 24, 24, 24, 24, 24 }; 
+        const BYTE LL_deltaCode = 19; 
+        const BYTE llCode = (litLength>63) ? (BYTE)ZSTD_highbit(litLength) + LL_deltaCode : LL_Code[litLength]; 
+        seqStorePtr->litLengthFreq[llCode]++; 
+        seqStorePtr->litLengthSum++; 
+    } 
+ 
+    /* match offset */ 
+	{   BYTE offCode = (BYTE)ZSTD_highbit(offset+1); 
+		seqStorePtr->offCodeSum++; 
+		seqStorePtr->offCodeFreq[offCode]++; 
+	} 
+ 
+    /* match Length */ 
+    {   static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 
+                                          16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 
+                                          32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37, 
+                                          38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 
+                                          40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 
+                                          41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 
+                                          42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
+                                          42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 }; 
+        const BYTE ML_deltaCode = 36; 
+        const BYTE mlCode = (matchLength>127) ? (BYTE)ZSTD_highbit(matchLength) + ML_deltaCode : ML_Code[matchLength]; 
+        seqStorePtr->matchLengthFreq[mlCode]++; 
+        seqStorePtr->matchLengthSum++; 
+    } 
+ 
+    ZSTD_setLog2Prices(seqStorePtr); 
+} 
+ 
+ 
+#define SET_PRICE(pos, mlen_, offset_, litlen_, price_)   \ 
+    {                                                 \ 
+        while (last_pos < pos)  { opt[last_pos+1].price = 1<<30; last_pos++; } \ 
+        opt[pos].mlen = mlen_;                         \ 
+        opt[pos].off = offset_;                        \ 
+        opt[pos].litlen = litlen_;                     \ 
+        opt[pos].price = price_;                       \ 
+        ZSTD_LOG_PARSER("%d: SET price[%d/%d]=%d litlen=%d len=%d off=%d\n", (int)(inr-base), (int)pos, (int)last_pos, opt[pos].price, opt[pos].litlen, opt[pos].mlen, opt[pos].off); \ 
+    } 
+ 
+ 
+ 
+ 
+/* Update hashTable3 up to ip (excluded) 
+   Assumption : always within prefix (ie. not within extDict) */ 
+FORCE_INLINE 
+U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip) 
+{ 
+    U32* const hashTable3  = zc->hashTable3; 
+    U32 const hashLog3  = zc->hashLog3; 
+    const BYTE* const base = zc->base; 
+    U32 idx = zc->nextToUpdate3; 
+    const U32 target = zc->nextToUpdate3 = (U32)(ip - base); 
+    const size_t hash3 = ZSTD_hash3Ptr(ip, hashLog3); 
+ 
+    while(idx < target) { 
+        hashTable3[ZSTD_hash3Ptr(base+idx, hashLog3)] = idx; 
+        idx++; 
+    } 
+ 
+    return hashTable3[hash3]; 
+} 
+ 
+ 
+/*-************************************* 
+*  Binary Tree search 
+***************************************/ 
+static U32 ZSTD_insertBtAndGetAllMatches ( 
+                        ZSTD_CCtx* zc, 
+                        const BYTE* const ip, const BYTE* const iLimit, 
+                        U32 nbCompares, const U32 mls, 
+                        U32 extDict, ZSTD_match_t* matches, const U32 minMatchLen) 
+{ 
+    const BYTE* const base = zc->base; 
+    const U32 current = (U32)(ip-base); 
+    const U32 hashLog = zc->params.cParams.hashLog; 
+    const size_t h  = ZSTD_hashPtr(ip, hashLog, mls); 
+    U32* const hashTable = zc->hashTable; 
+    U32 matchIndex  = hashTable[h]; 
+    U32* const bt   = zc->chainTable; 
+    const U32 btLog = zc->params.cParams.chainLog - 1; 
+    const U32 btMask= (1U << btLog) - 1; 
+    size_t commonLengthSmaller=0, commonLengthLarger=0; 
+    const BYTE* const dictBase = zc->dictBase; 
+    const U32 dictLimit = zc->dictLimit; 
+    const BYTE* const dictEnd = dictBase + dictLimit; 
+    const BYTE* const prefixStart = base + dictLimit; 
+    const U32 btLow = btMask >= current ? 0 : current - btMask; 
+    const U32 windowLow = zc->lowLimit; 
+    U32* smallerPtr = bt + 2*(current&btMask); 
+    U32* largerPtr  = bt + 2*(current&btMask) + 1; 
+    U32 matchEndIdx = current+8; 
+    U32 dummy32;   /* to be nullified at the end */ 
+    U32 mnum = 0; 
+ 
+    const U32 minMatch = (mls == 3) ? 3 : 4; 
+    size_t bestLength = minMatchLen-1; 
+ 
+    if (minMatch == 3) { /* HC3 match finder */ 
+        U32 const matchIndex3 = ZSTD_insertAndFindFirstIndexHash3 (zc, ip); 
+        if (matchIndex3>windowLow && (current - matchIndex3 < (1<<18))) { 
+            const BYTE* match; 
+            size_t currentMl=0; 
+            if ((!extDict) || matchIndex3 >= dictLimit) { 
+                match = base + matchIndex3; 
+                if (match[bestLength] == ip[bestLength]) currentMl = ZSTD_count(ip, match, iLimit); 
+            } else { 
+                match = dictBase + matchIndex3; 
+                if (MEM_readMINMATCH(match, MINMATCH) == MEM_readMINMATCH(ip, MINMATCH))    /* assumption : matchIndex3 <= dictLimit-4 (by table construction) */ 
+                    currentMl = ZSTD_count_2segments(ip+MINMATCH, match+MINMATCH, iLimit, dictEnd, prefixStart) + MINMATCH; 
+            } 
+ 
+            /* save best solution */ 
+            if (currentMl > bestLength) { 
+                bestLength = currentMl; 
+                matches[mnum].off = ZSTD_REP_MOVE + current - matchIndex3; 
+                matches[mnum].len = (U32)currentMl; 
+                mnum++; 
+                if (currentMl > ZSTD_OPT_NUM) goto update; 
+                if (ip+currentMl == iLimit) goto update; /* best possible, and avoid read overflow*/ 
+            } 
+        } 
+    } 
+ 
+    hashTable[h] = current;   /* Update Hash Table */ 
+ 
+    while (nbCompares-- && (matchIndex > windowLow)) { 
+        U32* nextPtr = bt + 2*(matchIndex & btMask); 
+        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */ 
+        const BYTE* match; 
+ 
+        if ((!extDict) || (matchIndex+matchLength >= dictLimit)) { 
+            match = base + matchIndex; 
+            if (match[matchLength] == ip[matchLength]) { 
+#if ZSTD_OPT_DEBUG >= 5 
+            size_t ml; 
+            if (matchIndex < dictLimit) 
+                ml = ZSTD_count_2segments(ip, dictBase + matchIndex, iLimit, dictEnd, prefixStart); 
+            else 
+                ml = ZSTD_count(ip, match, ip+matchLength); 
+            if (ml < matchLength) 
+                printf("%d: ERROR_NOEXT: offset=%d matchLength=%d matchIndex=%d dictLimit=%d ml=%d\n", current, (int)(current - matchIndex), (int)matchLength, (int)matchIndex, (int)dictLimit, (int)ml), exit(0); 
+#endif 
+                matchLength += ZSTD_count(ip+matchLength+1, match+matchLength+1, iLimit) +1; 
+            } 
+        } else { 
+            match = dictBase + matchIndex; 
+#if ZSTD_OPT_DEBUG >= 5 
+            if (memcmp(match, ip, matchLength) != 0) 
+                 printf("%d: ERROR_EXT: matchLength=%d ZSTD_count=%d\n", current, (int)matchLength, (int)ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dictEnd, prefixStart)), exit(0); 
+#endif 
+            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dictEnd, prefixStart); 
+            ZSTD_LOG_PARSER("%d: ZSTD_INSERTBTANDGETALLMATCHES=%d offset=%d dictBase=%p dictEnd=%p prefixStart=%p ip=%p match=%p\n", (int)current, (int)matchLength, (int)(current - matchIndex), dictBase, dictEnd, prefixStart, ip, match); 
+            if (matchIndex+matchLength >= dictLimit) 
+                match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */ 
+        } 
+ 
+        if (matchLength > bestLength) { 
+            if (matchLength > matchEndIdx - matchIndex) matchEndIdx = matchIndex + (U32)matchLength; 
+            bestLength = matchLength; 
+            matches[mnum].off = ZSTD_REP_MOVE + current - matchIndex; 
+            matches[mnum].len = (U32)matchLength; 
+            mnum++; 
+            if (matchLength > ZSTD_OPT_NUM) break; 
+            if (ip+matchLength == iLimit)   /* equal : no way to know if inf or sup */ 
+                break;   /* drop, to guarantee consistency (miss a little bit of compression) */ 
+        } 
+ 
+        if (match[matchLength] < ip[matchLength]) { 
+            /* match is smaller than current */ 
+            *smallerPtr = matchIndex;             /* update smaller idx */ 
+            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */ 
+            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */ 
+            smallerPtr = nextPtr+1;               /* new "smaller" => larger of match */ 
+            matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */ 
+        } else { 
+            /* match is larger than current */ 
+            *largerPtr = matchIndex; 
+            commonLengthLarger = matchLength; 
+            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */ 
+            largerPtr = nextPtr; 
+            matchIndex = nextPtr[0]; 
+    }   } 
+ 
+    *smallerPtr = *largerPtr = 0; 
+ 
+update: 
+    zc->nextToUpdate = (matchEndIdx > current + 8) ? matchEndIdx - 8 : current+1; 
+    return mnum; 
+} 
+ 
+ 
+/** Tree updater, providing best match */ 
+static U32 ZSTD_BtGetAllMatches ( 
+                        ZSTD_CCtx* zc, 
+                        const BYTE* const ip, const BYTE* const iLimit, 
+                        const U32 maxNbAttempts, const U32 mls, ZSTD_match_t* matches, const U32 minMatchLen) 
+{ 
+    if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */ 
+    ZSTD_updateTree(zc, ip, iLimit, maxNbAttempts, mls); 
+    return ZSTD_insertBtAndGetAllMatches(zc, ip, iLimit, maxNbAttempts, mls, 0, matches, minMatchLen); 
+} 
+ 
+ 
+static U32 ZSTD_BtGetAllMatches_selectMLS ( 
+                        ZSTD_CCtx* zc,   /* Index table will be updated */ 
+                        const BYTE* ip, const BYTE* const iHighLimit, 
+                        const U32 maxNbAttempts, const U32 matchLengthSearch, ZSTD_match_t* matches, const U32 minMatchLen) 
+{ 
+    switch(matchLengthSearch) 
+    { 
+    case 3 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 3, matches, minMatchLen); 
+    default : 
+    case 4 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 4, matches, minMatchLen); 
+    case 5 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 5, matches, minMatchLen); 
+    case 6 : return ZSTD_BtGetAllMatches(zc, ip, iHighLimit, maxNbAttempts, 6, matches, minMatchLen); 
+    } 
+} 
+ 
+/** Tree updater, providing best match */ 
+static U32 ZSTD_BtGetAllMatches_extDict ( 
+                        ZSTD_CCtx* zc, 
+                        const BYTE* const ip, const BYTE* const iLimit, 
+                        const U32 maxNbAttempts, const U32 mls, ZSTD_match_t* matches, const U32 minMatchLen) 
+{ 
+    if (ip < zc->base + zc->nextToUpdate) return 0;   /* skipped area */ 
+    ZSTD_updateTree_extDict(zc, ip, iLimit, maxNbAttempts, mls); 
+    return ZSTD_insertBtAndGetAllMatches(zc, ip, iLimit, maxNbAttempts, mls, 1, matches, minMatchLen); 
+} 
+ 
+ 
+static U32 ZSTD_BtGetAllMatches_selectMLS_extDict ( 
+                        ZSTD_CCtx* zc,   /* Index table will be updated */ 
+                        const BYTE* ip, const BYTE* const iHighLimit, 
+                        const U32 maxNbAttempts, const U32 matchLengthSearch, ZSTD_match_t* matches, const U32 minMatchLen) 
+{ 
+    switch(matchLengthSearch) 
+    { 
+    case 3 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 3, matches, minMatchLen); 
+    default : 
+    case 4 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 4, matches, minMatchLen); 
+    case 5 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 5, matches, minMatchLen); 
+    case 6 : return ZSTD_BtGetAllMatches_extDict(zc, ip, iHighLimit, maxNbAttempts, 6, matches, minMatchLen); 
+    } 
+} 
+ 
+ 
+/*-******************************* 
+*  Optimal parser 
+*********************************/ 
+FORCE_INLINE 
+void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx, 
+                                    const void* src, size_t srcSize) 
+{ 
+    seqStore_t* seqStorePtr = &(ctx->seqStore); 
+    const BYTE* const istart = (const BYTE*)src; 
+    const BYTE* ip = istart; 
+    const BYTE* anchor = istart; 
+    const BYTE* const iend = istart + srcSize; 
+    const BYTE* const ilimit = iend - 8; 
+    const BYTE* const base = ctx->base; 
+    const BYTE* const prefixStart = base + ctx->dictLimit; 
+ 
+    const U32 maxSearches = 1U << ctx->params.cParams.searchLog; 
+    const U32 sufficient_len = ctx->params.cParams.targetLength; 
+    const U32 mls = ctx->params.cParams.searchLength; 
+    const U32 minMatch = (ctx->params.cParams.searchLength == 3) ? 3 : 4; 
+ 
+    ZSTD_optimal_t* opt = seqStorePtr->priceTable; 
+    ZSTD_match_t* matches = seqStorePtr->matchTable; 
+    const BYTE* inr; 
+ 
+    /* init */ 
+    U32 offset, rep[ZSTD_REP_INIT]; 
+    { U32 i; for (i=0; i<ZSTD_REP_INIT; i++) rep[i]=REPCODE_STARTVALUE; } 
+ 
+    ctx->nextToUpdate3 = ctx->nextToUpdate; 
+    ZSTD_resetSeqStore(seqStorePtr); 
+    ZSTD_rescaleFreqs(seqStorePtr); 
+    if ((ip-prefixStart) < REPCODE_STARTVALUE) ip = prefixStart + REPCODE_STARTVALUE; 
+ 
+    ZSTD_LOG_BLOCK("%d: COMPBLOCK_OPT_GENERIC srcSz=%d maxSrch=%d mls=%d sufLen=%d\n", (int)(ip-base), (int)srcSize, maxSearches, mls, sufficient_len); 
+ 
+    /* Match Loop */ 
+    while (ip < ilimit) { 
+        U32 cur, match_num, last_pos, litlen, price; 
+        U32 u, mlen, best_mlen, best_off, litLength; 
+        memset(opt, 0, sizeof(ZSTD_optimal_t)); 
+        last_pos = 0; 
+        litlen = (U32)(ip - anchor); 
+ 
+        /* check repCode */ 
+        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) 
+        if (MEM_readMINMATCH(ip, minMatch) == MEM_readMINMATCH(ip - rep[i], minMatch)) { 
+            /* repcode : we take it */ 
+            mlen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-rep[i], iend) + minMatch; 
+            ZSTD_LOG_PARSER("%d: start try REP rep[%d]=%d mlen=%d\n", (int)(ip-base), i, (int)rep[i], (int)mlen); 
+            if (mlen > sufficient_len || mlen >= ZSTD_OPT_NUM) { 
+                best_mlen = mlen; best_off = i; cur = 0; last_pos = 1; 
+                goto _storeSequence; 
+            } 
+            best_off = (i<=1 && ip == anchor) ? 1-i : i; 
+            do { 
+                price = ZSTD_getPrice(seqStorePtr, litlen, anchor, best_off, mlen - MINMATCH); 
+                if (mlen > last_pos || price < opt[mlen].price) 
+                    SET_PRICE(mlen, mlen, i, litlen, price);   /* note : macro modifies last_pos */ 
+                mlen--; 
+            } while (mlen >= minMatch); 
+        } } 
+ 
+        match_num = ZSTD_BtGetAllMatches_selectMLS(ctx, ip, iend, maxSearches, mls, matches, minMatch); 
+ 
+        ZSTD_LOG_PARSER("%d: match_num=%d last_pos=%d\n", (int)(ip-base), match_num, last_pos); 
+        if (!last_pos && !match_num) { ip++; continue; } 
+ 
+        if (match_num && (matches[match_num-1].len > sufficient_len || matches[match_num-1].len >= ZSTD_OPT_NUM)) { 
+            best_mlen = matches[match_num-1].len; 
+            best_off = matches[match_num-1].off; 
+            cur = 0; 
+            last_pos = 1; 
+            goto _storeSequence; 
+        } 
+ 
+        /* set prices using matches at position = 0 */ 
+        best_mlen = (last_pos) ? last_pos : minMatch; 
+        for (u = 0; u < match_num; u++) { 
+           mlen = (u>0) ? matches[u-1].len+1 : best_mlen; 
+           best_mlen = matches[u].len; 
+           ZSTD_LOG_PARSER("%d: start Found mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(ip-base), matches[u].len, matches[u].off, (int)best_mlen, (int)last_pos); 
+           while (mlen <= best_mlen) { 
+                price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off, mlen - MINMATCH); 
+                if (mlen > last_pos || price < opt[mlen].price) 
+                    SET_PRICE(mlen, mlen, matches[u].off, litlen, price);   /* note : macro modifies last_pos */ 
+                mlen++; 
+        }  } 
+ 
+        if (last_pos < minMatch) { ip++; continue; } 
+ 
+        /* initialize opt[0] */ 
+        { U32 i ; for (i=0; i<ZSTD_REP_INIT; i++) opt[0].rep[i] = rep[i]; } 
+        opt[0].mlen = 1; 
+        opt[0].litlen = litlen; 
+ 
+         /* check further positions */ 
+        for (cur = 1; cur <= last_pos; cur++) { 
+           inr = ip + cur; 
+ 
+           if (opt[cur-1].mlen == 1) { 
+                litlen = opt[cur-1].litlen + 1; 
+                if (cur > litlen) { 
+                    price = opt[cur - litlen].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-litlen); 
+                } else 
+                    price = ZSTD_getLiteralPrice(seqStorePtr, litlen, anchor); 
+           } else { 
+                litlen = 1; 
+                price = opt[cur - 1].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-1); 
+           } 
+ 
+           if (cur > last_pos || price <= opt[cur].price) // || ((price == opt[cur].price) && (opt[cur-1].mlen == 1) && (cur != litlen))) 
+                SET_PRICE(cur, 1, 0, litlen, price); 
+ 
+           if (cur == last_pos) break; 
+ 
+           if (inr > ilimit)  /* last match must start at a minimum distance of 8 from oend */ 
+               continue; 
+ 
+           mlen = opt[cur].mlen; 
+           if (opt[cur].off >= ZSTD_REP_NUM) { 
+                opt[cur].rep[2] = opt[cur-mlen].rep[1]; 
+                opt[cur].rep[1] = opt[cur-mlen].rep[0]; 
+                opt[cur].rep[0] = opt[cur].off - ZSTD_REP_MOVE; 
+                ZSTD_LOG_ENCODE("%d: COPYREP_OFF cur=%d mlen=%d rep[0]=%d rep[1]=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep[0], opt[cur].rep[1]); 
+           } else { 
+                opt[cur].rep[2] = (opt[cur].off > 1) ? opt[cur-mlen].rep[1] : opt[cur-mlen].rep[2]; 
+                opt[cur].rep[1] = (opt[cur].off > 0) ? opt[cur-mlen].rep[0] : opt[cur-mlen].rep[1]; 
+                opt[cur].rep[0] = opt[cur-mlen].rep[opt[cur].off]; 
+                ZSTD_LOG_ENCODE("%d: COPYREP_NOR cur=%d mlen=%d rep[0]=%d rep[1]=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep[0], opt[cur].rep[1]); 
+           } 
+ 
+           ZSTD_LOG_PARSER("%d: CURRENT_NoExt price[%d/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(inr-base), cur, last_pos, opt[cur].price, opt[cur].off, opt[cur].mlen, opt[cur].litlen, opt[cur].rep[0], opt[cur].rep[1]); 
+ 
+           best_mlen = minMatch; 
+           { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) 
+           if (MEM_readMINMATCH(inr, minMatch) == MEM_readMINMATCH(inr - opt[cur].rep[i], minMatch)) {  /* check rep */ 
+               mlen = (U32)ZSTD_count(inr+minMatch, inr+minMatch - opt[cur].rep[i], iend) + minMatch; 
+               ZSTD_LOG_PARSER("%d: Found REP %d/%d mlen=%d off=%d rep=%d opt[%d].off=%d\n", (int)(inr-base), i, ZSTD_REP_NUM, mlen, i, opt[cur].rep[i], cur, opt[cur].off); 
+ 
+               if (mlen > sufficient_len || cur + mlen >= ZSTD_OPT_NUM) { 
+                    ZSTD_LOG_PARSER("%d: REP sufficient_len=%d best_mlen=%d best_off=%d last_pos=%d\n", (int)(inr-base), sufficient_len, best_mlen, best_off, last_pos); 
+                    best_mlen = mlen; best_off = i; last_pos = cur + 1; 
+                    goto _storeSequence; 
+               } 
+ 
+               best_off = (i<=1 && opt[cur].mlen != 1) ? 1-i : i; 
+               if (opt[cur].mlen == 1) { 
+                    litlen = opt[cur].litlen; 
+                    if (cur > litlen) { 
+                        price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, inr-litlen, best_off, mlen - MINMATCH); 
+                    } else 
+                        price = ZSTD_getPrice(seqStorePtr, litlen, anchor, best_off, mlen - MINMATCH); 
+                } else { 
+                    litlen = 0; 
+                    price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, best_off, mlen - MINMATCH); 
+                } 
+ 
+                if (mlen > best_mlen) best_mlen = mlen; 
+                ZSTD_LOG_PARSER("%d: Found REP mlen=%d off=%d price=%d litlen=%d\n", (int)(inr-base), mlen, best_off, price, litlen); 
+ 
+                do { 
+                    if (cur + mlen > last_pos || price <= opt[cur + mlen].price) 
+                        SET_PRICE(cur + mlen, mlen, i, litlen, price); 
+                    mlen--; 
+                } while (mlen >= minMatch); 
+            } } 
+ 
+            match_num = ZSTD_BtGetAllMatches_selectMLS(ctx, inr, iend, maxSearches, mls, matches, best_mlen); 
+            ZSTD_LOG_PARSER("%d: ZSTD_GetAllMatches match_num=%d\n", (int)(inr-base), match_num); 
+ 
+            if (match_num > 0 && (matches[match_num-1].len > sufficient_len || cur + matches[match_num-1].len >= ZSTD_OPT_NUM)) { 
+                best_mlen = matches[match_num-1].len; 
+                best_off = matches[match_num-1].off; 
+                last_pos = cur + 1; 
+                goto _storeSequence; 
+            } 
+ 
+            /* set prices using matches at position = cur */ 
+            for (u = 0; u < match_num; u++) { 
+                mlen = (u>0) ? matches[u-1].len+1 : best_mlen; 
+                best_mlen = matches[u].len; 
+ 
+              //  ZSTD_LOG_PARSER("%d: Found1 cur=%d mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(inr-base), cur, matches[u].len, matches[u].off, best_mlen, last_pos); 
+                while (mlen <= best_mlen) { 
+                    if (opt[cur].mlen == 1) { 
+                        litlen = opt[cur].litlen; 
+                        if (cur > litlen) 
+                            price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip+cur-litlen, matches[u].off, mlen - MINMATCH); 
+                        else 
+                            price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off, mlen - MINMATCH); 
+                    } else { 
+                        litlen = 0; 
+                        price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, matches[u].off, mlen - MINMATCH); 
+                    } 
+ 
+                  //  ZSTD_LOG_PARSER("%d: Found2 mlen=%d best_mlen=%d off=%d price=%d litlen=%d\n", (int)(inr-base), mlen, best_mlen, matches[u].off, price, litlen); 
+                    if (cur + mlen > last_pos || (price < opt[cur + mlen].price)) 
+                        SET_PRICE(cur + mlen, mlen, matches[u].off, litlen, price); 
+ 
+                    mlen++; 
+        }   }   }   //  for (cur = 1; cur <= last_pos; cur++) 
+ 
+        best_mlen = opt[last_pos].mlen; 
+        best_off = opt[last_pos].off; 
+        cur = last_pos - best_mlen; 
+ 
+        /* store sequence */ 
+_storeSequence:   /* cur, last_pos, best_mlen, best_off have to be set */ 
+        for (u = 1; u <= last_pos; u++) 
+            ZSTD_LOG_PARSER("%d: price[%d/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base+u), u, last_pos, opt[u].price, opt[u].off, opt[u].mlen, opt[u].litlen, opt[u].rep[0], opt[u].rep[1]); 
+        ZSTD_LOG_PARSER("%d: cur=%d/%d best_mlen=%d best_off=%d rep[0]=%d\n", (int)(ip-base+cur), (int)cur, (int)last_pos, (int)best_mlen, (int)best_off, opt[cur].rep[0]); 
+ 
+        opt[0].mlen = 1; 
+ 
+        while (1) { 
+            mlen = opt[cur].mlen; 
+            offset = opt[cur].off; 
+            opt[cur].mlen = best_mlen; 
+            opt[cur].off = best_off; 
+            best_mlen = mlen; 
+            best_off = offset; 
+            if (mlen > cur) break; 
+            cur -= mlen; 
+        } 
+ 
+        for (u = 0; u <= last_pos;) { 
+            ZSTD_LOG_PARSER("%d: price2[%d/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base+u), u, last_pos, opt[u].price, opt[u].off, opt[u].mlen, opt[u].litlen, opt[u].rep[0], opt[u].rep[1]); 
+            u += opt[u].mlen; 
+        } 
+ 
+        for (cur=0; cur < last_pos; ) { 
+            ZSTD_LOG_PARSER("%d: price3[%d/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base+cur), cur, last_pos, opt[cur].price, opt[cur].off, opt[cur].mlen, opt[cur].litlen, opt[cur].rep[0], opt[cur].rep[1]); 
+            mlen = opt[cur].mlen; 
+            if (mlen == 1) { ip++; cur++; continue; } 
+            offset = opt[cur].off; 
+            cur += mlen; 
+            litLength = (U32)(ip - anchor); 
+           // ZSTD_LOG_ENCODE("%d/%d: ENCODE literals=%d mlen=%d off=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base), (int)(iend-base), (int)(litLength), (int)mlen, (int)(offset), (int)rep[0], (int)rep[1]); 
+ 
+            if (offset >= ZSTD_REP_NUM) { 
+                rep[2] = rep[1]; 
+                rep[1] = rep[0]; 
+                rep[0] = offset - ZSTD_REP_MOVE; 
+            } else { 
+                if (offset != 0) { 
+                    best_off = rep[offset]; 
+                    if (offset != 1) rep[2] = rep[1]; 
+                    rep[1] = rep[0]; 
+                    rep[0] = best_off; 
+                } 
+                if (litLength == 0 && offset<=1) offset = 1-offset; 
+            } 
+ 
+            ZSTD_LOG_ENCODE("%d/%d: ENCODE literals=%d mlen=%d off=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base), (int)(iend-base), (int)(litLength), (int)mlen, (int)(offset), (int)rep[0], (int)rep[1]); 
+ 
+#if ZSTD_OPT_DEBUG >= 5 
+            U32 ml2; 
+            if (offset >= ZSTD_REP_NUM) 
+                ml2 = (U32)ZSTD_count(ip, ip-(offset-ZSTD_REP_MOVE), iend); 
+            else 
+                ml2 = (U32)ZSTD_count(ip, ip-rep[0], iend); 
+            if ((offset >= 8) && (ml2 < mlen || ml2 < minMatch)) { 
+                printf("%d: ERROR_NoExt iend=%d mlen=%d offset=%d ml2=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset, (int)ml2); exit(0); } 
+            if (ip < anchor) { 
+                printf("%d: ERROR_NoExt ip < anchor iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); } 
+            if (ip + mlen > iend) { 
+                printf("%d: ERROR_NoExt ip + mlen >= iend iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); } 
+#endif 
+ 
+            ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH); 
+            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH); 
+            anchor = ip = ip + mlen; 
+    }    }   /* for (cur=0; cur < last_pos; ) */ 
+ 
+    {   /* Last Literals */ 
+        size_t lastLLSize = iend - anchor; 
+        ZSTD_LOG_ENCODE("%d: lastLLSize literals=%u\n", (int)(ip-base), (U32)lastLLSize); 
+        memcpy(seqStorePtr->lit, anchor, lastLLSize); 
+        seqStorePtr->lit += lastLLSize; 
+    } 
+} 
+ 
+ 
+FORCE_INLINE 
+void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx, 
+                                     const void* src, size_t srcSize) 
+{ 
+    seqStore_t* seqStorePtr = &(ctx->seqStore); 
+    const BYTE* const istart = (const BYTE*)src; 
+    const BYTE* ip = istart; 
+    const BYTE* anchor = istart; 
+    const BYTE* const iend = istart + srcSize; 
+    const BYTE* const ilimit = iend - 8; 
+    const BYTE* const base = ctx->base; 
+    const U32 dictLimit = ctx->dictLimit; 
+    const BYTE* const prefixStart = base + dictLimit; 
+    const BYTE* const dictBase = ctx->dictBase; 
+    const BYTE* const dictEnd  = dictBase + dictLimit; 
+ 
+    const U32 maxSearches = 1U << ctx->params.cParams.searchLog; 
+    const U32 sufficient_len = ctx->params.cParams.targetLength; 
+    const U32 mls = ctx->params.cParams.searchLength; 
+    const U32 minMatch = (ctx->params.cParams.searchLength == 3) ? 3 : 4; 
+ 
+    ZSTD_optimal_t* opt = seqStorePtr->priceTable; 
+    ZSTD_match_t* matches = seqStorePtr->matchTable; 
+    const BYTE* inr; 
+ 
+    /* init */ 
+    U32 offset, rep[ZSTD_REP_INIT]; 
+    { U32 i; for (i=0; i<ZSTD_REP_INIT; i++) rep[i]=REPCODE_STARTVALUE; } 
+ 
+    ctx->nextToUpdate3 = ctx->nextToUpdate; 
+    ZSTD_resetSeqStore(seqStorePtr); 
+    ZSTD_rescaleFreqs(seqStorePtr); 
+    if ((ip - prefixStart) < REPCODE_STARTVALUE) ip += REPCODE_STARTVALUE; 
+ 
+    ZSTD_LOG_BLOCK("%d: COMPBLOCK_OPT_EXTDICT srcSz=%d maxSrch=%d mls=%d sufLen=%d\n", (int)(ip-base), (int)srcSize, maxSearches, mls, sufficient_len); 
+ 
+    /* Match Loop */ 
+    while (ip < ilimit) { 
+        U32 cur, match_num, last_pos, litlen, price; 
+        U32 u, mlen, best_mlen, best_off, litLength; 
+        U32 current = (U32)(ip-base); 
+        memset(opt, 0, sizeof(ZSTD_optimal_t)); 
+        last_pos = 0; 
+        inr = ip; 
+        opt[0].litlen = (U32)(ip - anchor); 
+ 
+        /* check repCode */ 
+        { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) { 
+            const U32 repIndex = (U32)(current - rep[i]); 
+            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base; 
+            const BYTE* const repMatch = repBase + repIndex; 
+            if ( ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */ 
+               && (MEM_readMINMATCH(ip, minMatch) == MEM_readMINMATCH(repMatch, minMatch)) ) { 
+                /* repcode detected we should take it */ 
+                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; 
+                mlen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iend, repEnd, prefixStart) + minMatch; 
+ 
+                ZSTD_LOG_PARSER("%d: start try REP rep[%d]=%d mlen=%d\n", (int)(ip-base), i, (int)rep[i], (int)mlen); 
+                if (mlen > sufficient_len || mlen >= ZSTD_OPT_NUM) { 
+                    best_mlen = mlen; best_off = i; cur = 0; last_pos = 1; 
+                    goto _storeSequence; 
+                } 
+ 
+                best_off = (i<=1 && ip == anchor) ? 1-i : i; 
+                litlen = opt[0].litlen; 
+                do { 
+                    price = ZSTD_getPrice(seqStorePtr, litlen, anchor, best_off, mlen - MINMATCH); 
+                    if (mlen > last_pos || price < opt[mlen].price) 
+                        SET_PRICE(mlen, mlen, i, litlen, price);   /* note : macro modifies last_pos */ 
+                    mlen--; 
+                } while (mlen >= minMatch); 
+        }   } } 
+ 
+        match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, ip, iend, maxSearches, mls, matches, minMatch);  /* first search (depth 0) */ 
+ 
+        ZSTD_LOG_PARSER("%d: match_num=%d last_pos=%d\n", (int)(ip-base), match_num, last_pos); 
+        if (!last_pos && !match_num) { ip++; continue; } 
+ 
+        { U32 i; for (i=0; i<ZSTD_REP_INIT; i++) opt[0].rep[i] = rep[i]; } 
+        opt[0].mlen = 1; 
+ 
+        if (match_num && (matches[match_num-1].len > sufficient_len || matches[match_num-1].len >= ZSTD_OPT_NUM)) { 
+            best_mlen = matches[match_num-1].len; 
+            best_off = matches[match_num-1].off; 
+            cur = 0; 
+            last_pos = 1; 
+            goto _storeSequence; 
+        } 
+ 
+        best_mlen = (last_pos) ? last_pos : minMatch; 
+ 
+        // set prices using matches at position = 0 
+        for (u = 0; u < match_num; u++) { 
+            mlen = (u>0) ? matches[u-1].len+1 : best_mlen; 
+            best_mlen = matches[u].len; 
+            ZSTD_LOG_PARSER("%d: start Found mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(ip-base), matches[u].len, matches[u].off, (int)best_mlen, (int)last_pos); 
+            litlen = opt[0].litlen; 
+            while (mlen <= best_mlen) { 
+                price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off, mlen - MINMATCH); 
+                if (mlen > last_pos || price < opt[mlen].price) 
+                    SET_PRICE(mlen, mlen, matches[u].off, litlen, price); 
+                mlen++; 
+        }   } 
+ 
+        if (last_pos < minMatch) { 
+            // ip += ((ip-anchor) >> g_searchStrength) + 1;   /* jump faster over incompressible sections */ 
+            ip++; continue; 
+        } 
+ 
+        /* check further positions */ 
+        for (cur = 1; cur <= last_pos; cur++) { 
+            inr = ip + cur; 
+ 
+            if (opt[cur-1].mlen == 1) { 
+                litlen = opt[cur-1].litlen + 1; 
+                if (cur > litlen) { 
+                    price = opt[cur - litlen].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-litlen); 
+                } else 
+                    price = ZSTD_getLiteralPrice(seqStorePtr, litlen, anchor); 
+            } else { 
+                litlen = 1; 
+                price = opt[cur - 1].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-1); 
+            } 
+ 
+            if (cur > last_pos || price <= opt[cur].price) // || ((price == opt[cur].price) && (opt[cur-1].mlen == 1) && (cur != litlen))) 
+                SET_PRICE(cur, 1, 0, litlen, price); 
+ 
+            if (cur == last_pos) break; 
+ 
+            if (inr > ilimit)  /* last match must start at a minimum distance of 8 from oend */ 
+                continue; 
+ 
+            mlen = opt[cur].mlen; 
+            if (opt[cur].off >= ZSTD_REP_NUM) { 
+                opt[cur].rep[2] = opt[cur-mlen].rep[1]; 
+                opt[cur].rep[1] = opt[cur-mlen].rep[0]; 
+                opt[cur].rep[0] = opt[cur].off - ZSTD_REP_MOVE; 
+                ZSTD_LOG_ENCODE("%d: COPYREP_OFF cur=%d mlen=%d rep[0]=%d rep[1]=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep[0], opt[cur].rep[1]); 
+            } else { 
+                opt[cur].rep[2] = (opt[cur].off > 1) ? opt[cur-mlen].rep[1] : opt[cur-mlen].rep[2]; 
+                opt[cur].rep[1] = (opt[cur].off > 0) ? opt[cur-mlen].rep[0] : opt[cur-mlen].rep[1]; 
+                opt[cur].rep[0] = opt[cur-mlen].rep[opt[cur].off]; 
+                ZSTD_LOG_ENCODE("%d: COPYREP_NOR cur=%d mlen=%d rep[0]=%d rep[1]=%d\n", (int)(inr-base), cur, mlen, opt[cur].rep[0], opt[cur].rep[1]); 
+            } 
+ 
+            ZSTD_LOG_PARSER("%d: CURRENT_Ext price[%d/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(inr-base), cur, last_pos, opt[cur].price, opt[cur].off, opt[cur].mlen, opt[cur].litlen, opt[cur].rep[0], opt[cur].rep[1]); 
+            best_mlen = 0; 
+ 
+            { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) { 
+                const U32 repIndex = (U32)(current+cur - opt[cur].rep[i]); 
+                const BYTE* const repBase = repIndex < dictLimit ? dictBase : base; 
+                const BYTE* const repMatch = repBase + repIndex; 
+                if ( ((U32)((dictLimit-1) - repIndex) >= 3)   /* intentional overflow */ 
+                  && (MEM_readMINMATCH(inr, minMatch) == MEM_readMINMATCH(repMatch, minMatch)) ) { 
+                    /* repcode detected */ 
+                    const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend; 
+                    mlen = (U32)ZSTD_count_2segments(inr+minMatch, repMatch+minMatch, iend, repEnd, prefixStart) + minMatch; 
+                    ZSTD_LOG_PARSER("%d: Found REP %d/%d mlen=%d off=%d rep=%d opt[%d].off=%d\n", (int)(inr-base), i, ZSTD_REP_NUM, mlen, i, opt[cur].rep[i], cur, opt[cur].off); 
+ 
+                    if (mlen > sufficient_len || cur + mlen >= ZSTD_OPT_NUM) { 
+                        ZSTD_LOG_PARSER("%d: REP sufficient_len=%d best_mlen=%d best_off=%d last_pos=%d\n", (int)(inr-base), sufficient_len, best_mlen, best_off, last_pos); 
+                        best_mlen = mlen; best_off = i; last_pos = cur + 1; 
+                        goto _storeSequence; 
+                    } 
+ 
+                    best_off = (i<=1 && opt[cur].mlen != 1) ? 1-i : i; 
+                    if (opt[cur].mlen == 1) { 
+                        litlen = opt[cur].litlen; 
+                        if (cur > litlen) { 
+                            price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, inr-litlen, best_off, mlen - MINMATCH); 
+                        } else 
+                            price = ZSTD_getPrice(seqStorePtr, litlen, anchor, best_off, mlen - MINMATCH); 
+                    } else { 
+                        litlen = 0; 
+                        price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, best_off, mlen - MINMATCH); 
+                    } 
+ 
+                    best_mlen = mlen; 
+                    ZSTD_LOG_PARSER("%d: Found REP mlen=%d off=%d price=%d litlen=%d\n", (int)(inr-base), mlen, best_off, price, litlen); 
+ 
+                    do { 
+                        if (cur + mlen > last_pos || price <= opt[cur + mlen].price) 
+                            SET_PRICE(cur + mlen, mlen, i, litlen, price); 
+                        mlen--; 
+                    } while (mlen >= minMatch); 
+            }   } } 
+ 
+            match_num = ZSTD_BtGetAllMatches_selectMLS_extDict(ctx, inr, iend, maxSearches, mls, matches, minMatch); 
+            ZSTD_LOG_PARSER("%d: ZSTD_GetAllMatches match_num=%d\n", (int)(inr-base), match_num); 
+ 
+            if (match_num > 0 && matches[match_num-1].len > sufficient_len) { 
+                best_mlen = matches[match_num-1].len; 
+                best_off = matches[match_num-1].off; 
+                last_pos = cur + 1; 
+                goto _storeSequence; 
+            } 
+ 
+            best_mlen = (best_mlen > minMatch) ? best_mlen : minMatch; 
+ 
+            /* set prices using matches at position = cur */ 
+            for (u = 0; u < match_num; u++) { 
+                mlen = (u>0) ? matches[u-1].len+1 : best_mlen; 
+                best_mlen = (cur + matches[u].len < ZSTD_OPT_NUM) ? matches[u].len : ZSTD_OPT_NUM - cur; 
+ 
+            //    ZSTD_LOG_PARSER("%d: Found1 cur=%d mlen=%d off=%d best_mlen=%d last_pos=%d\n", (int)(inr-base), cur, matches[u].len, matches[u].off, best_mlen, last_pos); 
+                while (mlen <= best_mlen) { 
+                    if (opt[cur].mlen == 1) { 
+                        litlen = opt[cur].litlen; 
+                        if (cur > litlen) 
+                            price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip+cur-litlen, matches[u].off, mlen - MINMATCH); 
+                        else 
+                            price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off, mlen - MINMATCH); 
+                    } else { 
+                        litlen = 0; 
+                        price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, matches[u].off, mlen - MINMATCH); 
+                    } 
+ 
+                //    ZSTD_LOG_PARSER("%d: Found2 mlen=%d best_mlen=%d off=%d price=%d litlen=%d\n", (int)(inr-base), mlen, best_mlen, matches[u].off, price, litlen); 
+                    if (cur + mlen > last_pos || (price < opt[cur + mlen].price)) 
+                        SET_PRICE(cur + mlen, mlen, matches[u].off, litlen, price); 
+ 
+                    mlen++; 
+        }   }   }   /* for (cur = 1; cur <= last_pos; cur++) */ 
+ 
+        best_mlen = opt[last_pos].mlen; 
+        best_off = opt[last_pos].off; 
+        cur = last_pos - best_mlen; 
+ 
+        /* store sequence */ 
+_storeSequence:   /* cur, last_pos, best_mlen, best_off have to be set */ 
+        for (u = 1; u <= last_pos; u++) 
+            ZSTD_LOG_PARSER("%d: price[%u/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base+u), u, last_pos, opt[u].price, opt[u].off, opt[u].mlen, opt[u].litlen, opt[u].rep[0], opt[u].rep[1]); 
+        ZSTD_LOG_PARSER("%d: cur=%d/%d best_mlen=%d best_off=%d rep[0]=%d\n", (int)(ip-base+cur), (int)cur, (int)last_pos, (int)best_mlen, (int)best_off, opt[cur].rep[0]); 
+ 
+        opt[0].mlen = 1; 
+ 
+        while (1) { 
+            mlen = opt[cur].mlen; 
+            offset = opt[cur].off; 
+            opt[cur].mlen = best_mlen; 
+            opt[cur].off = best_off; 
+            best_mlen = mlen; 
+            best_off = offset; 
+            if (mlen > cur) break; 
+            cur -= mlen; 
+        } 
+ 
+        for (u = 0; u <= last_pos; ) { 
+            ZSTD_LOG_PARSER("%d: price2[%d/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base+u), u, last_pos, opt[u].price, opt[u].off, opt[u].mlen, opt[u].litlen, opt[u].rep[0], opt[u].rep[1]); 
+            u += opt[u].mlen; 
+        } 
+ 
+        for (cur=0; cur < last_pos; ) { 
+            ZSTD_LOG_PARSER("%d: price3[%d/%d]=%d off=%d mlen=%d litlen=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base+cur), cur, last_pos, opt[cur].price, opt[cur].off, opt[cur].mlen, opt[cur].litlen, opt[cur].rep[0], opt[cur].rep[1]); 
+            mlen = opt[cur].mlen; 
+            if (mlen == 1) { ip++; cur++; continue; } 
+            offset = opt[cur].off; 
+            cur += mlen; 
+            litLength = (U32)(ip - anchor); 
+         //   ZSTD_LOG_ENCODE("%d/%d: ENCODE1 literals=%d mlen=%d off=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base), (int)(iend-base), (int)(litLength), (int)mlen, (int)(offset), (int)rep[0], (int)rep[1]); 
+ 
+            if (offset >= ZSTD_REP_NUM) { 
+                rep[2] = rep[1]; 
+                rep[1] = rep[0]; 
+                rep[0] = offset - ZSTD_REP_MOVE; 
+            } else { 
+                if (offset != 0) { 
+                    best_off = rep[offset]; 
+                    if (offset != 1) rep[2] = rep[1]; 
+                    rep[1] = rep[0]; 
+                    rep[0] = best_off; 
+                 } 
+                 if (litLength == 0 && offset<=1) offset = 1-offset; 
+            } 
+ 
+            ZSTD_LOG_ENCODE("%d/%d: ENCODE literals=%d mlen=%d off=%d rep[0]=%d rep[1]=%d\n", (int)(ip-base), (int)(iend-base), (int)(litLength), (int)mlen, (int)(offset), (int)rep[0], (int)rep[1]); 
+ 
+#if ZSTD_OPT_DEBUG >= 5 
+            U32 ml2; 
+            if (offset >= ZSTD_REP_NUM) { 
+                best_off = offset - ZSTD_REP_MOVE; 
+                if (best_off > (size_t)(ip - prefixStart))  { 
+                    const BYTE* match = dictEnd - (best_off - (ip - prefixStart)); 
+                    ml2 = ZSTD_count_2segments(ip, match, iend, dictEnd, prefixStart); 
+                    ZSTD_LOG_PARSER("%d: ZSTD_count_2segments=%d offset=%d dictBase=%p dictEnd=%p prefixStart=%p ip=%p match=%p\n", (int)current, (int)ml2, (int)best_off, dictBase, dictEnd, prefixStart, ip, match); 
+                } 
+                else ml2 = (U32)ZSTD_count(ip, ip-offset, iend); 
+            } 
+            else ml2 = (U32)ZSTD_count(ip, ip-rep[0], iend); 
+            if ((offset >= 8) && (ml2 < mlen || ml2 < minMatch)) { 
+                printf("%d: ERROR_Ext iend=%d mlen=%d offset=%d ml2=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset, (int)ml2); exit(0); } 
+            if (ip < anchor) { 
+                printf("%d: ERROR_Ext ip < anchor iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); } 
+            if (ip + mlen > iend) { 
+                printf("%d: ERROR_Ext ip + mlen >= iend iend=%d mlen=%d offset=%d\n", (int)(ip - base), (int)(iend - ip), (int)mlen, (int)offset); exit(0); } 
+#endif 
+ 
+            ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH); 
+            ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH); 
+            anchor = ip = ip + mlen; 
+    }    }   /* for (cur=0; cur < last_pos; ) */ 
+ 
+    {   /* Last Literals */ 
+        size_t lastLLSize = iend - anchor; 
+        ZSTD_LOG_ENCODE("%d: lastLLSize literals=%u\n", (int)(ip-base), (U32)(lastLLSize)); 
+        memcpy(seqStorePtr->lit, anchor, lastLLSize); 
+        seqStorePtr->lit += lastLLSize; 
+    } 
+}