/**

 * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.

 * All rights reserved.

 *

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

 * LICENSE file in the root directory of this source tree. An additional grant

 * of patent rights can be found in the PATENTS file in the same directory.

 */

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

*  Dependencies

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

#include <string.h>         /* memset */

#include "mem.h"

#define XXH_STATIC_LINKING_ONLY   /* XXH64_state_t */

#include "xxhash.h"               /* XXH_reset, update, digest */

#define FSE_STATIC_LINKING_ONLY   /* FSE_encodeSymbol */

#include "fse.h"

#define HUF_STATIC_LINKING_ONLY

#include "huf.h"

#include "zstd_internal.h"  /* includes zstd.h */

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

*  Constants

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

static const U32 g_searchStrength = 8;   /* control skip over incompressible data */

#define HASH_READ_SIZE 8

typedef enum { ZSTDcs_created=0, ZSTDcs_init, ZSTDcs_ongoing, ZSTDcs_ending } ZSTD_compressionStage_e;

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

*  Helper functions

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

size_t ZSTD_compressBound(size_t srcSize) { return FSE_compressBound(srcSize) + 12; }

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

*  Sequence storage

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

static void ZSTD_resetSeqStore(seqStore_t* ssPtr)

{

    ssPtr->lit = ssPtr->litStart;

    ssPtr->sequences = ssPtr->sequencesStart;

    ssPtr->longLengthID = 0;

}

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

*  Context memory management

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

struct ZSTD_CCtx_s

{

    const BYTE* nextSrc;    /* next block here to continue on current prefix */

    const BYTE* base;       /* All regular indexes relative to this position */

    const BYTE* dictBase;   /* extDict indexes relative to this position */

    U32   dictLimit;        /* below that point, need extDict */

    U32   lowLimit;         /* below that point, no more data */

    U32   nextToUpdate;     /* index from which to continue dictionary update */

    U32   nextToUpdate3;    /* index from which to continue dictionary update */

    U32   hashLog3;         /* dispatch table : larger == faster, more memory */

    U32   loadedDictEnd;

    ZSTD_compressionStage_e stage;

    U32   rep[ZSTD_REP_NUM];

    U32   savedRep[ZSTD_REP_NUM];

    U32   dictID;

    ZSTD_parameters params;

    void* workSpace;

    size_t workSpaceSize;

    size_t blockSize;

    U64 frameContentSize;

    XXH64_state_t xxhState;

    ZSTD_customMem customMem;

    seqStore_t seqStore;    /* sequences storage ptrs */

    U32* hashTable;

    U32* hashTable3;

    U32* chainTable;

    HUF_CElt* hufTable;

    U32 flagStaticTables;

    FSE_CTable offcodeCTable  [FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)];

    FSE_CTable matchlengthCTable[FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)];

    FSE_CTable litlengthCTable  [FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)];

};

ZSTD_CCtx* ZSTD_createCCtx(void)

{

    return ZSTD_createCCtx_advanced(defaultCustomMem);

}

ZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem)

{

    ZSTD_CCtx* cctx;

    if (!customMem.customAlloc && !customMem.customFree) customMem = defaultCustomMem;

    if (!customMem.customAlloc || !customMem.customFree) return NULL;

    cctx = (ZSTD_CCtx*) ZSTD_malloc(sizeof(ZSTD_CCtx), customMem);

    if (!cctx) return NULL;

    memset(cctx, 0, sizeof(ZSTD_CCtx));

    memcpy(&(cctx->customMem), &customMem, sizeof(customMem));

    return cctx;

}

size_t ZSTD_freeCCtx(ZSTD_CCtx* cctx)

{

    if (cctx==NULL) return 0;   /* support free on NULL */

    ZSTD_free(cctx->workSpace, cctx->customMem);

    ZSTD_free(cctx, cctx->customMem);

    return 0;   /* reserved as a potential error code in the future */

}

size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx)

