/*

 * Copyright (c) Meta Platforms, Inc. and affiliates.

 * All rights reserved.

 *

 * This source code is licensed under both the BSD-style license (found in the

 * LICENSE file in the root directory of this source tree) and the GPLv2 (found

 * in the COPYING file in the root directory of this source tree).

 * You may select, at your option, one of the above-listed licenses.

 */

#include "zstd_compress_internal.h"

#include "zstd_lazy.h"

#include "../common/bits.h" /* ZSTD_countTrailingZeros64 */

#define kLazySkippingStep 8

/*-*************************************

*  Binary Tree search

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

static void

ZSTD_updateDUBT(ZSTD_matchState_t* ms,

                const BYTE* ip, const BYTE* iend,

                U32 mls)

{

    const ZSTD_compressionParameters* const cParams = &ms->cParams;

    U32* const hashTable = ms->hashTable;

    U32  const hashLog = cParams->hashLog;

    U32* const bt = ms->chainTable;

    U32  const btLog  = cParams->chainLog - 1;

    U32  const btMask = (1 << btLog) - 1;

    const BYTE* const base = ms->window.base;

    U32 const target = (U32)(ip - base);

    U32 idx = ms->nextToUpdate;

    if (idx != target)

        DEBUGLOG(7, "ZSTD_updateDUBT, from %u to %u (dictLimit:%u)",

                    idx, target, ms->window.dictLimit);

    assert(ip + 8 <= iend);   /* condition for ZSTD_hashPtr */

    (void)iend;

    assert(idx >= ms->window.dictLimit);   /* condition for valid base+idx */

    for ( ; idx < target ; idx++) {

        size_t const h  = ZSTD_hashPtr(base + idx, hashLog, mls);   /* assumption : ip + 8 <= iend */

        U32    const matchIndex = hashTable[h];

        U32*   const nextCandidatePtr = bt + 2*(idx&btMask);

        U32*   const sortMarkPtr  = nextCandidatePtr + 1;

        DEBUGLOG(8, "ZSTD_updateDUBT: insert %u", idx);

        hashTable[h] = idx;   /* Update Hash Table */

        *nextCandidatePtr = matchIndex;   /* update BT like a chain */

        *sortMarkPtr = ZSTD_DUBT_UNSORTED_MARK;

    }

    ms->nextToUpdate = target;

}

/** ZSTD_insertDUBT1() :

 *  sort one already inserted but unsorted position

 *  assumption : curr >= btlow == (curr - btmask)

 *  doesn't fail */

static void

ZSTD_insertDUBT1(const ZSTD_matchState_t* ms,

                 U32 curr, const BYTE* inputEnd,

                 U32 nbCompares, U32 btLow,

                 const ZSTD_dictMode_e dictMode)

{

    const ZSTD_compressionParameters* const cParams = &ms->cParams;

    U32* const bt = ms->chainTable;

    U32  const btLog  = cParams->chainLog - 1;

    U32  const btMask = (1 << btLog) - 1;

    size_t commonLengthSmaller=0, commonLengthLarger=0;

    const BYTE* const base = ms->window.base;

    const BYTE* const dictBase = ms->window.dictBase;

    const U32 dictLimit = ms->window.dictLimit;

    const BYTE* const ip = (curr>=dictLimit) ? base + curr : dictBase + curr;

    const BYTE* const iend = (curr>=dictLimit) ? inputEnd : dictBase + dictLimit;

    const BYTE* const dictEnd = dictBase + dictLimit;

    const BYTE* const prefixStart = base + dictLimit;

    const BYTE* match;

    U32* smallerPtr = bt + 2*(curr&btMask);

    U32* largerPtr  = smallerPtr + 1;

    U32 matchIndex = *smallerPtr;   /* this candidate is unsorted : next sorted candidate is reached through *smallerPtr, while *largerPtr contains previous unsorted candidate (which is already saved and can be overwritten) */

    U32 dummy32;   /* to be nullified at the end */

    U32 const windowValid = ms->window.lowLimit;

    U32 const maxDistance = 1U << cParams->windowLog;

    U32 const windowLow = (curr - windowValid > maxDistance) ? curr - maxDistance : windowValid;

    DEBUGLOG(8, "ZSTD_insertDUBT1(%u) (dictLimit=%u, lowLimit=%u)",

                curr, dictLimit, windowLow);

    assert(curr >= btLow);

    assert(ip < iend);   /* condition for ZSTD_count */

    for (; nbCompares && (matchIndex > windowLow); --nbCompares) {

        U32* const nextPtr = bt + 2*(matchIndex & btMask);

        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */

        assert(matchIndex < curr);

        /* note : all candidates are now supposed sorted,

         * but it's still possible to have nextPtr[1] == ZSTD_DUBT_UNSORTED_MARK

         * when a real index has the same value as ZSTD_DUBT_UNSORTED_MARK */

        if ( (dictMode != ZSTD_extDict)

          || (matchIndex+matchLength >= dictLimit)  /* both in current segment*/

          || (curr < dictLimit) /* both in extDict */) {

            const BYTE* const mBase = ( (dictMode != ZSTD_extDict)

                                     || (matchIndex+matchLength >= dictLimit)) ?

                                        base : dictBase;

            assert( (matchIndex+matchLength >= dictLimit)   /* might be wrong if extDict is incorrectly set to 0 */

                 || (curr < dictLimit) );

            match = mBase + matchIndex;

            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);

        } else {

            match = dictBase + matchIndex;

            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);

            if (matchIndex+matchLength >= dictLimit)

                match = base + matchIndex;   /* preparation for next read of match[matchLength] */

        }

        DEBUGLOG(8, "ZSTD_insertDUBT1: comparing %u with %u : found %u common bytes ",

                    curr, matchIndex, (U32)matchLength);

        if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */

            break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */

        }

        if (match[matchLength] < ip[matchLength]) {  /* necessarily within buffer */

            /* match is smaller than current */

            *smallerPtr = matchIndex;             /* update smaller idx */

            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */

            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop searching */

            DEBUGLOG(8, "ZSTD_insertDUBT1: %u (>btLow=%u) is smaller : next => %u",

                        matchIndex, btLow, nextPtr[1]);

            smallerPtr = nextPtr+1;               /* new "candidate" => larger than match, which was smaller than target */

            matchIndex = nextPtr[1];              /* new matchIndex, larger than previous and closer to current */

        } else {

            /* match is larger than current */

            *largerPtr = matchIndex;

            commonLengthLarger = matchLength;

            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop searching */

            DEBUGLOG(8, "ZSTD_insertDUBT1: %u (>btLow=%u) is larger => %u",

                        matchIndex, btLow, nextPtr[0]);

            largerPtr = nextPtr;

            matchIndex = nextPtr[0];

    }   }

    *smallerPtr = *largerPtr = 0;

}

