/*

    LZ4 HC - High Compression Mode of LZ4

    Copyright (C) 2011-2020, Yann Collet.

    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)

    Redistribution and use in source and binary forms, with or without

    modification, are permitted provided that the following conditions are

    met:

    * Redistributions of source code must retain the above copyright

    notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above

    copyright notice, this list of conditions and the following disclaimer

    in the documentation and/or other materials provided with the

    distribution.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    You can contact the author at :

       - LZ4 source repository : https://github.com/lz4/lz4

       - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c

*/

/* note : lz4hc is not an independent module, it requires lz4.h/lz4.c for proper compilation */

/* *************************************

*  Tuning Parameter

***************************************/

/*! HEAPMODE :

 *  Select how stateless HC compression functions like `LZ4_compress_HC()`

 *  allocate memory for their workspace:

 *  in stack (0:fastest), or in heap (1:default, requires malloc()).

 *  Since workspace is rather large, heap mode is recommended.

**/

#ifndef LZ4HC_HEAPMODE

#  define LZ4HC_HEAPMODE 1

#endif

/*===    Dependency    ===*/

#define LZ4_HC_STATIC_LINKING_ONLY

#include "lz4hc.h"

#include <limits.h>

/*===   Shared lz4.c code   ===*/

#ifndef LZ4_SRC_INCLUDED

# if defined(__GNUC__)

#  pragma GCC diagnostic ignored "-Wunused-function"

# endif

# if defined (__clang__)

#  pragma clang diagnostic ignored "-Wunused-function"

# endif

# define LZ4_COMMONDEFS_ONLY

# include "lz4.c"   /* LZ4_count, constants, mem */

#endif

/*===   Enums   ===*/

typedef enum { noDictCtx, usingDictCtxHc } dictCtx_directive;

/*===   Constants   ===*/

#define OPTIMAL_ML (int)((ML_MASK-1)+MINMATCH)

#define LZ4_OPT_NUM   (1<<12)

/*===   Macros   ===*/

#define MIN(a,b)   ( (a) < (b) ? (a) : (b) )

#define MAX(a,b)   ( (a) > (b) ? (a) : (b) )

#define DELTANEXTU16(table, pos) table[(U16)(pos)]   /* faster */

/* Make fields passed to, and updated by LZ4HC_encodeSequence explicit */

#define UPDATABLE(ip, op, anchor) &ip, &op, &anchor

/*===   Hashing   ===*/

#define LZ4HC_HASHSIZE 4

#define HASH_FUNCTION(i)         (((i) * 2654435761U) >> ((MINMATCH*8)-LZ4HC_HASH_LOG))

static U32 LZ4HC_hashPtr(const void* ptr) { return HASH_FUNCTION(LZ4_read32(ptr)); }

#if defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==2)

/* lie to the compiler about data alignment; use with caution */

static U64 LZ4_read64(const void* memPtr) { return *(const U64*) memPtr; }

#elif defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==1)

/* __pack instructions are safer, but compiler specific */

LZ4_PACK(typedef struct { U64 u64; }) LZ4_unalign64;

static U64 LZ4_read64(const void* ptr) { return ((const LZ4_unalign64*)ptr)->u64; }

#else  /* safe and portable access using memcpy() */

static U64 LZ4_read64(const void* memPtr)

{

    U64 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;

}

#endif /* LZ4_FORCE_MEMORY_ACCESS */

#define LZ4MID_HASHSIZE 8

#define LZ4MID_HASHLOG (LZ4HC_HASH_LOG-1)

#define LZ4MID_HASHTABLESIZE (1 << LZ4MID_HASHLOG)

static U32 LZ4MID_hash4(U32 v) { return (v * 2654435761U) >> (32-LZ4MID_HASHLOG); }

static U32 LZ4MID_hash4Ptr(const void* ptr) { return LZ4MID_hash4(LZ4_read32(ptr)); }

/* note: hash7 hashes the lower 56-bits.

 * It presumes input was read using little endian.*/

static U32 LZ4MID_hash7(U64 v) { return (U32)(((v  << (64-56)) * 58295818150454627ULL) >> (64-LZ4MID_HASHLOG)) ; }

static U64 LZ4_readLE64(const void* memPtr);

static U32 LZ4MID_hash8Ptr(const void* ptr) { return LZ4MID_hash7(LZ4_readLE64(ptr)); }

static U64 LZ4_readLE64(const void* memPtr)

{

    if (LZ4_isLittleEndian()) {

        return LZ4_read64(memPtr);

    } else {

        const BYTE* p = (const BYTE*)memPtr;

        /* note: relies on the compiler to simplify this expression */

        return (U64)p[0] | ((U64)p[1]<<8) | ((U64)p[2]<<16) | ((U64)p[3]<<24)

            | ((U64)p[4]<<32) | ((U64)p[5]<<40) | ((U64)p[6]<<48) | ((U64)p[7]<<56);

    }

}

/*===   Count match length   ===*/

LZ4_FORCE_INLINE

unsigned LZ4HC_NbCommonBytes32(U32 val)

{

    assert(val != 0);

    if (LZ4_isLittleEndian()) {

#     if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(LZ4_FORCE_SW_BITCOUNT)

        unsigned long r;

        _BitScanReverse(&r, val);

        return (unsigned)((31 - r) >> 3);

#     elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \

                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \

                                        !defined(LZ4_FORCE_SW_BITCOUNT)

        return (unsigned)__builtin_clz(val) >> 3;

#     else

        val >>= 8;

        val = ((((val + 0x00FFFF00) | 0x00FFFFFF) + val) |

              (val + 0x00FF0000)) >> 24;

        return (unsigned)val ^ 3;

#     endif

    } else {

#     if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(LZ4_FORCE_SW_BITCOUNT)

        unsigned long r;

        _BitScanForward(&r, val);

        return (unsigned)(r >> 3);

#     elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \

                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \

                                        !defined(LZ4_FORCE_SW_BITCOUNT)

        return (unsigned)__builtin_ctz(val) >> 3;

#     else

        const U32 m = 0x01010101;

        return (unsigned)((((val - 1) ^ val) & (m - 1)) * m) >> 24;

#     endif

    }

}