{

    if (cctx==NULL) return 0;   /* support sizeof on NULL */

    return sizeof(*cctx) + cctx->workSpaceSize;

}

const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx)   /* hidden interface */

{

    return &(ctx->seqStore);

}

static ZSTD_parameters ZSTD_getParamsFromCCtx(const ZSTD_CCtx* cctx)

{

    return cctx->params;

}

/** ZSTD_checkParams() :

    ensure param values remain within authorized range.

    @return : 0, or an error code if one value is beyond authorized range */

size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)

{

#   define CLAMPCHECK(val,min,max) { if ((val<min) | (val>max)) return ERROR(compressionParameter_unsupported); }

    CLAMPCHECK(cParams.windowLog, ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX);

    CLAMPCHECK(cParams.chainLog, ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX);

    CLAMPCHECK(cParams.hashLog, ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX);

    CLAMPCHECK(cParams.searchLog, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX);

    { U32 const searchLengthMin = ((cParams.strategy == ZSTD_fast) | (cParams.strategy == ZSTD_greedy)) ? ZSTD_SEARCHLENGTH_MIN+1 : ZSTD_SEARCHLENGTH_MIN;

      U32 const searchLengthMax = (cParams.strategy == ZSTD_fast) ? ZSTD_SEARCHLENGTH_MAX : ZSTD_SEARCHLENGTH_MAX-1;

      CLAMPCHECK(cParams.searchLength, searchLengthMin, searchLengthMax); }

    CLAMPCHECK(cParams.targetLength, ZSTD_TARGETLENGTH_MIN, ZSTD_TARGETLENGTH_MAX);

    if ((U32)(cParams.strategy) > (U32)ZSTD_btopt2) return ERROR(compressionParameter_unsupported);

    return 0;

}

/** ZSTD_adjustCParams() :

    optimize `cPar` for a given input (`srcSize` and `dictSize`).

    mostly downsizing to reduce memory consumption and initialization.

    Both `srcSize` and `dictSize` are optional (use 0 if unknown),

    but if both are 0, no optimization can be done.

    Note : cPar is considered validated at this stage. Use ZSTD_checkParams() to ensure that. */

ZSTD_compressionParameters ZSTD_adjustCParams(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize)

{

    if (srcSize+dictSize == 0) return cPar;   /* no size information available : no adjustment */

    /* resize params, to use less memory when necessary */

    {   U32 const minSrcSize = (srcSize==0) ? 500 : 0;

        U64 const rSize = srcSize + dictSize + minSrcSize;

        if (rSize < ((U64)1<<ZSTD_WINDOWLOG_MAX)) {

            U32 const srcLog = MAX(ZSTD_HASHLOG_MIN, ZSTD_highbit32((U32)(rSize)-1) + 1);

            if (cPar.windowLog > srcLog) cPar.windowLog = srcLog;

    }   }

    if (cPar.hashLog > cPar.windowLog) cPar.hashLog = cPar.windowLog;

    if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN) cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* required for frame header */

    return cPar;

}

size_t ZSTD_estimateCCtxSize(ZSTD_compressionParameters cParams)

{

    size_t const blockSize = MIN(ZSTD_BLOCKSIZE_ABSOLUTEMAX, (size_t)1 << cParams.windowLog);

    U32    const divider = (cParams.searchLength==3) ? 3 : 4;

    size_t const maxNbSeq = blockSize / divider;

    size_t const tokenSpace = blockSize + 11*maxNbSeq;

    size_t const chainSize = (cParams.strategy == ZSTD_fast) ? 0 : (1 << cParams.chainLog);

    size_t const hSize = ((size_t)1) << cParams.hashLog;

    U32    const hashLog3 = (cParams.searchLength>3) ? 0 : MIN(ZSTD_HASHLOG3_MAX, cParams.windowLog);

    size_t const h3Size = ((size_t)1) << hashLog3;

    size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);

    size_t const optSpace = ((MaxML+1) + (MaxLL+1) + (MaxOff+1) + (1<<Litbits))*sizeof(U32)

                          + (ZSTD_OPT_NUM+1)*(sizeof(ZSTD_match_t) + sizeof(ZSTD_optimal_t));

    size_t const neededSpace = tableSpace + (256*sizeof(U32)) /* huffTable */ + tokenSpace

                             + (((cParams.strategy == ZSTD_btopt) || (cParams.strategy == ZSTD_btopt2)) ? optSpace : 0);

    return sizeof(ZSTD_CCtx) + neededSpace;

}