static size_t

ZSTD_DUBT_findBetterDictMatch (

        const ZSTD_matchState_t* ms,

        const BYTE* const ip, const BYTE* const iend,

        size_t* offsetPtr,

        size_t bestLength,

        U32 nbCompares,

        U32 const mls,

        const ZSTD_dictMode_e dictMode)

{

    const ZSTD_matchState_t * const dms = ms->dictMatchState;

    const ZSTD_compressionParameters* const dmsCParams = &dms->cParams;

    const U32 * const dictHashTable = dms->hashTable;

    U32         const hashLog = dmsCParams->hashLog;

    size_t      const h  = ZSTD_hashPtr(ip, hashLog, mls);

    U32               dictMatchIndex = dictHashTable[h];

    const BYTE* const base = ms->window.base;

    const BYTE* const prefixStart = base + ms->window.dictLimit;

    U32         const curr = (U32)(ip-base);

    const BYTE* const dictBase = dms->window.base;

    const BYTE* const dictEnd = dms->window.nextSrc;

    U32         const dictHighLimit = (U32)(dms->window.nextSrc - dms->window.base);

    U32         const dictLowLimit = dms->window.lowLimit;

    U32         const dictIndexDelta = ms->window.lowLimit - dictHighLimit;

    U32*        const dictBt = dms->chainTable;

    U32         const btLog  = dmsCParams->chainLog - 1;

    U32         const btMask = (1 << btLog) - 1;

    U32         const btLow = (btMask >= dictHighLimit - dictLowLimit) ? dictLowLimit : dictHighLimit - btMask;

    size_t commonLengthSmaller=0, commonLengthLarger=0;

    (void)dictMode;

    assert(dictMode == ZSTD_dictMatchState);

    for (; nbCompares && (dictMatchIndex > dictLowLimit); --nbCompares) {

        U32* const nextPtr = dictBt + 2*(dictMatchIndex & btMask);

        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */

        const BYTE* match = dictBase + dictMatchIndex;

        matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);

        if (dictMatchIndex+matchLength >= dictHighLimit)

            match = base + dictMatchIndex + dictIndexDelta;   /* to prepare for next usage of match[matchLength] */

        if (matchLength > bestLength) {

            U32 matchIndex = dictMatchIndex + dictIndexDelta;

            if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(curr-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) ) {

                DEBUGLOG(9, "ZSTD_DUBT_findBetterDictMatch(%u) : found better match length %u -> %u and offsetCode %u -> %u (dictMatchIndex %u, matchIndex %u)",

                    curr, (U32)bestLength, (U32)matchLength, (U32)*offsetPtr, OFFSET_TO_OFFBASE(curr - matchIndex), dictMatchIndex, matchIndex);

                bestLength = matchLength, *offsetPtr = OFFSET_TO_OFFBASE(curr - matchIndex);

            }

            if (ip+matchLength == iend) {   /* reached end of input : ip[matchLength] is not valid, no way to know if it's larger or smaller than match */

                break;   /* drop, to guarantee consistency (miss a little bit of compression) */

            }

        }

        if (match[matchLength] < ip[matchLength]) {

            if (dictMatchIndex <= btLow) { break; }   /* beyond tree size, stop the search */

            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */

            dictMatchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */

        } else {

            /* match is larger than current */

            if (dictMatchIndex <= btLow) { break; }   /* beyond tree size, stop the search */

            commonLengthLarger = matchLength;

            dictMatchIndex = nextPtr[0];

        }

    }

    if (bestLength >= MINMATCH) {

        U32 const mIndex = curr - (U32)OFFBASE_TO_OFFSET(*offsetPtr); (void)mIndex;

        DEBUGLOG(8, "ZSTD_DUBT_findBetterDictMatch(%u) : found match of length %u and offsetCode %u (pos %u)",

                    curr, (U32)bestLength, (U32)*offsetPtr, mIndex);

    }

    return bestLength;

}