/** LZ4HC_countBack() :

 * @return : negative value, nb of common bytes before ip/match */

LZ4_FORCE_INLINE

int LZ4HC_countBack(const BYTE* const ip, const BYTE* const match,

                    const BYTE* const iMin, const BYTE* const mMin)

{

    int back = 0;

    int const min = (int)MAX(iMin - ip, mMin - match);

    assert(min <= 0);

    assert(ip >= iMin); assert((size_t)(ip-iMin) < (1U<<31));

    assert(match >= mMin); assert((size_t)(match - mMin) < (1U<<31));

    while ((back - min) > 3) {

        U32 const v = LZ4_read32(ip + back - 4) ^ LZ4_read32(match + back - 4);

        if (v) {

            return (back - (int)LZ4HC_NbCommonBytes32(v));

        } else back -= 4; /* 4-byte step */

    }

    /* check remainder if any */

    while ( (back > min)

         && (ip[back-1] == match[back-1]) )

            back--;

    return back;

}

/**************************************

*  Init

**************************************/

static void LZ4HC_clearTables (LZ4HC_CCtx_internal* hc4)

{

    MEM_INIT(hc4->hashTable, 0, sizeof(hc4->hashTable));

    MEM_INIT(hc4->chainTable, 0xFF, sizeof(hc4->chainTable));

}

static void LZ4HC_init_internal (LZ4HC_CCtx_internal* hc4, const BYTE* start)

{

    size_t const bufferSize = (size_t)(hc4->end - hc4->prefixStart);

    size_t newStartingOffset = bufferSize + hc4->dictLimit;

    DEBUGLOG(5, "LZ4HC_init_internal");

    assert(newStartingOffset >= bufferSize);  /* check overflow */

    if (newStartingOffset > 1 GB) {

        LZ4HC_clearTables(hc4);

        newStartingOffset = 0;

    }

    newStartingOffset += 64 KB;

    hc4->nextToUpdate = (U32)newStartingOffset;

    hc4->prefixStart = start;

    hc4->end = start;

    hc4->dictStart = start;

    hc4->dictLimit = (U32)newStartingOffset;

    hc4->lowLimit = (U32)newStartingOffset;

}

/**************************************

*  Encode

**************************************/

/* LZ4HC_encodeSequence() :

 * @return : 0 if ok,

 *           1 if buffer issue detected */

LZ4_FORCE_INLINE int LZ4HC_encodeSequence (

    const BYTE** _ip,

    BYTE** _op,

    const BYTE** _anchor,

    int matchLength,

    int offset,

    limitedOutput_directive limit,

    BYTE* oend)

{

#define ip      (*_ip)

#define op      (*_op)

#define anchor  (*_anchor)

    size_t length;

    BYTE* const token = op++;

#if defined(LZ4_DEBUG) && (LZ4_DEBUG >= 6)

    static const BYTE* start = NULL;

    static U32 totalCost = 0;

    U32 const pos = (start==NULL) ? 0 : (U32)(anchor - start);

    U32 const ll = (U32)(ip - anchor);

    U32 const llAdd = (ll>=15) ? ((ll-15) / 255) + 1 : 0;

    U32 const mlAdd = (matchLength>=19) ? ((matchLength-19) / 255) + 1 : 0;

    U32 const cost = 1 + llAdd + ll + 2 + mlAdd;

    if (start==NULL) start = anchor;  /* only works for single segment */

    /* g_debuglog_enable = (pos >= 2228) & (pos <= 2262); */

    DEBUGLOG(6, "pos:%7u -- literals:%4u, match:%4i, offset:%5i, cost:%4u + %5u",

                pos,

                (U32)(ip - anchor), matchLength, offset,

                cost, totalCost);

    totalCost += cost;

#endif

    /* Encode Literal length */

    length = (size_t)(ip - anchor);

    LZ4_STATIC_ASSERT(notLimited == 0);

    /* Check output limit */

    if (limit && ((op + (length / 255) + length + (2 + 1 + LASTLITERALS)) > oend)) {

        DEBUGLOG(6, "Not enough room to write %i literals (%i bytes remaining)",

                (int)length, (int)(oend - op));

        return 1;

    }

    if (length >= RUN_MASK) {

        size_t len = length - RUN_MASK;

        *token = (RUN_MASK << ML_BITS);

        for(; len >= 255 ; len -= 255) *op++ = 255;

        *op++ = (BYTE)len;

    } else {

        *token = (BYTE)(length << ML_BITS);

    }

    /* Copy Literals */

    LZ4_wildCopy8(op, anchor, op + length);

    op += length;

    /* Encode Offset */

    assert(offset <= LZ4_DISTANCE_MAX );

    assert(offset > 0);

    LZ4_writeLE16(op, (U16)(offset)); op += 2;

    /* Encode MatchLength */

    assert(matchLength >= MINMATCH);

    length = (size_t)matchLength - MINMATCH;

    if (limit && (op + (length / 255) + (1 + LASTLITERALS) > oend)) {

        DEBUGLOG(6, "Not enough room to write match length");

        return 1;   /* Check output limit */

    }

    if (length >= ML_MASK) {

        *token += ML_MASK;

        length -= ML_MASK;

        for(; length >= 510 ; length -= 510) { *op++ = 255; *op++ = 255; }

        if (length >= 255) { length -= 255; *op++ = 255; }

        *op++ = (BYTE)length;

    } else {

        *token += (BYTE)(length);

    }

    /* Prepare next loop */

    ip += matchLength;

    anchor = ip;

    return 0;

#undef ip

#undef op

#undef anchor

}