static U32 ZSTD_equivalentParams(ZSTD_parameters param1, ZSTD_parameters param2)

{

    return (param1.cParams.hashLog  == param2.cParams.hashLog)

         & (param1.cParams.chainLog == param2.cParams.chainLog)

         & (param1.cParams.strategy == param2.cParams.strategy)

         & ((param1.cParams.searchLength==3) == (param2.cParams.searchLength==3));

}

/*! ZSTD_continueCCtx() :

    reuse CCtx without reset (note : requires no dictionary) */

static size_t ZSTD_continueCCtx(ZSTD_CCtx* cctx, ZSTD_parameters params, U64 frameContentSize)

{

    U32 const end = (U32)(cctx->nextSrc - cctx->base);

    cctx->params = params;

    cctx->frameContentSize = frameContentSize;

    cctx->lowLimit = end;

    cctx->dictLimit = end;

    cctx->nextToUpdate = end+1;

    cctx->stage = ZSTDcs_init;

    cctx->dictID = 0;

    cctx->loadedDictEnd = 0;

    { int i; for (i=0; i<ZSTD_REP_NUM; i++) cctx->rep[i] = repStartValue[i]; }

    cctx->seqStore.litLengthSum = 0;  /* force reset of btopt stats */

    XXH64_reset(&cctx->xxhState, 0);

    return 0;

}

typedef enum { ZSTDcrp_continue, ZSTDcrp_noMemset, ZSTDcrp_fullReset } ZSTD_compResetPolicy_e;

/*! ZSTD_resetCCtx_advanced() :

    note : 'params' must be validated */

static size_t ZSTD_resetCCtx_advanced (ZSTD_CCtx* zc,

                                       ZSTD_parameters params, U64 frameContentSize,

                                       ZSTD_compResetPolicy_e const crp)