static size_t

ZSTD_DUBT_findBestMatch(ZSTD_matchState_t* ms,

                        const BYTE* const ip, const BYTE* const iend,

                        size_t* offBasePtr,

                        U32 const mls,

                        const ZSTD_dictMode_e dictMode)

{

    const ZSTD_compressionParameters* const cParams = &ms->cParams;

    U32*   const hashTable = ms->hashTable;

    U32    const hashLog = cParams->hashLog;

    size_t const h  = ZSTD_hashPtr(ip, hashLog, mls);

    U32          matchIndex  = hashTable[h];

    const BYTE* const base = ms->window.base;

    U32    const curr = (U32)(ip-base);

    U32    const windowLow = ZSTD_getLowestMatchIndex(ms, curr, cParams->windowLog);

    U32*   const bt = ms->chainTable;

    U32    const btLog  = cParams->chainLog - 1;

    U32    const btMask = (1 << btLog) - 1;

    U32    const btLow = (btMask >= curr) ? 0 : curr - btMask;

    U32    const unsortLimit = MAX(btLow, windowLow);

    U32*         nextCandidate = bt + 2*(matchIndex&btMask);

    U32*         unsortedMark = bt + 2*(matchIndex&btMask) + 1;

    U32          nbCompares = 1U << cParams->searchLog;

    U32          nbCandidates = nbCompares;

    U32          previousCandidate = 0;

    DEBUGLOG(7, "ZSTD_DUBT_findBestMatch (%u) ", curr);

    assert(ip <= iend-8);   /* required for h calculation */

    assert(dictMode != ZSTD_dedicatedDictSearch);

    /* reach end of unsorted candidates list */

    while ( (matchIndex > unsortLimit)

         && (*unsortedMark == ZSTD_DUBT_UNSORTED_MARK)

         && (nbCandidates > 1) ) {

        DEBUGLOG(8, "ZSTD_DUBT_findBestMatch: candidate %u is unsorted",

                    matchIndex);

        *unsortedMark = previousCandidate;  /* the unsortedMark becomes a reversed chain, to move up back to original position */

        previousCandidate = matchIndex;

        matchIndex = *nextCandidate;

        nextCandidate = bt + 2*(matchIndex&btMask);

        unsortedMark = bt + 2*(matchIndex&btMask) + 1;

        nbCandidates --;

    }

    /* nullify last candidate if it's still unsorted

     * simplification, detrimental to compression ratio, beneficial for speed */

    if ( (matchIndex > unsortLimit)

      && (*unsortedMark==ZSTD_DUBT_UNSORTED_MARK) ) {

        DEBUGLOG(7, "ZSTD_DUBT_findBestMatch: nullify last unsorted candidate %u",

                    matchIndex);

        *nextCandidate = *unsortedMark = 0;

    }

    /* batch sort stacked candidates */

    matchIndex = previousCandidate;

    while (matchIndex) {  /* will end on matchIndex == 0 */

        U32* const nextCandidateIdxPtr = bt + 2*(matchIndex&btMask) + 1;

        U32 const nextCandidateIdx = *nextCandidateIdxPtr;

        ZSTD_insertDUBT1(ms, matchIndex, iend,

                         nbCandidates, unsortLimit, dictMode);

        matchIndex = nextCandidateIdx;

        nbCandidates++;

    }

    /* find longest match */

    {   size_t commonLengthSmaller = 0, commonLengthLarger = 0;

        const BYTE* const dictBase = ms->window.dictBase;

        const U32 dictLimit = ms->window.dictLimit;

        const BYTE* const dictEnd = dictBase + dictLimit;

        const BYTE* const prefixStart = base + dictLimit;

        U32* smallerPtr = bt + 2*(curr&btMask);

        U32* largerPtr  = bt + 2*(curr&btMask) + 1;

        U32 matchEndIdx = curr + 8 + 1;

        U32 dummy32;   /* to be nullified at the end */

        size_t bestLength = 0;

        matchIndex  = hashTable[h];

        hashTable[h] = curr;   /* Update Hash Table */

        for (; nbCompares && (matchIndex > windowLow); --nbCompares) {

            U32* const nextPtr = bt + 2*(matchIndex & btMask);

            size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */

            const BYTE* match;

            if ((dictMode != ZSTD_extDict) || (matchIndex+matchLength >= dictLimit)) {

                match = base + matchIndex;

                matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);

            } else {

                match = dictBase + matchIndex;

                matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);

                if (matchIndex+matchLength >= dictLimit)

                    match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */

            }

            if (matchLength > bestLength) {

                if (matchLength > matchEndIdx - matchIndex)

                    matchEndIdx = matchIndex + (U32)matchLength;

                if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(curr - matchIndex + 1) - ZSTD_highbit32((U32)*offBasePtr)) )

                    bestLength = matchLength, *offBasePtr = OFFSET_TO_OFFBASE(curr - matchIndex);

                if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */

                    if (dictMode == ZSTD_dictMatchState) {

                        nbCompares = 0; /* in addition to avoiding checking any

                                         * further in this loop, make sure we

                                         * skip checking in the dictionary. */

                    }

                    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;

        assert(nbCompares <= (1U << ZSTD_SEARCHLOG_MAX)); /* Check we haven't underflowed. */

        if (dictMode == ZSTD_dictMatchState && nbCompares) {

            bestLength = ZSTD_DUBT_findBetterDictMatch(

                    ms, ip, iend,

                    offBasePtr, bestLength, nbCompares,

                    mls, dictMode);

        }

        assert(matchEndIdx > curr+8); /* ensure nextToUpdate is increased */

        ms->nextToUpdate = matchEndIdx - 8;   /* skip repetitive patterns */

        if (bestLength >= MINMATCH) {

            U32 const mIndex = curr - (U32)OFFBASE_TO_OFFSET(*offBasePtr); (void)mIndex;

            DEBUGLOG(8, "ZSTD_DUBT_findBestMatch(%u) : found match of length %u and offsetCode %u (pos %u)",

                        curr, (U32)bestLength, (U32)*offBasePtr, mIndex);

        }

        return bestLength;

    }

}