typedef struct {

    int off;

    int len;

    int back;  /* negative value */

} LZ4HC_match_t;

LZ4HC_match_t LZ4HC_searchExtDict(const BYTE* ip, U32 ipIndex,

        const BYTE* const iLowLimit, const BYTE* const iHighLimit,

        const LZ4HC_CCtx_internal* dictCtx, U32 gDictEndIndex,

        int currentBestML, int nbAttempts)

{

    size_t const lDictEndIndex = (size_t)(dictCtx->end - dictCtx->prefixStart) + dictCtx->dictLimit;

    U32 lDictMatchIndex = dictCtx->hashTable[LZ4HC_hashPtr(ip)];

    U32 matchIndex = lDictMatchIndex + gDictEndIndex - (U32)lDictEndIndex;

    int offset = 0, sBack = 0;

    assert(lDictEndIndex <= 1 GB);

    if (lDictMatchIndex>0)

        DEBUGLOG(7, "lDictEndIndex = %zu, lDictMatchIndex = %u", lDictEndIndex, lDictMatchIndex);

    while (ipIndex - matchIndex <= LZ4_DISTANCE_MAX && nbAttempts--) {

        const BYTE* const matchPtr = dictCtx->prefixStart - dictCtx->dictLimit + lDictMatchIndex;

        if (LZ4_read32(matchPtr) == LZ4_read32(ip)) {

            int mlt;

            int back = 0;

            const BYTE* vLimit = ip + (lDictEndIndex - lDictMatchIndex);

            if (vLimit > iHighLimit) vLimit = iHighLimit;

            mlt = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH;

            back = (ip > iLowLimit) ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictCtx->prefixStart) : 0;

            mlt -= back;

            if (mlt > currentBestML) {

                currentBestML = mlt;

                offset = (int)(ipIndex - matchIndex);

                sBack = back;

                DEBUGLOG(7, "found match of length %i within extDictCtx", currentBestML);

        }   }

        {   U32 const nextOffset = DELTANEXTU16(dictCtx->chainTable, lDictMatchIndex);

            lDictMatchIndex -= nextOffset;

            matchIndex -= nextOffset;

    }   }

    {   LZ4HC_match_t md;

        md.len = currentBestML;

        md.off = offset;

        md.back = sBack;

        return md;

    }

}

/**************************************

*  Mid Compression (level 2)

**************************************/

LZ4_FORCE_INLINE void

LZ4MID_addPosition(U32* hTable, U32 hValue, U32 index)

{

    hTable[hValue] = index;

}

#define ADDPOS8(_p, _idx) LZ4MID_addPosition(hash8Table, LZ4MID_hash8Ptr(_p), _idx)

#define ADDPOS4(_p, _idx) LZ4MID_addPosition(hash4Table, LZ4MID_hash4Ptr(_p), _idx)

static int LZ4HC_compress_2hashes (

    LZ4HC_CCtx_internal* const ctx,

    const char* const src,

    char* const dst,

    int* srcSizePtr,

    int const maxOutputSize,

    const limitedOutput_directive limit,

    const dictCtx_directive dict

    )