{

    if (crp == ZSTDcrp_continue)

        if (ZSTD_equivalentParams(params, zc->params))

            return ZSTD_continueCCtx(zc, params, frameContentSize);

    {   size_t const blockSize = MIN(ZSTD_BLOCKSIZE_ABSOLUTEMAX, (size_t)1 << params.cParams.windowLog);

        U32    const divider = (params.cParams.searchLength==3) ? 3 : 4;

        size_t const maxNbSeq = blockSize / divider;

        size_t const tokenSpace = blockSize + 11*maxNbSeq;

        size_t const chainSize = (params.cParams.strategy == ZSTD_fast) ? 0 : (1 << params.cParams.chainLog);

        size_t const hSize = ((size_t)1) << params.cParams.hashLog;

        U32    const hashLog3 = (params.cParams.searchLength>3) ? 0 : MIN(ZSTD_HASHLOG3_MAX, params.cParams.windowLog);

        size_t const h3Size = ((size_t)1) << hashLog3;

        size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);

        void* ptr;

        /* Check if workSpace is large enough, alloc a new one if needed */

        {   size_t const optSpace = ((MaxML+1) + (MaxLL+1) + (MaxOff+1) + (1<<Litbits))*sizeof(U32)

                                  + (ZSTD_OPT_NUM+1)*(sizeof(ZSTD_match_t) + sizeof(ZSTD_optimal_t));

            size_t const neededSpace = tableSpace + (256*sizeof(U32)) /* huffTable */ + tokenSpace

                                  + (((params.cParams.strategy == ZSTD_btopt) || (params.cParams.strategy == ZSTD_btopt2)) ? optSpace : 0);

            if (zc->workSpaceSize < neededSpace) {

                ZSTD_free(zc->workSpace, zc->customMem);

                zc->workSpace = ZSTD_malloc(neededSpace, zc->customMem);

                if (zc->workSpace == NULL) return ERROR(memory_allocation);

                zc->workSpaceSize = neededSpace;

        }   }

        if (crp!=ZSTDcrp_noMemset) memset(zc->workSpace, 0, tableSpace);   /* reset tables only */

        XXH64_reset(&zc->xxhState, 0);

        zc->hashLog3 = hashLog3;

        zc->hashTable = (U32*)(zc->workSpace);

        zc->chainTable = zc->hashTable + hSize;

        zc->hashTable3 = zc->chainTable + chainSize;

        ptr = zc->hashTable3 + h3Size;

        zc->hufTable = (HUF_CElt*)ptr;

        zc->flagStaticTables = 0;

        ptr = ((U32*)ptr) + 256;  /* note : HUF_CElt* is incomplete type, size is simulated using U32 */

        zc->nextToUpdate = 1;

        zc->nextSrc = NULL;

        zc->base = NULL;

        zc->dictBase = NULL;

        zc->dictLimit = 0;

        zc->lowLimit = 0;

        zc->params = params;

        zc->blockSize = blockSize;

        zc->frameContentSize = frameContentSize;

        { int i; for (i=0; i<ZSTD_REP_NUM; i++) zc->rep[i] = repStartValue[i]; }

        if ((params.cParams.strategy == ZSTD_btopt) || (params.cParams.strategy == ZSTD_btopt2)) {

            zc->seqStore.litFreq = (U32*)ptr;

            zc->seqStore.litLengthFreq = zc->seqStore.litFreq + (1<<Litbits);

            zc->seqStore.matchLengthFreq = zc->seqStore.litLengthFreq + (MaxLL+1);

            zc->seqStore.offCodeFreq = zc->seqStore.matchLengthFreq + (MaxML+1);

            ptr = zc->seqStore.offCodeFreq + (MaxOff+1);

            zc->seqStore.matchTable = (ZSTD_match_t*)ptr;

            ptr = zc->seqStore.matchTable + ZSTD_OPT_NUM+1;

            zc->seqStore.priceTable = (ZSTD_optimal_t*)ptr;

            ptr = zc->seqStore.priceTable + ZSTD_OPT_NUM+1;

            zc->seqStore.litLengthSum = 0;

        }

        zc->seqStore.sequencesStart = (seqDef*)ptr;

        ptr = zc->seqStore.sequencesStart + maxNbSeq;

        zc->seqStore.llCode = (BYTE*) ptr;

        zc->seqStore.mlCode = zc->seqStore.llCode + maxNbSeq;

        zc->seqStore.ofCode = zc->seqStore.mlCode + maxNbSeq;

        zc->seqStore.litStart = zc->seqStore.ofCode + maxNbSeq;

        zc->stage = ZSTDcs_init;

        zc->dictID = 0;

        zc->loadedDictEnd = 0;

        return 0;

    }

}

/*! ZSTD_copyCCtx() :

*   Duplicate an existing context `srcCCtx` into another one `dstCCtx`.

*   Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()).

*   @return : 0, or an error code */

size_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx, unsigned long long pledgedSrcSize)