/** ZSTD_BtFindBestMatch() : Tree updater, providing best match */

FORCE_INLINE_TEMPLATE size_t

ZSTD_BtFindBestMatch( ZSTD_matchState_t* ms,

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

                      size_t* offBasePtr,

                const U32 mls /* template */,

                const ZSTD_dictMode_e dictMode)

{

    DEBUGLOG(7, "ZSTD_BtFindBestMatch");

    if (ip < ms->window.base + ms->nextToUpdate) return 0;   /* skipped area */

    ZSTD_updateDUBT(ms, ip, iLimit, mls);

    return ZSTD_DUBT_findBestMatch(ms, ip, iLimit, offBasePtr, mls, dictMode);

}

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

* Dedicated dict search

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

void ZSTD_dedicatedDictSearch_lazy_loadDictionary(ZSTD_matchState_t* ms, const BYTE* const ip)

{

    const BYTE* const base = ms->window.base;

    U32 const target = (U32)(ip - base);

    U32* const hashTable = ms->hashTable;

    U32* const chainTable = ms->chainTable;

    U32 const chainSize = 1 << ms->cParams.chainLog;

    U32 idx = ms->nextToUpdate;

    U32 const minChain = chainSize < target - idx ? target - chainSize : idx;

    U32 const bucketSize = 1 << ZSTD_LAZY_DDSS_BUCKET_LOG;

    U32 const cacheSize = bucketSize - 1;

    U32 const chainAttempts = (1 << ms->cParams.searchLog) - cacheSize;

    U32 const chainLimit = chainAttempts > 255 ? 255 : chainAttempts;

    /* We know the hashtable is oversized by a factor of `bucketSize`.

     * We are going to temporarily pretend `bucketSize == 1`, keeping only a

     * single entry. We will use the rest of the space to construct a temporary

     * chaintable.

     */

    U32 const hashLog = ms->cParams.hashLog - ZSTD_LAZY_DDSS_BUCKET_LOG;

    U32* const tmpHashTable = hashTable;

    U32* const tmpChainTable = hashTable + ((size_t)1 << hashLog);

    U32 const tmpChainSize = (U32)((1 << ZSTD_LAZY_DDSS_BUCKET_LOG) - 1) << hashLog;

    U32 const tmpMinChain = tmpChainSize < target ? target - tmpChainSize : idx;

    U32 hashIdx;

    assert(ms->cParams.chainLog <= 24);

    assert(ms->cParams.hashLog > ms->cParams.chainLog);

    assert(idx != 0);

    assert(tmpMinChain <= minChain);

    /* fill conventional hash table and conventional chain table */

    for ( ; idx < target; idx++) {

        U32 const h = (U32)ZSTD_hashPtr(base + idx, hashLog, ms->cParams.minMatch);

        if (idx >= tmpMinChain) {

            tmpChainTable[idx - tmpMinChain] = hashTable[h];

        }

        tmpHashTable[h] = idx;

    }

    /* sort chains into ddss chain table */

    {

        U32 chainPos = 0;

        for (hashIdx = 0; hashIdx < (1U << hashLog); hashIdx++) {

            U32 count;

            U32 countBeyondMinChain = 0;

            U32 i = tmpHashTable[hashIdx];

            for (count = 0; i >= tmpMinChain && count < cacheSize; count++) {

                /* skip through the chain to the first position that won't be

                 * in the hash cache bucket */

                if (i < minChain) {

                    countBeyondMinChain++;

                }

                i = tmpChainTable[i - tmpMinChain];

            }

            if (count == cacheSize) {

                for (count = 0; count < chainLimit;) {

                    if (i < minChain) {

                        if (!i || ++countBeyondMinChain > cacheSize) {

                            /* only allow pulling `cacheSize` number of entries

                             * into the cache or chainTable beyond `minChain`,

                             * to replace the entries pulled out of the

                             * chainTable into the cache. This lets us reach

                             * back further without increasing the total number

                             * of entries in the chainTable, guaranteeing the

                             * DDSS chain table will fit into the space

                             * allocated for the regular one. */

                            break;

                        }

                    }

                    chainTable[chainPos++] = i;

                    count++;

                    if (i < tmpMinChain) {

                        break;

                    }

                    i = tmpChainTable[i - tmpMinChain];

                }

            } else {

                count = 0;

            }

            if (count) {

                tmpHashTable[hashIdx] = ((chainPos - count) << 8) + count;

            } else {

                tmpHashTable[hashIdx] = 0;

            }

        }

        assert(chainPos <= chainSize); /* I believe this is guaranteed... */

    }

    /* move chain pointers into the last entry of each hash bucket */

    for (hashIdx = (1 << hashLog); hashIdx; ) {

        U32 const bucketIdx = --hashIdx << ZSTD_LAZY_DDSS_BUCKET_LOG;

        U32 const chainPackedPointer = tmpHashTable[hashIdx];

        U32 i;

        for (i = 0; i < cacheSize; i++) {

            hashTable[bucketIdx + i] = 0;

        }

        hashTable[bucketIdx + bucketSize - 1] = chainPackedPointer;

    }

    /* fill the buckets of the hash table */

    for (idx = ms->nextToUpdate; idx < target; idx++) {

        U32 const h = (U32)ZSTD_hashPtr(base + idx, hashLog, ms->cParams.minMatch)

                   << ZSTD_LAZY_DDSS_BUCKET_LOG;

        U32 i;

        /* Shift hash cache down 1. */

        for (i = cacheSize - 1; i; i--)

            hashTable[h + i] = hashTable[h + i - 1];

        hashTable[h] = idx;

    }

    ms->nextToUpdate = target;

}