{

    U32* const hash4Table = ctx->hashTable;

    U32* const hash8Table = hash4Table + LZ4MID_HASHTABLESIZE;

    const BYTE* ip = (const BYTE*)src;

    const BYTE* anchor = ip;

    const BYTE* const iend = ip + *srcSizePtr;

    const BYTE* const mflimit = iend - MFLIMIT;

    const BYTE* const matchlimit = (iend - LASTLITERALS);

    const BYTE* const ilimit = (iend - LZ4MID_HASHSIZE);

    BYTE* op = (BYTE*)dst;

    BYTE* oend = op + maxOutputSize;

    const BYTE* const prefixPtr = ctx->prefixStart;

    const U32 prefixIdx = ctx->dictLimit;

    const U32 ilimitIdx = (U32)(ilimit - prefixPtr) + prefixIdx;

    const U32 gDictEndIndex = ctx->lowLimit;

    unsigned matchLength;

    unsigned matchDistance;

    /* input sanitization */

    DEBUGLOG(5, "LZ4HC_compress_2hashes (%i bytes)", *srcSizePtr);

    assert(*srcSizePtr >= 0);

    if (*srcSizePtr) assert(src != NULL);

    if (maxOutputSize) assert(dst != NULL);

    if (*srcSizePtr < 0) return 0;  /* invalid */

    if (maxOutputSize < 0) return 0; /* invalid */

    if (*srcSizePtr > LZ4_MAX_INPUT_SIZE) {

        /* forbidden: no input is allowed to be that large */

        return 0;

    }

    if (limit == fillOutput) oend -= LASTLITERALS;  /* Hack for support LZ4 format restriction */

    if (*srcSizePtr < LZ4_minLength)

        goto _lz4mid_last_literals;  /* Input too small, no compression (all literals) */

    /* main loop */

    while (ip <= mflimit) {

        const U32 ipIndex = (U32)(ip - prefixPtr) + prefixIdx;

        /* search long match */

        {   U32 h8 = LZ4MID_hash8Ptr(ip);

            U32 pos8 = hash8Table[h8];

            assert(h8 < LZ4MID_HASHTABLESIZE);

            assert(h8 < ipIndex);

            LZ4MID_addPosition(hash8Table, h8, ipIndex);

            if ( ipIndex - pos8 <= LZ4_DISTANCE_MAX

              && pos8 >= prefixIdx  /* note: currently only search within prefix */

              ) {

                /* match candidate found */

                const BYTE* matchPtr = prefixPtr + pos8 - prefixIdx;

                assert(matchPtr < ip);

                matchLength = LZ4_count(ip, matchPtr, matchlimit);

                if (matchLength >= MINMATCH) {

                    DEBUGLOG(7, "found candidate match at pos %u (len=%u)", pos8, matchLength);

                    matchDistance = ipIndex - pos8;

                    goto _lz4mid_encode_sequence;

                }

        }   }

        /* search short match */

        {   U32 h4 = LZ4MID_hash4Ptr(ip);

            U32 pos4 = hash4Table[h4];

            assert(h4 < LZ4MID_HASHTABLESIZE);

            assert(pos4 < ipIndex);

            LZ4MID_addPosition(hash4Table, h4, ipIndex);

            if (ipIndex - pos4 <= LZ4_DISTANCE_MAX

              && pos4 >= prefixIdx /* only search within prefix */

              ) {

                /* match candidate found */

                const BYTE* const matchPtr = prefixPtr + (pos4 - prefixIdx);

                assert(matchPtr < ip);

                assert(matchPtr >= prefixPtr);

                matchLength = LZ4_count(ip, matchPtr, matchlimit);

                if (matchLength >= MINMATCH) {

                    /* short match found, let's just check ip+1 for longer */

                    U32 const h8 = LZ4MID_hash8Ptr(ip+1);

                    U32 const pos8 = hash8Table[h8];

                    U32 const m2Distance = ipIndex + 1 - pos8;

                    matchDistance = ipIndex - pos4;

                    if ( m2Distance <= LZ4_DISTANCE_MAX

                      && pos8 >= prefixIdx /* only search within prefix */

                      && likely(ip < mflimit)

                      ) {

                        const BYTE* const m2Ptr = prefixPtr + (pos8 - prefixIdx);

                        unsigned ml2 = LZ4_count(ip+1, m2Ptr, matchlimit);

                        if (ml2 > matchLength) {

                            LZ4MID_addPosition(hash8Table, h8, ipIndex+1);

                            ip++;

                            matchLength = ml2;

                            matchDistance = m2Distance;

                    }   }

                    goto _lz4mid_encode_sequence;

                }

        }   }

        /* no match found in prefix */

        if ( (dict == usingDictCtxHc)

          && (ipIndex - gDictEndIndex < LZ4_DISTANCE_MAX - 8) ) {

            /* search a match in dictionary */

            LZ4HC_match_t dMatch = LZ4HC_searchExtDict(ip, ipIndex,

                    anchor, matchlimit,

                    ctx->dictCtx, gDictEndIndex,

                    0, 2);

            if (dMatch.len >= MINMATCH) {

                DEBUGLOG(7, "found Dictionary match (offset=%i)", dMatch.off);

                ip += dMatch.back;

                assert(ip >= anchor);

                matchLength = (unsigned)dMatch.len;

                matchDistance = (unsigned)dMatch.off;

                goto _lz4mid_encode_sequence;

            }

        }

        /* no match found */

        ip += 1 + ((ip-anchor) >> 9);  /* skip faster over incompressible data */

        continue;

_lz4mid_encode_sequence:

        /* catch back */

        while (((ip > anchor) & ((U32)(ip-prefixPtr) > matchDistance)) && (unlikely(ip[-1] == ip[-(int)matchDistance-1]))) {

            ip--;  matchLength++;

        };

        /* fill table with beginning of match */

        ADDPOS8(ip+1, ipIndex+1);

        ADDPOS8(ip+2, ipIndex+2);

        ADDPOS4(ip+1, ipIndex+1);

        /* encode */

        {   BYTE* const saved_op = op;

            /* LZ4HC_encodeSequence always updates @op; on success, it updates @ip and @anchor */

            if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),

                    (int)matchLength, (int)matchDistance,

                    limit, oend) ) {

                op = saved_op;  /* restore @op value before failed LZ4HC_encodeSequence */

                goto _lz4mid_dest_overflow;

            }

        }

        /* fill table with end of match */

        {   U32 endMatchIdx = (U32)(ip-prefixPtr) + prefixIdx;

            U32 pos_m2 = endMatchIdx - 2;

            if (pos_m2 < ilimitIdx) {

                if (likely(ip - prefixPtr > 5)) {

                    ADDPOS8(ip-5, endMatchIdx - 5);

                }

                ADDPOS8(ip-3, endMatchIdx - 3);

                ADDPOS8(ip-2, endMatchIdx - 2);

                ADDPOS4(ip-2, endMatchIdx - 2);

                ADDPOS4(ip-1, endMatchIdx - 1);

            }

        }

    }

_lz4mid_last_literals:

    /* Encode Last Literals */

    {   size_t lastRunSize = (size_t)(iend - anchor);  /* literals */

        size_t llAdd = (lastRunSize + 255 - RUN_MASK) / 255;

        size_t const totalSize = 1 + llAdd + lastRunSize;

        if (limit == fillOutput) oend += LASTLITERALS;  /* restore correct value */

        if (limit && (op + totalSize > oend)) {

            if (limit == limitedOutput) return 0;  /* not enough space in @dst */

            /* adapt lastRunSize to fill 'dest' */

            lastRunSize  = (size_t)(oend - op) - 1 /*token*/;

            llAdd = (lastRunSize + 256 - RUN_MASK) / 256;

            lastRunSize -= llAdd;

        }

        DEBUGLOG(6, "Final literal run : %i literals", (int)lastRunSize);

        ip = anchor + lastRunSize;  /* can be != iend if limit==fillOutput */

        if (lastRunSize >= RUN_MASK) {

            size_t accumulator = lastRunSize - RUN_MASK;

            *op++ = (RUN_MASK << ML_BITS);

            for(; accumulator >= 255 ; accumulator -= 255)

                *op++ = 255;

            *op++ = (BYTE) accumulator;

        } else {

            *op++ = (BYTE)(lastRunSize << ML_BITS);

        }

        assert(lastRunSize <= (size_t)(oend - op));

        LZ4_memcpy(op, anchor, lastRunSize);

        op += lastRunSize;

    }

    /* End */

    DEBUGLOG(5, "compressed %i bytes into %i bytes", *srcSizePtr, (int)((char*)op - dst));

    assert(ip >= (const BYTE*)src);

    assert(ip <= iend);

    *srcSizePtr = (int)(ip - (const BYTE*)src);

    assert((char*)op >= dst);

    assert(op <= oend);

    assert((char*)op - dst < INT_MAX);

    return (int)((char*)op - dst);