{

    if (srcCCtx->stage!=ZSTDcs_init) return ERROR(stage_wrong);

    memcpy(&dstCCtx->customMem, &srcCCtx->customMem, sizeof(ZSTD_customMem));

    ZSTD_resetCCtx_advanced(dstCCtx, srcCCtx->params, pledgedSrcSize, ZSTDcrp_noMemset);

    /* copy tables */

    {   size_t const chainSize = (srcCCtx->params.cParams.strategy == ZSTD_fast) ? 0 : (1 << srcCCtx->params.cParams.chainLog);

        size_t const hSize = ((size_t)1) << srcCCtx->params.cParams.hashLog;

        size_t const h3Size = (size_t)1 << srcCCtx->hashLog3;

        size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);

        memcpy(dstCCtx->workSpace, srcCCtx->workSpace, tableSpace);

    }

    /* copy dictionary offsets */

    dstCCtx->nextToUpdate = srcCCtx->nextToUpdate;

    dstCCtx->nextToUpdate3= srcCCtx->nextToUpdate3;

    dstCCtx->nextSrc      = srcCCtx->nextSrc;

    dstCCtx->base         = srcCCtx->base;

    dstCCtx->dictBase     = srcCCtx->dictBase;

    dstCCtx->dictLimit    = srcCCtx->dictLimit;

    dstCCtx->lowLimit     = srcCCtx->lowLimit;

    dstCCtx->loadedDictEnd= srcCCtx->loadedDictEnd;

    dstCCtx->dictID       = srcCCtx->dictID;

    /* copy entropy tables */

    dstCCtx->flagStaticTables = srcCCtx->flagStaticTables;

    if (srcCCtx->flagStaticTables) {

        memcpy(dstCCtx->hufTable, srcCCtx->hufTable, 256*4);

        memcpy(dstCCtx->litlengthCTable, srcCCtx->litlengthCTable, sizeof(dstCCtx->litlengthCTable));

        memcpy(dstCCtx->matchlengthCTable, srcCCtx->matchlengthCTable, sizeof(dstCCtx->matchlengthCTable));

        memcpy(dstCCtx->offcodeCTable, srcCCtx->offcodeCTable, sizeof(dstCCtx->offcodeCTable));

    }

    return 0;

}

/*! ZSTD_reduceTable() :

*   reduce table indexes by `reducerValue` */

static void ZSTD_reduceTable (U32* const table, U32 const size, U32 const reducerValue)

{

    U32 u;

    for (u=0 ; u < size ; u++) {

        if (table[u] < reducerValue) table[u] = 0;

        else table[u] -= reducerValue;

    }

}

/*! ZSTD_reduceIndex() :

*   rescale all indexes to avoid future overflow (indexes are U32) */

static void ZSTD_reduceIndex (ZSTD_CCtx* zc, const U32 reducerValue)

{

    { U32 const hSize = 1 << zc->params.cParams.hashLog;

      ZSTD_reduceTable(zc->hashTable, hSize, reducerValue); }

    { U32 const chainSize = (zc->params.cParams.strategy == ZSTD_fast) ? 0 : (1 << zc->params.cParams.chainLog);

      ZSTD_reduceTable(zc->chainTable, chainSize, reducerValue); }

    { U32 const h3Size = (zc->hashLog3) ? 1 << zc->hashLog3 : 0;

      ZSTD_reduceTable(zc->hashTable3, h3Size, reducerValue); }

}

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

*  Block entropic compression

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

/* See doc/zstd_compression_format.md for detailed format description */

size_t ZSTD_noCompressBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize)

{

    if (srcSize + ZSTD_blockHeaderSize > dstCapacity) return ERROR(dstSize_tooSmall);

    memcpy((BYTE*)dst + ZSTD_blockHeaderSize, src, srcSize);

    MEM_writeLE24(dst, (U32)(srcSize << 2) + (U32)bt_raw);

    return ZSTD_blockHeaderSize+srcSize;

}

static size_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize)