/* Returns the longest match length found in the dedicated dict search structure.

 * If none are longer than the argument ml, then ml will be returned.

 */

FORCE_INLINE_TEMPLATE

size_t ZSTD_dedicatedDictSearch_lazy_search(size_t* offsetPtr, size_t ml, U32 nbAttempts,

                                            const ZSTD_matchState_t* const dms,

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

                                            const BYTE* const prefixStart, const U32 curr,

                                            const U32 dictLimit, const size_t ddsIdx) {

    const U32 ddsLowestIndex  = dms->window.dictLimit;

    const BYTE* const ddsBase = dms->window.base;

    const BYTE* const ddsEnd  = dms->window.nextSrc;

    const U32 ddsSize         = (U32)(ddsEnd - ddsBase);

    const U32 ddsIndexDelta   = dictLimit - ddsSize;

    const U32 bucketSize      = (1 << ZSTD_LAZY_DDSS_BUCKET_LOG);

    const U32 bucketLimit     = nbAttempts < bucketSize - 1 ? nbAttempts : bucketSize - 1;

    U32 ddsAttempt;

    U32 matchIndex;

    for (ddsAttempt = 0; ddsAttempt < bucketSize - 1; ddsAttempt++) {

        PREFETCH_L1(ddsBase + dms->hashTable[ddsIdx + ddsAttempt]);

    }

    {

        U32 const chainPackedPointer = dms->hashTable[ddsIdx + bucketSize - 1];

        U32 const chainIndex = chainPackedPointer >> 8;

        PREFETCH_L1(&dms->chainTable[chainIndex]);

    }

    for (ddsAttempt = 0; ddsAttempt < bucketLimit; ddsAttempt++) {

        size_t currentMl=0;

        const BYTE* match;

        matchIndex = dms->hashTable[ddsIdx + ddsAttempt];

        match = ddsBase + matchIndex;

        if (!matchIndex) {

            return ml;

        }

        /* guaranteed by table construction */

        (void)ddsLowestIndex;

        assert(matchIndex >= ddsLowestIndex);

        assert(match+4 <= ddsEnd);

        if (MEM_read32(match) == MEM_read32(ip)) {

            /* assumption : matchIndex <= dictLimit-4 (by table construction) */

            currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, ddsEnd, prefixStart) + 4;

        }

        /* save best solution */

        if (currentMl > ml) {

            ml = currentMl;

            *offsetPtr = OFFSET_TO_OFFBASE(curr - (matchIndex + ddsIndexDelta));

            if (ip+currentMl == iLimit) {

                /* best possible, avoids read overflow on next attempt */

                return ml;

            }

        }

    }

    {

        U32 const chainPackedPointer = dms->hashTable[ddsIdx + bucketSize - 1];

        U32 chainIndex = chainPackedPointer >> 8;

        U32 const chainLength = chainPackedPointer & 0xFF;

        U32 const chainAttempts = nbAttempts - ddsAttempt;

        U32 const chainLimit = chainAttempts > chainLength ? chainLength : chainAttempts;

        U32 chainAttempt;

        for (chainAttempt = 0 ; chainAttempt < chainLimit; chainAttempt++) {

            PREFETCH_L1(ddsBase + dms->chainTable[chainIndex + chainAttempt]);

        }

        for (chainAttempt = 0 ; chainAttempt < chainLimit; chainAttempt++, chainIndex++) {

            size_t currentMl=0;

            const BYTE* match;

            matchIndex = dms->chainTable[chainIndex];

            match = ddsBase + matchIndex;

            /* guaranteed by table construction */

            assert(matchIndex >= ddsLowestIndex);

            assert(match+4 <= ddsEnd);

            if (MEM_read32(match) == MEM_read32(ip)) {

                /* assumption : matchIndex <= dictLimit-4 (by table construction) */

                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, ddsEnd, prefixStart) + 4;

            }

            /* save best solution */

            if (currentMl > ml) {

                ml = currentMl;

                *offsetPtr = OFFSET_TO_OFFBASE(curr - (matchIndex + ddsIndexDelta));

                if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */

            }

        }

    }

    return ml;

}

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