_lz4mid_dest_overflow:

    if (limit == fillOutput) {

        /* Assumption : @ip, @anchor, @optr and @matchLength must be set correctly */

        size_t const ll = (size_t)(ip - anchor);

        size_t const ll_addbytes = (ll + 240) / 255;

        size_t const ll_totalCost = 1 + ll_addbytes + ll;

        BYTE* const maxLitPos = oend - 3; /* 2 for offset, 1 for token */

        DEBUGLOG(6, "Last sequence is overflowing : %u literals, %u remaining space",

                (unsigned)ll, (unsigned)(oend-op));

        if (op + ll_totalCost <= maxLitPos) {

            /* ll validated; now adjust match length */

            size_t const bytesLeftForMl = (size_t)(maxLitPos - (op+ll_totalCost));

            size_t const maxMlSize = MINMATCH + (ML_MASK-1) + (bytesLeftForMl * 255);

            assert(maxMlSize < INT_MAX);

            if ((size_t)matchLength > maxMlSize) matchLength= (unsigned)maxMlSize;

            if ((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1 + matchLength >= MFLIMIT) {

            DEBUGLOG(6, "Let's encode a last sequence (ll=%u, ml=%u)", (unsigned)ll, matchLength);

                LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),

                        (int)matchLength, (int)matchDistance,

                        notLimited, oend);

        }   }

        DEBUGLOG(6, "Let's finish with a run of literals (%u bytes left)", (unsigned)(oend-op));

        goto _lz4mid_last_literals;

    }

    /* compression failed */

    return 0;

}

/**************************************

*  HC Compression - Search

**************************************/

/* Update chains up to ip (excluded) */

LZ4_FORCE_INLINE void LZ4HC_Insert (LZ4HC_CCtx_internal* hc4, const BYTE* ip)

{

    U16* const chainTable = hc4->chainTable;

    U32* const hashTable  = hc4->hashTable;

    const BYTE* const prefixPtr = hc4->prefixStart;

    U32 const prefixIdx = hc4->dictLimit;

    U32 const target = (U32)(ip - prefixPtr) + prefixIdx;

    U32 idx = hc4->nextToUpdate;

    assert(ip >= prefixPtr);

    assert(target >= prefixIdx);

    while (idx < target) {

        U32 const h = LZ4HC_hashPtr(prefixPtr+idx-prefixIdx);

        size_t delta = idx - hashTable[h];

        if (delta>LZ4_DISTANCE_MAX) delta = LZ4_DISTANCE_MAX;

        DELTANEXTU16(chainTable, idx) = (U16)delta;

        hashTable[h] = idx;

        idx++;

    }

    hc4->nextToUpdate = target;

}

#if defined(_MSC_VER)

#  define LZ4HC_rotl32(x,r) _rotl(x,r)

#else

#  define LZ4HC_rotl32(x,r) ((x << r) | (x >> (32 - r)))

#endif

static U32 LZ4HC_rotatePattern(size_t const rotate, U32 const pattern)

{

    size_t const bitsToRotate = (rotate & (sizeof(pattern) - 1)) << 3;

    if (bitsToRotate == 0) return pattern;

    return LZ4HC_rotl32(pattern, (int)bitsToRotate);

}

/* LZ4HC_countPattern() :

 * pattern32 must be a sample of repetitive pattern of length 1, 2 or 4 (but not 3!) */

static unsigned

LZ4HC_countPattern(const BYTE* ip, const BYTE* const iEnd, U32 const pattern32)

{

    const BYTE* const iStart = ip;

    reg_t const pattern = (sizeof(pattern)==8) ?

        (reg_t)pattern32 + (((reg_t)pattern32) << (sizeof(pattern)*4)) : pattern32;

    while (likely(ip < iEnd-(sizeof(pattern)-1))) {

        reg_t const diff = LZ4_read_ARCH(ip) ^ pattern;

        if (!diff) { ip+=sizeof(pattern); continue; }

        ip += LZ4_NbCommonBytes(diff);

        return (unsigned)(ip - iStart);

    }

    if (LZ4_isLittleEndian()) {

        reg_t patternByte = pattern;

        while ((ip<iEnd) && (*ip == (BYTE)patternByte)) {

            ip++; patternByte >>= 8;

        }

    } else {  /* big endian */

        U32 bitOffset = (sizeof(pattern)*8) - 8;

        while (ip < iEnd) {

            BYTE const byte = (BYTE)(pattern >> bitOffset);

            if (*ip != byte) break;

            ip ++; bitOffset -= 8;

    }   }

    return (unsigned)(ip - iStart);

}

/* LZ4HC_reverseCountPattern() :

 * pattern must be a sample of repetitive pattern of length 1, 2 or 4 (but not 3!)

 * read using natural platform endianness */

static unsigned

LZ4HC_reverseCountPattern(const BYTE* ip, const BYTE* const iLow, U32 pattern)

{

    const BYTE* const iStart = ip;

    while (likely(ip >= iLow+4)) {

        if (LZ4_read32(ip-4) != pattern) break;

        ip -= 4;

    }

    {   const BYTE* bytePtr = (const BYTE*)(&pattern) + 3; /* works for any endianness */

        while (likely(ip>iLow)) {

            if (ip[-1] != *bytePtr) break;

            ip--; bytePtr--;

    }   }

    return (unsigned)(iStart - ip);

}