{

    BYTE* const ostart = (BYTE* const)dst;

    U32   const flSize = 1 + (srcSize>31) + (srcSize>4095);

    if (srcSize + flSize > dstCapacity) return ERROR(dstSize_tooSmall);

    switch(flSize)

    {

        case 1: /* 2 - 1 - 5 */

            ostart[0] = (BYTE)((U32)set_basic + (srcSize<<3));

            break;

        case 2: /* 2 - 2 - 12 */

            MEM_writeLE16(ostart, (U16)((U32)set_basic + (1<<2) + (srcSize<<4)));

            break;

        default:   /*note : should not be necessary : flSize is within {1,2,3} */

        case 3: /* 2 - 2 - 20 */

            MEM_writeLE32(ostart, (U32)((U32)set_basic + (3<<2) + (srcSize<<4)));

            break;

    }

    memcpy(ostart + flSize, src, srcSize);

    return srcSize + flSize;

}

static size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize)

{

    BYTE* const ostart = (BYTE* const)dst;

    U32   const flSize = 1 + (srcSize>31) + (srcSize>4095);

    (void)dstCapacity;  /* dstCapacity already guaranteed to be >=4, hence large enough */

    switch(flSize)

    {

        case 1: /* 2 - 1 - 5 */

            ostart[0] = (BYTE)((U32)set_rle + (srcSize<<3));

            break;

        case 2: /* 2 - 2 - 12 */

            MEM_writeLE16(ostart, (U16)((U32)set_rle + (1<<2) + (srcSize<<4)));

            break;

        default:   /*note : should not be necessary : flSize is necessarily within {1,2,3} */

        case 3: /* 2 - 2 - 20 */

            MEM_writeLE32(ostart, (U32)((U32)set_rle + (3<<2) + (srcSize<<4)));

            break;

    }

    ostart[flSize] = *(const BYTE*)src;

    return flSize+1;

}

static size_t ZSTD_minGain(size_t srcSize) { return (srcSize >> 6) + 2; }

static size_t ZSTD_compressLiterals (ZSTD_CCtx* zc,

                                     void* dst, size_t dstCapacity,

                               const void* src, size_t srcSize)

{

    size_t const minGain = ZSTD_minGain(srcSize);

    size_t const lhSize = 3 + (srcSize >= 1 KB) + (srcSize >= 16 KB);

    BYTE*  const ostart = (BYTE*)dst;

    U32 singleStream = srcSize < 256;

    symbolEncodingType_e hType = set_compressed;

    size_t cLitSize;

    /* small ? don't even attempt compression (speed opt) */

#   define LITERAL_NOENTROPY 63

    {   size_t const minLitSize = zc->flagStaticTables ? 6 : LITERAL_NOENTROPY;

        if (srcSize <= minLitSize) return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);

    }

    if (dstCapacity < lhSize+1) return ERROR(dstSize_tooSmall);   /* not enough space for compression */

    if (zc->flagStaticTables && (lhSize==3)) {

        hType = set_repeat;

        singleStream = 1;

        cLitSize = HUF_compress1X_usingCTable(ostart+lhSize, dstCapacity-lhSize, src, srcSize, zc->hufTable);

    } else {

    }

    if ((cLitSize==0) | (cLitSize >= srcSize - minGain))

        return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);

    if (cLitSize==1)

        return ZSTD_compressRleLiteralsBlock(dst, dstCapacity, src, srcSize);

    /* Build header */

    switch(lhSize)

    {

    case 3: /* 2 - 2 - 10 - 10 */

        {   U32 const lhc = hType + ((!singleStream) << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<14);

            MEM_writeLE24(ostart, lhc);

            break;

        }

    case 4: /* 2 - 2 - 14 - 14 */

        {   U32 const lhc = hType + (2 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<18);

            MEM_writeLE32(ostart, lhc);

            break;

        }

    default:   /* should not be necessary, lhSize is only {3,4,5} */

    case 5: /* 2 - 2 - 18 - 18 */

        {   U32 const lhc = hType + (3 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<22);

            MEM_writeLE32(ostart, lhc);

            ostart[4] = (BYTE)(cLitSize >> 10);

            break;

        }

    }

    return lhSize+cLitSize;

}

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 };

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,