*  Hash Chain

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

#define NEXT_IN_CHAIN(d, mask)   chainTable[(d) & (mask)]

/* Update chains up to ip (excluded)

   Assumption : always within prefix (i.e. not within extDict) */

FORCE_INLINE_TEMPLATE U32 ZSTD_insertAndFindFirstIndex_internal(

                        ZSTD_matchState_t* ms,

                        const ZSTD_compressionParameters* const cParams,

                        const BYTE* ip, U32 const mls, U32 const lazySkipping)

{

    U32* const hashTable  = ms->hashTable;

    const U32 hashLog = cParams->hashLog;

    U32* const chainTable = ms->chainTable;

    const U32 chainMask = (1 << cParams->chainLog) - 1;

    const BYTE* const base = ms->window.base;

    const U32 target = (U32)(ip - base);

    U32 idx = ms->nextToUpdate;

    while(idx < target) { /* catch up */

        size_t const h = ZSTD_hashPtr(base+idx, hashLog, mls);

        NEXT_IN_CHAIN(idx, chainMask) = hashTable[h];

        hashTable[h] = idx;

        idx++;

        /* Stop inserting every position when in the lazy skipping mode. */

        if (lazySkipping)

            break;

    }

    ms->nextToUpdate = target;

    return hashTable[ZSTD_hashPtr(ip, hashLog, mls)];

}

U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip) {

    const ZSTD_compressionParameters* const cParams = &ms->cParams;

    return ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, ms->cParams.minMatch, /* lazySkipping*/ 0);

}

/* inlining is important to hardwire a hot branch (template emulation) */

FORCE_INLINE_TEMPLATE

size_t ZSTD_HcFindBestMatch(

                        ZSTD_matchState_t* ms,

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

                        size_t* offsetPtr,

                        const U32 mls, const ZSTD_dictMode_e dictMode)