/* LZ4HC_protectDictEnd() :

 * Checks if the match is in the last 3 bytes of the dictionary, so reading the

 * 4 byte MINMATCH would overflow.

 * @returns true if the match index is okay.

 */

static int LZ4HC_protectDictEnd(U32 const dictLimit, U32 const matchIndex)

{

    return ((U32)((dictLimit - 1) - matchIndex) >= 3);

}

typedef enum { rep_untested, rep_not, rep_confirmed } repeat_state_e;

typedef enum { favorCompressionRatio=0, favorDecompressionSpeed } HCfavor_e;

LZ4_FORCE_INLINE LZ4HC_match_t

LZ4HC_InsertAndGetWiderMatch (

        LZ4HC_CCtx_internal* const hc4,

        const BYTE* const ip,

        const BYTE* const iLowLimit, const BYTE* const iHighLimit,

        int longest,

        const int maxNbAttempts,

        const int patternAnalysis, const int chainSwap,

        const dictCtx_directive dict,

        const HCfavor_e favorDecSpeed)

{

    U16* const chainTable = hc4->chainTable;

    U32* const hashTable = hc4->hashTable;

    const LZ4HC_CCtx_internal* const dictCtx = hc4->dictCtx;

    const BYTE* const prefixPtr = hc4->prefixStart;

    const U32 prefixIdx = hc4->dictLimit;

    const U32 ipIndex = (U32)(ip - prefixPtr) + prefixIdx;

    const int withinStartDistance = (hc4->lowLimit + (LZ4_DISTANCE_MAX + 1) > ipIndex);

    const U32 lowestMatchIndex = (withinStartDistance) ? hc4->lowLimit : ipIndex - LZ4_DISTANCE_MAX;

    const BYTE* const dictStart = hc4->dictStart;

    const U32 dictIdx = hc4->lowLimit;

    const BYTE* const dictEnd = dictStart + prefixIdx - dictIdx;

    int const lookBackLength = (int)(ip-iLowLimit);

    int nbAttempts = maxNbAttempts;

    U32 matchChainPos = 0;

    U32 const pattern = LZ4_read32(ip);

    U32 matchIndex;

    repeat_state_e repeat = rep_untested;

    size_t srcPatternLength = 0;

    int offset = 0, sBack = 0;

    DEBUGLOG(7, "LZ4HC_InsertAndGetWiderMatch");

    /* First Match */

    LZ4HC_Insert(hc4, ip);  /* insert all prior positions up to ip (excluded) */

    matchIndex = hashTable[LZ4HC_hashPtr(ip)];

    DEBUGLOG(7, "First candidate match for pos %u found at index %u / %u (lowestMatchIndex)",

                ipIndex, matchIndex, lowestMatchIndex);

    while ((matchIndex>=lowestMatchIndex) && (nbAttempts>0)) {

        int matchLength=0;

        nbAttempts--;

        assert(matchIndex < ipIndex);

        if (favorDecSpeed && (ipIndex - matchIndex < 8)) {

            /* do nothing:

             * favorDecSpeed intentionally skips matches with offset < 8 */

        } else if (matchIndex >= prefixIdx) {   /* within current Prefix */

            const BYTE* const matchPtr = prefixPtr + (matchIndex - prefixIdx);

            assert(matchPtr < ip);

            assert(longest >= 1);

            if (LZ4_read16(iLowLimit + longest - 1) == LZ4_read16(matchPtr - lookBackLength + longest - 1)) {

                if (LZ4_read32(matchPtr) == pattern) {

                    int const back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, prefixPtr) : 0;

                    matchLength = MINMATCH + (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, iHighLimit);

                    matchLength -= back;

                    if (matchLength > longest) {

                        longest = matchLength;

                        offset = (int)(ipIndex - matchIndex);

                        sBack = back;

                        DEBUGLOG(7, "Found match of len=%i within prefix, offset=%i, back=%i", longest, offset, -back);

            }   }   }

        } else {   /* lowestMatchIndex <= matchIndex < dictLimit : within Ext Dict */

            const BYTE* const matchPtr = dictStart + (matchIndex - dictIdx);

            assert(matchIndex >= dictIdx);

            if ( likely(matchIndex <= prefixIdx - 4)

              && (LZ4_read32(matchPtr) == pattern) ) {

                int back = 0;

                const BYTE* vLimit = ip + (prefixIdx - matchIndex);

                if (vLimit > iHighLimit) vLimit = iHighLimit;

                matchLength = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH;

                if ((ip+matchLength == vLimit) && (vLimit < iHighLimit))

                    matchLength += LZ4_count(ip+matchLength, prefixPtr, iHighLimit);

                back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictStart) : 0;

                matchLength -= back;

                if (matchLength > longest) {

                    longest = matchLength;

                    offset = (int)(ipIndex - matchIndex);

                    sBack = back;

                    DEBUGLOG(7, "Found match of len=%i within dict, offset=%i, back=%i", longest, offset, -back);

        }   }   }

        if (chainSwap && matchLength==longest) {   /* better match => select a better chain */

            assert(lookBackLength==0);   /* search forward only */

            if (matchIndex + (U32)longest <= ipIndex) {

                int const kTrigger = 4;

                U32 distanceToNextMatch = 1;

                int const end = longest - MINMATCH + 1;

                int step = 1;

                int accel = 1 << kTrigger;

                int pos;

                for (pos = 0; pos < end; pos += step) {

                    U32 const candidateDist = DELTANEXTU16(chainTable, matchIndex + (U32)pos);

                    step = (accel++ >> kTrigger);

                    if (candidateDist > distanceToNextMatch) {

                        distanceToNextMatch = candidateDist;

                        matchChainPos = (U32)pos;

                        accel = 1 << kTrigger;

                }   }

                if (distanceToNextMatch > 1) {

                    if (distanceToNextMatch > matchIndex) break;   /* avoid overflow */

                    matchIndex -= distanceToNextMatch;

                    continue;

        }   }   }

        {   U32 const distNextMatch = DELTANEXTU16(chainTable, matchIndex);

            if (patternAnalysis && distNextMatch==1 && matchChainPos==0) {

                U32 const matchCandidateIdx = matchIndex-1;

                /* may be a repeated pattern */

                if (repeat == rep_untested) {

                    if ( ((pattern & 0xFFFF) == (pattern >> 16))

                      &  ((pattern & 0xFF)   == (pattern >> 24)) ) {

                        DEBUGLOG(7, "Repeat pattern detected, char %02X", pattern >> 24);

                        repeat = rep_confirmed;

                        srcPatternLength = LZ4HC_countPattern(ip+sizeof(pattern), iHighLimit, pattern) + sizeof(pattern);

                    } else {

                        repeat = rep_not;

                }   }

                if ( (repeat == rep_confirmed) && (matchCandidateIdx >= lowestMatchIndex)

                  && LZ4HC_protectDictEnd(prefixIdx, matchCandidateIdx) ) {

                    const int extDict = matchCandidateIdx < prefixIdx;

                    const BYTE* const matchPtr = extDict ? dictStart + (matchCandidateIdx - dictIdx) : prefixPtr + (matchCandidateIdx - prefixIdx);

                    if (LZ4_read32(matchPtr) == pattern) {  /* good candidate */

                        const BYTE* const iLimit = extDict ? dictEnd : iHighLimit;

                        size_t forwardPatternLength = LZ4HC_countPattern(matchPtr+sizeof(pattern), iLimit, pattern) + sizeof(pattern);

                        if (extDict && matchPtr + forwardPatternLength == iLimit) {

                            U32 const rotatedPattern = LZ4HC_rotatePattern(forwardPatternLength, pattern);

                            forwardPatternLength += LZ4HC_countPattern(prefixPtr, iHighLimit, rotatedPattern);

                        }

                        {   const BYTE* const lowestMatchPtr = extDict ? dictStart : prefixPtr;

                            size_t backLength = LZ4HC_reverseCountPattern(matchPtr, lowestMatchPtr, pattern);

                            size_t currentSegmentLength;

                            if (!extDict

                              && matchPtr - backLength == prefixPtr

                              && dictIdx < prefixIdx) {

                                U32 const rotatedPattern = LZ4HC_rotatePattern((U32)(-(int)backLength), pattern);

                                backLength += LZ4HC_reverseCountPattern(dictEnd, dictStart, rotatedPattern);

                            }

                            /* Limit backLength not go further than lowestMatchIndex */

                            backLength = matchCandidateIdx - MAX(matchCandidateIdx - (U32)backLength, lowestMatchIndex);

                            assert(matchCandidateIdx - backLength >= lowestMatchIndex);

                            currentSegmentLength = backLength + forwardPatternLength;

                            /* Adjust to end of pattern if the source pattern fits, otherwise the beginning of the pattern */

                            if ( (currentSegmentLength >= srcPatternLength)   /* current pattern segment large enough to contain full srcPatternLength */

                              && (forwardPatternLength <= srcPatternLength) ) { /* haven't reached this position yet */

                                U32 const newMatchIndex = matchCandidateIdx + (U32)forwardPatternLength - (U32)srcPatternLength;  /* best position, full pattern, might be followed by more match */

                                if (LZ4HC_protectDictEnd(prefixIdx, newMatchIndex))

                                    matchIndex = newMatchIndex;

                                else {

                                    /* Can only happen if started in the prefix */

                                    assert(newMatchIndex >= prefixIdx - 3 && newMatchIndex < prefixIdx && !extDict);

                                    matchIndex = prefixIdx;

                                }

                            } else {

                                U32 const newMatchIndex = matchCandidateIdx - (U32)backLength;   /* farthest position in current segment, will find a match of length currentSegmentLength + maybe some back */

                                if (!LZ4HC_protectDictEnd(prefixIdx, newMatchIndex)) {

                                    assert(newMatchIndex >= prefixIdx - 3 && newMatchIndex < prefixIdx && !extDict);

                                    matchIndex = prefixIdx;

                                } else {

                                    matchIndex = newMatchIndex;

                                    if (lookBackLength==0) {  /* no back possible */

                                        size_t const maxML = MIN(currentSegmentLength, srcPatternLength);

                                        if ((size_t)longest < maxML) {

                                            assert(prefixPtr - prefixIdx + matchIndex != ip);

                                            if ((size_t)(ip - prefixPtr) + prefixIdx - matchIndex > LZ4_DISTANCE_MAX) break;

                                            assert(maxML < 2 GB);

                                            longest = (int)maxML;

                                            offset = (int)(ipIndex - matchIndex);

                                            assert(sBack == 0);

                                            DEBUGLOG(7, "Found repeat pattern match of len=%i, offset=%i", longest, offset);

                                        }

                                        {   U32 const distToNextPattern = DELTANEXTU16(chainTable, matchIndex);

                                            if (distToNextPattern > matchIndex) break;  /* avoid overflow */

                                            matchIndex -= distToNextPattern;

                        }   }   }   }   }

                        continue;

                }   }

        }   }   /* PA optimization */

        /* follow current chain */

        matchIndex -= DELTANEXTU16(chainTable, matchIndex + matchChainPos);

    }  /* while ((matchIndex>=lowestMatchIndex) && (nbAttempts)) */

    if ( dict == usingDictCtxHc

      && nbAttempts > 0

      && withinStartDistance) {

        size_t const dictEndOffset = (size_t)(dictCtx->end - dictCtx->prefixStart) + dictCtx->dictLimit;

        U32 dictMatchIndex = dictCtx->hashTable[LZ4HC_hashPtr(ip)];

        assert(dictEndOffset <= 1 GB);

        matchIndex = dictMatchIndex + lowestMatchIndex - (U32)dictEndOffset;

        if (dictMatchIndex>0) DEBUGLOG(7, "dictEndOffset = %zu, dictMatchIndex = %u => relative matchIndex = %i", dictEndOffset, dictMatchIndex, (int)dictMatchIndex - (int)dictEndOffset);

        while (ipIndex - matchIndex <= LZ4_DISTANCE_MAX && nbAttempts--) {

            const BYTE* const matchPtr = dictCtx->prefixStart - dictCtx->dictLimit + dictMatchIndex;

            if (LZ4_read32(matchPtr) == pattern) {

                int mlt;

                int back = 0;

                const BYTE* vLimit = ip + (dictEndOffset - dictMatchIndex);

                if (vLimit > iHighLimit) vLimit = iHighLimit;

                mlt = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH;

                back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictCtx->prefixStart) : 0;

                mlt -= back;

                if (mlt > longest) {

                    longest = mlt;

                    offset = (int)(ipIndex - matchIndex);

                    sBack = back;

                    DEBUGLOG(7, "found match of length %i within extDictCtx", longest);

            }   }

            {   U32 const nextOffset = DELTANEXTU16(dictCtx->chainTable, dictMatchIndex);

                dictMatchIndex -= nextOffset;

                matchIndex -= nextOffset;

    }   }   }

    {   LZ4HC_match_t md;

        assert(longest >= 0);

        md.len = longest;

        md.off = offset;

        md.back = sBack;

        return md;

    }

}

LZ4_FORCE_INLINE LZ4HC_match_t

LZ4HC_InsertAndFindBestMatch(LZ4HC_CCtx_internal* const hc4,   /* Index table will be updated */

                       const BYTE* const ip, const BYTE* const iLimit,

                       const int maxNbAttempts,

                       const int patternAnalysis,

                       const dictCtx_directive dict)

{

    DEBUGLOG(7, "LZ4HC_InsertAndFindBestMatch");

    /* note : LZ4HC_InsertAndGetWiderMatch() is able to modify the starting position of a match (*startpos),

     * but this won't be the case here, as we define iLowLimit==ip,

     * so LZ4HC_InsertAndGetWiderMatch() won't be allowed to search past ip */

    return LZ4HC_InsertAndGetWiderMatch(hc4, ip, ip, iLimit, MINMATCH-1, maxNbAttempts, patternAnalysis, 0 /*chainSwap*/, dict, favorCompressionRatio);

}

LZ4_FORCE_INLINE int LZ4HC_compress_hashChain (

    LZ4HC_CCtx_internal* const ctx,

    const char* const source,

    char* const dest,

    int* srcSizePtr,

    int const maxOutputSize,

    int maxNbAttempts,

    const limitedOutput_directive limit,

    const dictCtx_directive dict

    )