{

    const ZSTD_compressionParameters* const cParams = &ms->cParams;

    U32* const chainTable = ms->chainTable;

    const U32 chainSize = (1 << cParams->chainLog);

    const U32 chainMask = chainSize-1;

    const BYTE* const base = ms->window.base;

    const BYTE* const dictBase = ms->window.dictBase;

    const U32 dictLimit = ms->window.dictLimit;

    const BYTE* const prefixStart = base + dictLimit;

    const BYTE* const dictEnd = dictBase + dictLimit;

    const U32 curr = (U32)(ip-base);

    const U32 maxDistance = 1U << cParams->windowLog;

    const U32 lowestValid = ms->window.lowLimit;

    const U32 withinMaxDistance = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;

    const U32 isDictionary = (ms->loadedDictEnd != 0);

    const U32 lowLimit = isDictionary ? lowestValid : withinMaxDistance;

    const U32 minChain = curr > chainSize ? curr - chainSize : 0;

    U32 nbAttempts = 1U << cParams->searchLog;

    size_t ml=4-1;

    const ZSTD_matchState_t* const dms = ms->dictMatchState;

    const U32 ddsHashLog = dictMode == ZSTD_dedicatedDictSearch

                         ? dms->cParams.hashLog - ZSTD_LAZY_DDSS_BUCKET_LOG : 0;

    const size_t ddsIdx = dictMode == ZSTD_dedicatedDictSearch

                        ? ZSTD_hashPtr(ip, ddsHashLog, mls) << ZSTD_LAZY_DDSS_BUCKET_LOG : 0;

    U32 matchIndex;

    if (dictMode == ZSTD_dedicatedDictSearch) {

        const U32* entry = &dms->hashTable[ddsIdx];

        PREFETCH_L1(entry);

    }

    /* HC4 match finder */

    matchIndex = ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, mls, ms->lazySkipping);

    for ( ; (matchIndex>=lowLimit) & (nbAttempts>0) ; nbAttempts--) {

        size_t currentMl=0;

        if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) {

            const BYTE* const match = base + matchIndex;

            assert(matchIndex >= dictLimit);   /* ensures this is true if dictMode != ZSTD_extDict */

            /* read 4B starting from (match + ml + 1 - sizeof(U32)) */

            if (MEM_read32(match + ml - 3) == MEM_read32(ip + ml - 3))   /* potentially better */

                currentMl = ZSTD_count(ip, match, iLimit);

        } else {

            const BYTE* const match = dictBase + matchIndex;

            assert(match+4 <= dictEnd);

            if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */

                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dictEnd, prefixStart) + 4;

        }

        /* save best solution */

        if (currentMl > ml) {

            ml = currentMl;

            *offsetPtr = OFFSET_TO_OFFBASE(curr - matchIndex);

            if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */

        }

        if (matchIndex <= minChain) break;

        matchIndex = NEXT_IN_CHAIN(matchIndex, chainMask);

    }

    assert(nbAttempts <= (1U << ZSTD_SEARCHLOG_MAX)); /* Check we haven't underflowed. */

    if (dictMode == ZSTD_dedicatedDictSearch) {

        ml = ZSTD_dedicatedDictSearch_lazy_search(offsetPtr, ml, nbAttempts, dms,

                                                  ip, iLimit, prefixStart, curr, dictLimit, ddsIdx);

    } else if (dictMode == ZSTD_dictMatchState) {

        const U32* const dmsChainTable = dms->chainTable;

        const U32 dmsChainSize         = (1 << dms->cParams.chainLog);

        const U32 dmsChainMask         = dmsChainSize - 1;

        const U32 dmsLowestIndex       = dms->window.dictLimit;

        const BYTE* const dmsBase      = dms->window.base;

        const BYTE* const dmsEnd       = dms->window.nextSrc;

        const U32 dmsSize              = (U32)(dmsEnd - dmsBase);

        const U32 dmsIndexDelta        = dictLimit - dmsSize;

        const U32 dmsMinChain = dmsSize > dmsChainSize ? dmsSize - dmsChainSize : 0;

        matchIndex = dms->hashTable[ZSTD_hashPtr(ip, dms->cParams.hashLog, mls)];

        for ( ; (matchIndex>=dmsLowestIndex) & (nbAttempts>0) ; nbAttempts--) {

            size_t currentMl=0;

            const BYTE* const match = dmsBase + matchIndex;

            assert(match+4 <= dmsEnd);

            if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */

                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dmsEnd, prefixStart) + 4;

            /* save best solution */

            if (currentMl > ml) {

                ml = currentMl;

                assert(curr > matchIndex + dmsIndexDelta);

                *offsetPtr = OFFSET_TO_OFFBASE(curr - (matchIndex + dmsIndexDelta));

                if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */

            }

            if (matchIndex <= dmsMinChain) break;

            matchIndex = dmsChainTable[matchIndex & dmsChainMask];

        }

    }

    return ml;

}

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

* (SIMD) Row-based matchfinder

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

/* Constants for row-based hash */

#define ZSTD_ROW_HASH_TAG_MASK ((1u << ZSTD_ROW_HASH_TAG_BITS) - 1)

#define ZSTD_ROW_HASH_MAX_ENTRIES 64    /* absolute maximum number of entries per row, for all configurations */

#define ZSTD_ROW_HASH_CACHE_MASK (ZSTD_ROW_HASH_CACHE_SIZE - 1)

typedef U64 ZSTD_VecMask;   /* Clarifies when we are interacting with a U64 representing a mask of matches */

/* ZSTD_VecMask_next():

 * Starting from the LSB, returns the idx of the next non-zero bit.

 * Basically counting the nb of trailing zeroes.

 */

MEM_STATIC U32 ZSTD_VecMask_next(ZSTD_VecMask val) {

    return ZSTD_countTrailingZeros64(val);

}