{

    const int inputSize = *srcSizePtr;

    const int patternAnalysis = (maxNbAttempts > 128);   /* levels 9+ */

    const BYTE* ip = (const BYTE*) source;

    const BYTE* anchor = ip;

    const BYTE* const iend = ip + inputSize;

    const BYTE* const mflimit = iend - MFLIMIT;

    const BYTE* const matchlimit = (iend - LASTLITERALS);

    BYTE* optr = (BYTE*) dest;

    BYTE* op = (BYTE*) dest;

    BYTE* oend = op + maxOutputSize;

    const BYTE* start0;

    const BYTE* start2 = NULL;

    const BYTE* start3 = NULL;

    LZ4HC_match_t m0, m1, m2, m3;

    const LZ4HC_match_t nomatch = {0, 0, 0};

    /* init */

    DEBUGLOG(5, "LZ4HC_compress_hashChain (dict?=>%i)", dict);

    *srcSizePtr = 0;

    if (limit == fillOutput) oend -= LASTLITERALS;                  /* Hack for support LZ4 format restriction */

    if (inputSize < LZ4_minLength) goto _last_literals;             /* Input too small, no compression (all literals) */

    /* Main Loop */

    while (ip <= mflimit) {

        m1 = LZ4HC_InsertAndFindBestMatch(ctx, ip, matchlimit, maxNbAttempts, patternAnalysis, dict);

        if (m1.len<MINMATCH) { ip++; continue; }

        /* saved, in case we would skip too much */

        start0 = ip; m0 = m1;

_Search2:

        DEBUGLOG(7, "_Search2 (currently found match of size %i)", m1.len);

        if (ip+m1.len <= mflimit) {

            start2 = ip + m1.len - 2;

            m2 = LZ4HC_InsertAndGetWiderMatch(ctx,

                            start2, ip + 0, matchlimit, m1.len,

                            maxNbAttempts, patternAnalysis, 0, dict, favorCompressionRatio);

            start2 += m2.back;

        } else {

            m2 = nomatch;  /* do not search further */

        }

        if (m2.len <= m1.len) { /* No better match => encode ML1 immediately */

            optr = op;

            if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),

                    m1.len, m1.off,

                    limit, oend) )

                goto _dest_overflow;

            continue;

        }

        if (start0 < ip) {   /* first match was skipped at least once */

            if (start2 < ip + m0.len) {  /* squeezing ML1 between ML0(original ML1) and ML2 */

                ip = start0; m1 = m0;  /* restore initial Match1 */

        }   }

        /* Here, start0==ip */

        if ((start2 - ip) < 3) {  /* First Match too small : removed */

            ip = start2;

            m1 = m2;

            goto _Search2;

        }

_Search3:

        if ((start2 - ip) < OPTIMAL_ML) {

            int correction;

            int new_ml = m1.len;

            if (new_ml > OPTIMAL_ML) new_ml = OPTIMAL_ML;

            if (ip+new_ml > start2 + m2.len - MINMATCH)

                new_ml = (int)(start2 - ip) + m2.len - MINMATCH;

            correction = new_ml - (int)(start2 - ip);