/* ZSTD_row_nextIndex():

 * Returns the next index to insert at within a tagTable row, and updates the "head"

 * value to reflect the update. Essentially cycles backwards from [1, {entries per row})

 */

FORCE_INLINE_TEMPLATE U32 ZSTD_row_nextIndex(BYTE* const tagRow, U32 const rowMask) {

    U32 next = (*tagRow-1) & rowMask;

    next += (next == 0) ? rowMask : 0; /* skip first position */

    *tagRow = (BYTE)next;

    return next;

}

/* ZSTD_isAligned():

 * Checks that a pointer is aligned to "align" bytes which must be a power of 2.

 */

MEM_STATIC int ZSTD_isAligned(void const* ptr, size_t align) {

    assert((align & (align - 1)) == 0);

    return (((size_t)ptr) & (align - 1)) == 0;

}

/* ZSTD_row_prefetch():

 * Performs prefetching for the hashTable and tagTable at a given row.

 */

FORCE_INLINE_TEMPLATE void ZSTD_row_prefetch(U32 const* hashTable, BYTE const* tagTable, U32 const relRow, U32 const rowLog) {

    PREFETCH_L1(hashTable + relRow);

    if (rowLog >= 5) {

        PREFETCH_L1(hashTable + relRow + 16);

        /* Note: prefetching more of the hash table does not appear to be beneficial for 128-entry rows */

    }

    PREFETCH_L1(tagTable + relRow);

    if (rowLog == 6) {

        PREFETCH_L1(tagTable + relRow + 32);

    }

    assert(rowLog == 4 || rowLog == 5 || rowLog == 6);

    assert(ZSTD_isAligned(hashTable + relRow, 64));                 /* prefetched hash row always 64-byte aligned */

    assert(ZSTD_isAligned(tagTable + relRow, (size_t)1 << rowLog)); /* prefetched tagRow sits on correct multiple of bytes (32,64,128) */

}

/* ZSTD_row_fillHashCache():

 * Fill up the hash cache starting at idx, prefetching up to ZSTD_ROW_HASH_CACHE_SIZE entries,

 * but not beyond iLimit.

 */

FORCE_INLINE_TEMPLATE void ZSTD_row_fillHashCache(ZSTD_matchState_t* ms, const BYTE* base,

                                   U32 const rowLog, U32 const mls,

                                   U32 idx, const BYTE* const iLimit)

{

    U32 const* const hashTable = ms->hashTable;

    BYTE const* const tagTable = ms->tagTable;

    U32 const hashLog = ms->rowHashLog;

    U32 const maxElemsToPrefetch = (base + idx) > iLimit ? 0 : (U32)(iLimit - (base + idx) + 1);

    U32 const lim = idx + MIN(ZSTD_ROW_HASH_CACHE_SIZE, maxElemsToPrefetch);

    for (; idx < lim; ++idx) {

        U32 const hash = (U32)ZSTD_hashPtrSalted(base + idx, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, ms->hashSalt);

        U32 const row = (hash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;

        ZSTD_row_prefetch(hashTable, tagTable, row, rowLog);

        ms->hashCache[idx & ZSTD_ROW_HASH_CACHE_MASK] = hash;

    }

    DEBUGLOG(6, "ZSTD_row_fillHashCache(): [%u %u %u %u %u %u %u %u]", ms->hashCache[0], ms->hashCache[1],

                                                     ms->hashCache[2], ms->hashCache[3], ms->hashCache[4],

                                                     ms->hashCache[5], ms->hashCache[6], ms->hashCache[7]);

}

/* ZSTD_row_nextCachedHash():

 * Returns the hash of base + idx, and replaces the hash in the hash cache with the byte at

 * base + idx + ZSTD_ROW_HASH_CACHE_SIZE. Also prefetches the appropriate rows from hashTable and tagTable.

 */

FORCE_INLINE_TEMPLATE U32 ZSTD_row_nextCachedHash(U32* cache, U32 const* hashTable,

                                                  BYTE const* tagTable, BYTE const* base,

                                                  U32 idx, U32 const hashLog,

                                                  U32 const rowLog, U32 const mls,

                                                  U64 const hashSalt)

{

    U32 const newHash = (U32)ZSTD_hashPtrSalted(base+idx+ZSTD_ROW_HASH_CACHE_SIZE, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, hashSalt);

    U32 const row = (newHash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;

    ZSTD_row_prefetch(hashTable, tagTable, row, rowLog);

    {   U32 const hash = cache[idx & ZSTD_ROW_HASH_CACHE_MASK];

        cache[idx & ZSTD_ROW_HASH_CACHE_MASK] = newHash;

        return hash;

    }

}

/* ZSTD_row_update_internalImpl():

 * Updates the hash table with positions starting from updateStartIdx until updateEndIdx.

 */

FORCE_INLINE_TEMPLATE void ZSTD_row_update_internalImpl(ZSTD_matchState_t* ms,

                                                        U32 updateStartIdx, U32 const updateEndIdx,