Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

1 files changed, 570 insertions, 570 deletions

diff --git a/contrib/libs/zstd/lib/compress/zstd_compress_internal.h b/contrib/libs/zstd/lib/compress/zstd_compress_internal.h
index 4a493f015ed..c406e794bdb 100644
--- a/contrib/libs/zstd/lib/compress/zstd_compress_internal.h
+++ b/contrib/libs/zstd/lib/compress/zstd_compress_internal.h
@@ -1,60 +1,60 @@
-/* 
+/*
  * Copyright (c) Yann Collet, Facebook, Inc.
- * 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. 
- */ 
- 
-/* This header contains definitions 
- * that shall **only** be used by modules within lib/compress. 
- */ 
- 
-#ifndef ZSTD_COMPRESS_H 
-#define ZSTD_COMPRESS_H 
- 
-/*-************************************* 
-*  Dependencies 
-***************************************/ 
+ * 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.
+ */
+
+/* This header contains definitions
+ * that shall **only** be used by modules within lib/compress.
+ */
+
+#ifndef ZSTD_COMPRESS_H
+#define ZSTD_COMPRESS_H
+
+/*-*************************************
+*  Dependencies
+***************************************/
 #include "../common/zstd_internal.h"
 #include "zstd_cwksp.h"
-#ifdef ZSTD_MULTITHREAD 
-#  include "zstdmt_compress.h" 
-#endif 
- 
-#if defined (__cplusplus) 
-extern "C" { 
-#endif 
- 
-/*-************************************* 
-*  Constants 
-***************************************/ 
-#define kSearchStrength      8 
-#define HASH_READ_SIZE       8 
+#ifdef ZSTD_MULTITHREAD
+#  include "zstdmt_compress.h"
+#endif
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/*-*************************************
+*  Constants
+***************************************/
+#define kSearchStrength      8
+#define HASH_READ_SIZE       8
 #define ZSTD_DUBT_UNSORTED_MARK 1   /* For btlazy2 strategy, index ZSTD_DUBT_UNSORTED_MARK==1 means "unsorted".
-                                       It could be confused for a real successor at index "1", if sorted as larger than its predecessor. 
-                                       It's not a big deal though : candidate will just be sorted again. 
+                                       It could be confused for a real successor at index "1", if sorted as larger than its predecessor.
+                                       It's not a big deal though : candidate will just be sorted again.
                                        Additionally, candidate position 1 will be lost.
-                                       But candidate 1 cannot hide a large tree of candidates, so it's a minimal loss. 
+                                       But candidate 1 cannot hide a large tree of candidates, so it's a minimal loss.
                                        The benefit is that ZSTD_DUBT_UNSORTED_MARK cannot be mishandled after table re-use with a different strategy.
                                        This constant is required by ZSTD_compressBlock_btlazy2() and ZSTD_reduceTable_internal() */
- 
- 
-/*-************************************* 
-*  Context memory management 
-***************************************/ 
-typedef enum { ZSTDcs_created=0, ZSTDcs_init, ZSTDcs_ongoing, ZSTDcs_ending } ZSTD_compressionStage_e; 
-typedef enum { zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage; 
- 
-typedef struct ZSTD_prefixDict_s { 
-    const void* dict; 
-    size_t dictSize; 
-    ZSTD_dictContentType_e dictContentType; 
-} ZSTD_prefixDict; 
- 
-typedef struct { 
+
+
+/*-*************************************
+*  Context memory management
+***************************************/
+typedef enum { ZSTDcs_created=0, ZSTDcs_init, ZSTDcs_ongoing, ZSTDcs_ending } ZSTD_compressionStage_e;
+typedef enum { zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage;
+
+typedef struct ZSTD_prefixDict_s {
+    const void* dict;
+    size_t dictSize;
+    ZSTD_dictContentType_e dictContentType;
+} ZSTD_prefixDict;
+
+typedef struct {
     void* dictBuffer;
     void const* dict;
     size_t dictSize;
@@ -68,19 +68,19 @@ typedef struct {
 } ZSTD_hufCTables_t;
 
 typedef struct {
-    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)]; 
-    FSE_repeat offcode_repeatMode; 
-    FSE_repeat matchlength_repeatMode; 
-    FSE_repeat litlength_repeatMode; 
+    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)];
+    FSE_repeat offcode_repeatMode;
+    FSE_repeat matchlength_repeatMode;
+    FSE_repeat litlength_repeatMode;
 } ZSTD_fseCTables_t;
 
 typedef struct {
     ZSTD_hufCTables_t huf;
     ZSTD_fseCTables_t fse;
-} ZSTD_entropyCTables_t; 
- 
+} ZSTD_entropyCTables_t;
+
 /***********************************************
 *  Entropy buffer statistics structs and funcs *
 ***********************************************/
@@ -89,7 +89,7 @@ typedef struct {
  *  huffman tree description in hufDesBuffer.
  *  hufDesSize refers to the size of huffman tree description in bytes.
  *  This metadata is populated in ZSTD_buildBlockEntropyStats_literals() */
-typedef struct { 
+typedef struct {
     symbolEncodingType_e hType;
     BYTE hufDesBuffer[ZSTD_MAX_HUF_HEADER_SIZE];
     size_t hufDesSize;
@@ -131,9 +131,9 @@ size_t ZSTD_buildBlockEntropyStats(seqStore_t* seqStorePtr,
 typedef struct {
     U32 off;            /* Offset sumtype code for the match, using ZSTD_storeSeq() format */
     U32 len;            /* Raw length of match */
-} ZSTD_match_t; 
- 
-typedef struct { 
+} ZSTD_match_t;
+
+typedef struct {
     U32 offset;         /* Offset of sequence */
     U32 litLength;      /* Length of literals prior to match */
     U32 matchLength;    /* Raw length of match */
@@ -151,28 +151,28 @@ typedef struct {
 UNUSED_ATTR static const rawSeqStore_t kNullRawSeqStore = {NULL, 0, 0, 0, 0};
 
 typedef struct {
-    int price; 
-    U32 off; 
-    U32 mlen; 
-    U32 litlen; 
-    U32 rep[ZSTD_REP_NUM]; 
-} ZSTD_optimal_t; 
- 
+    int price;
+    U32 off;
+    U32 mlen;
+    U32 litlen;
+    U32 rep[ZSTD_REP_NUM];
+} ZSTD_optimal_t;
+
 typedef enum { zop_dynamic=0, zop_predef } ZSTD_OptPrice_e;
 
-typedef struct { 
-    /* All tables are allocated inside cctx->workspace by ZSTD_resetCCtx_internal() */ 
+typedef struct {
+    /* All tables are allocated inside cctx->workspace by ZSTD_resetCCtx_internal() */
     unsigned* litFreq;           /* table of literals statistics, of size 256 */
     unsigned* litLengthFreq;     /* table of litLength statistics, of size (MaxLL+1) */
     unsigned* matchLengthFreq;   /* table of matchLength statistics, of size (MaxML+1) */
     unsigned* offCodeFreq;       /* table of offCode statistics, of size (MaxOff+1) */
     ZSTD_match_t* matchTable;    /* list of found matches, of size ZSTD_OPT_NUM+1 */
     ZSTD_optimal_t* priceTable;  /* All positions tracked by optimal parser, of size ZSTD_OPT_NUM+1 */
- 
-    U32  litSum;                 /* nb of literals */ 
-    U32  litLengthSum;           /* nb of litLength codes */ 
-    U32  matchLengthSum;         /* nb of matchLength codes */ 
-    U32  offCodeSum;             /* nb of offset codes */ 
+
+    U32  litSum;                 /* nb of literals */
+    U32  litLengthSum;           /* nb of litLength codes */
+    U32  matchLengthSum;         /* nb of matchLength codes */
+    U32  offCodeSum;             /* nb of offset codes */
     U32  litSumBasePrice;        /* to compare to log2(litfreq) */
     U32  litLengthSumBasePrice;  /* to compare to log2(llfreq)  */
     U32  matchLengthSumBasePrice;/* to compare to log2(mlfreq)  */
@@ -180,14 +180,14 @@ typedef struct {
     ZSTD_OptPrice_e priceType;   /* prices can be determined dynamically, or follow a pre-defined cost structure */
     const ZSTD_entropyCTables_t* symbolCosts;  /* pre-calculated dictionary statistics */
     ZSTD_paramSwitch_e literalCompressionMode;
-} optState_t; 
- 
-typedef struct { 
-  ZSTD_entropyCTables_t entropy; 
-  U32 rep[ZSTD_REP_NUM]; 
-} ZSTD_compressedBlockState_t; 
- 
-typedef struct { 
+} optState_t;
+
+typedef struct {
+  ZSTD_entropyCTables_t entropy;
+  U32 rep[ZSTD_REP_NUM];
+} ZSTD_compressedBlockState_t;
+
+typedef struct {
     BYTE const* nextSrc;       /* next block here to continue on current prefix */
     BYTE const* base;          /* All regular indexes relative to this position */
     BYTE const* dictBase;      /* extDict indexes relative to this position */
@@ -197,8 +197,8 @@ typedef struct {
                                 * ZSTD_window_init(). Useful for debugging coredumps
                                 * and for ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY.
                                 */
-} ZSTD_window_t; 
- 
+} ZSTD_window_t;
+
 #define ZSTD_WINDOW_START_INDEX 2
 
 typedef struct ZSTD_matchState_t ZSTD_matchState_t;
@@ -221,33 +221,33 @@ struct ZSTD_matchState_t {
     U16* tagTable;                           /* For row-based matchFinder: A row-based table containing the hashes and head index. */
     U32 hashCache[ZSTD_ROW_HASH_CACHE_SIZE]; /* For row-based matchFinder: a cache of hashes to improve speed */
 
-    U32* hashTable; 
-    U32* hashTable3; 
-    U32* chainTable; 
+    U32* hashTable;
+    U32* hashTable3;
+    U32* chainTable;
 
     U32 forceNonContiguous; /* Non-zero if we should force non-contiguous load for the next window update. */
 
     int dedicatedDictSearch;  /* Indicates whether this matchState is using the
                                * dedicated dictionary search structure.
                                */
-    optState_t opt;         /* optimal parser state */ 
+    optState_t opt;         /* optimal parser state */
     const ZSTD_matchState_t* dictMatchState;
     ZSTD_compressionParameters cParams;
     const rawSeqStore_t* ldmSeqStore;
 };
- 
-typedef struct { 
-    ZSTD_compressedBlockState_t* prevCBlock; 
-    ZSTD_compressedBlockState_t* nextCBlock; 
-    ZSTD_matchState_t matchState; 
-} ZSTD_blockState_t; 
- 
-typedef struct { 
-    U32 offset; 
-    U32 checksum; 
-} ldmEntry_t; 
- 
-typedef struct { 
+
+typedef struct {
+    ZSTD_compressedBlockState_t* prevCBlock;
+    ZSTD_compressedBlockState_t* nextCBlock;
+    ZSTD_matchState_t matchState;
+} ZSTD_blockState_t;
+
+typedef struct {
+    U32 offset;
+    U32 checksum;
+} ldmEntry_t;
+
+typedef struct {
     BYTE const* split;
     U32 hash;
     U32 checksum;
@@ -257,57 +257,57 @@ typedef struct {
 #define LDM_BATCH_SIZE 64
 
 typedef struct {
-    ZSTD_window_t window;   /* State for the window round buffer management */ 
-    ldmEntry_t* hashTable; 
+    ZSTD_window_t window;   /* State for the window round buffer management */
+    ldmEntry_t* hashTable;
     U32 loadedDictEnd;
-    BYTE* bucketOffsets;    /* Next position in bucket to insert entry */ 
+    BYTE* bucketOffsets;    /* Next position in bucket to insert entry */
     size_t splitIndices[LDM_BATCH_SIZE];
     ldmMatchCandidate_t matchCandidates[LDM_BATCH_SIZE];
-} ldmState_t; 
- 
-typedef struct { 
+} ldmState_t;
+
+typedef struct {
     ZSTD_paramSwitch_e enableLdm; /* ZSTD_ps_enable to enable LDM. ZSTD_ps_auto by default */
-    U32 hashLog;            /* Log size of hashTable */ 
-    U32 bucketSizeLog;      /* Log bucket size for collision resolution, at most 8 */ 
-    U32 minMatchLength;     /* Minimum match length */ 
+    U32 hashLog;            /* Log size of hashTable */
+    U32 bucketSizeLog;      /* Log bucket size for collision resolution, at most 8 */
+    U32 minMatchLength;     /* Minimum match length */
     U32 hashRateLog;       /* Log number of entries to skip */
-    U32 windowLog;          /* Window log for the LDM */ 
-} ldmParams_t; 
- 
-typedef struct { 
+    U32 windowLog;          /* Window log for the LDM */
+} ldmParams_t;
+
+typedef struct {
     int collectSequences;
     ZSTD_Sequence* seqStart;
     size_t seqIndex;
     size_t maxSequences;
 } SeqCollector;
 
-struct ZSTD_CCtx_params_s { 
-    ZSTD_format_e format; 
-    ZSTD_compressionParameters cParams; 
-    ZSTD_frameParameters fParams; 
- 
-    int compressionLevel; 
-    int forceWindow;           /* force back-references to respect limit of 
-                                * 1<<wLog, even for dictionary */ 
+struct ZSTD_CCtx_params_s {
+    ZSTD_format_e format;
+    ZSTD_compressionParameters cParams;
+    ZSTD_frameParameters fParams;
+
+    int compressionLevel;
+    int forceWindow;           /* force back-references to respect limit of
+                                * 1<<wLog, even for dictionary */
     size_t targetCBlockSize;   /* Tries to fit compressed block size to be around targetCBlockSize.
                                 * No target when targetCBlockSize == 0.
                                 * There is no guarantee on compressed block size */
     int srcSizeHint;           /* User's best guess of source size.
                                 * Hint is not valid when srcSizeHint == 0.
                                 * There is no guarantee that hint is close to actual source size */
- 
+
     ZSTD_dictAttachPref_e attachDictPref;
     ZSTD_paramSwitch_e literalCompressionMode;
 
-    /* Multithreading: used to pass parameters to mtctx */ 
+    /* Multithreading: used to pass parameters to mtctx */
     int nbWorkers;
     size_t jobSize;
     int overlapLog;
     int rsyncable;
- 
-    /* Long distance matching parameters */ 
-    ldmParams_t ldmParams; 
- 
+
+    /* Long distance matching parameters */
+    ldmParams_t ldmParams;
+
     /* Dedicated dict search algorithm trigger */
     int enableDedicatedDictSearch;
 
@@ -328,10 +328,10 @@ struct ZSTD_CCtx_params_s {
     /* Always load a dictionary in ext-dict mode (not prefix mode)? */
     int deterministicRefPrefix;
 
-    /* Internal use, for createCCtxParams() and freeCCtxParams() only */ 
-    ZSTD_customMem customMem; 
-};  /* typedef'd to ZSTD_CCtx_params within "zstd.h" */ 
- 
+    /* Internal use, for createCCtxParams() and freeCCtxParams() only */
+    ZSTD_customMem customMem;
+};  /* typedef'd to ZSTD_CCtx_params within "zstd.h" */
+
 #define COMPRESS_SEQUENCES_WORKSPACE_SIZE (sizeof(unsigned) * (MaxSeq + 2))
 #define ENTROPY_WORKSPACE_SIZE (HUF_WORKSPACE_SIZE + COMPRESS_SEQUENCES_WORKSPACE_SIZE)
 
@@ -361,66 +361,66 @@ typedef struct {
     ZSTD_entropyCTablesMetadata_t entropyMetadata;
 } ZSTD_blockSplitCtx;
 
-struct ZSTD_CCtx_s { 
-    ZSTD_compressionStage_e stage; 
-    int cParamsChanged;                  /* == 1 if cParams(except wlog) or compression level are changed in requestedParams. Triggers transmission of new params to ZSTDMT (if available) then reset to 0. */ 
-    int bmi2;                            /* == 1 if the CPU supports BMI2 and 0 otherwise. CPU support is determined dynamically once per context lifetime. */ 
-    ZSTD_CCtx_params requestedParams; 
-    ZSTD_CCtx_params appliedParams; 
+struct ZSTD_CCtx_s {
+    ZSTD_compressionStage_e stage;
+    int cParamsChanged;                  /* == 1 if cParams(except wlog) or compression level are changed in requestedParams. Triggers transmission of new params to ZSTDMT (if available) then reset to 0. */
+    int bmi2;                            /* == 1 if the CPU supports BMI2 and 0 otherwise. CPU support is determined dynamically once per context lifetime. */
+    ZSTD_CCtx_params requestedParams;
+    ZSTD_CCtx_params appliedParams;
     ZSTD_CCtx_params simpleApiParams;    /* Param storage used by the simple API - not sticky. Must only be used in top-level simple API functions for storage. */
-    U32   dictID; 
+    U32   dictID;
     size_t dictContentSize;
 
     ZSTD_cwksp workspace; /* manages buffer for dynamic allocations */
-    size_t blockSize; 
-    unsigned long long pledgedSrcSizePlusOne;  /* this way, 0 (default) == unknown */ 
-    unsigned long long consumedSrcSize; 
-    unsigned long long producedCSize; 
-    XXH64_state_t xxhState; 
-    ZSTD_customMem customMem; 
+    size_t blockSize;
+    unsigned long long pledgedSrcSizePlusOne;  /* this way, 0 (default) == unknown */
+    unsigned long long consumedSrcSize;
+    unsigned long long producedCSize;
+    XXH64_state_t xxhState;
+    ZSTD_customMem customMem;
     ZSTD_threadPool* pool;
-    size_t staticSize; 
+    size_t staticSize;
     SeqCollector seqCollector;
     int isFirstBlock;
     int initialized;
- 
-    seqStore_t seqStore;      /* sequences storage ptrs */ 
-    ldmState_t ldmState;      /* long distance matching state */ 
-    rawSeq* ldmSequences;     /* Storage for the ldm output sequences */ 
-    size_t maxNbLdmSequences; 
-    rawSeqStore_t externSeqStore; /* Mutable reference to external sequences */ 
-    ZSTD_blockState_t blockState; 
+
+    seqStore_t seqStore;      /* sequences storage ptrs */
+    ldmState_t ldmState;      /* long distance matching state */
+    rawSeq* ldmSequences;     /* Storage for the ldm output sequences */
+    size_t maxNbLdmSequences;
+    rawSeqStore_t externSeqStore; /* Mutable reference to external sequences */
+    ZSTD_blockState_t blockState;
     U32* entropyWorkspace;  /* entropy workspace of ENTROPY_WORKSPACE_SIZE bytes */
- 
+
     /* Whether we are streaming or not */
     ZSTD_buffered_policy_e bufferedPolicy;
 
-    /* streaming */ 
-    char*  inBuff; 
-    size_t inBuffSize; 
-    size_t inToCompress; 
-    size_t inBuffPos; 
-    size_t inBuffTarget; 
-    char*  outBuff; 
-    size_t outBuffSize; 
-    size_t outBuffContentSize; 
-    size_t outBuffFlushedSize; 
-    ZSTD_cStreamStage streamStage; 
-    U32    frameEnded; 
- 
+    /* streaming */
+    char*  inBuff;
+    size_t inBuffSize;
+    size_t inToCompress;
+    size_t inBuffPos;
+    size_t inBuffTarget;
+    char*  outBuff;
+    size_t outBuffSize;
+    size_t outBuffContentSize;
+    size_t outBuffFlushedSize;
+    ZSTD_cStreamStage streamStage;
+    U32    frameEnded;
+
     /* Stable in/out buffer verification */
     ZSTD_inBuffer expectedInBuffer;
     size_t expectedOutBufferSize;
 
-    /* Dictionary */ 
+    /* Dictionary */
     ZSTD_localDict localDict;
-    const ZSTD_CDict* cdict; 
-    ZSTD_prefixDict prefixDict;   /* single-usage dictionary */ 
- 
-    /* Multi-threading */ 
-#ifdef ZSTD_MULTITHREAD 
-    ZSTDMT_CCtx* mtctx; 
-#endif 
+    const ZSTD_CDict* cdict;
+    ZSTD_prefixDict prefixDict;   /* single-usage dictionary */
+
+    /* Multi-threading */
+#ifdef ZSTD_MULTITHREAD
+    ZSTDMT_CCtx* mtctx;
+#endif
 
     /* Tracing */
 #if ZSTD_TRACE
@@ -429,10 +429,10 @@ struct ZSTD_CCtx_s {
 
     /* Workspace for block splitter */
     ZSTD_blockSplitCtx blockSplitCtx;
-}; 
- 
+};
+
 typedef enum { ZSTD_dtlm_fast, ZSTD_dtlm_full } ZSTD_dictTableLoadMethod_e;
- 
+
 typedef enum {
     ZSTD_noDict = 0,
     ZSTD_extDict = 1,
@@ -460,43 +460,43 @@ typedef enum {
                                  */
 } ZSTD_cParamMode_e;
 
-typedef size_t (*ZSTD_blockCompressor) ( 
-        ZSTD_matchState_t* bs, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], 
+typedef size_t (*ZSTD_blockCompressor) (
+        ZSTD_matchState_t* bs, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],
         void const* src, size_t srcSize);
 ZSTD_blockCompressor ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_paramSwitch_e rowMatchfinderMode, ZSTD_dictMode_e dictMode);
- 
- 
-MEM_STATIC U32 ZSTD_LLcode(U32 litLength) 
-{ 
-    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 U32 LL_deltaCode = 19; 
-    return (litLength > 63) ? ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength]; 
-} 
- 
-/* ZSTD_MLcode() : 
- * note : mlBase = matchLength - MINMATCH; 
- *        because it's the format it's stored in seqStore->sequences */ 
-MEM_STATIC U32 ZSTD_MLcode(U32 mlBase) 
-{ 
-    static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 
-                                      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 
-                                      32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37, 
-                                      38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 
-                                      40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 
-                                      41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 
-                                      42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 
-                                      42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 }; 
-    static const U32 ML_deltaCode = 36; 
-    return (mlBase > 127) ? ZSTD_highbit32(mlBase) + ML_deltaCode : ML_Code[mlBase]; 
-} 
- 
+
+
+MEM_STATIC U32 ZSTD_LLcode(U32 litLength)
+{
+    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 U32 LL_deltaCode = 19;
+    return (litLength > 63) ? ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];
+}
+
+/* ZSTD_MLcode() :
+ * note : mlBase = matchLength - MINMATCH;
+ *        because it's the format it's stored in seqStore->sequences */
+MEM_STATIC U32 ZSTD_MLcode(U32 mlBase)
+{
+    static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
+                                      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+                                      32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37,
+                                      38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39,
+                                      40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
+                                      41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
+                                      42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
+                                      42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 };
+    static const U32 ML_deltaCode = 36;
+    return (mlBase > 127) ? ZSTD_highbit32(mlBase) + ML_deltaCode : ML_Code[mlBase];
+}
+
 /* ZSTD_cParam_withinBounds:
  * @return 1 if value is within cParam bounds,
  * 0 otherwise */
@@ -590,30 +590,30 @@ ZSTD_safecopyLiterals(BYTE* op, BYTE const* ip, BYTE const* const iend, BYTE con
 #define STORED_TO_OFFBASE(o) ((o)+1)
 #define OFFBASE_TO_STORED(o) ((o)-1)
 
-/*! ZSTD_storeSeq() : 
+/*! ZSTD_storeSeq() :
  *  Store a sequence (litlen, litPtr, offCode and matchLength) into seqStore_t.
  *  @offBase_minus1 : Users should use employ macros STORE_REPCODE_X and STORE_OFFSET().
  *  @matchLength : must be >= MINMATCH
  *  Allowed to overread literals up to litLimit.
-*/ 
+*/
 HINT_INLINE UNUSED_ATTR void
 ZSTD_storeSeq(seqStore_t* seqStorePtr,
               size_t litLength, const BYTE* literals, const BYTE* litLimit,
               U32 offBase_minus1,
               size_t matchLength)
-{ 
+{
     BYTE const* const litLimit_w = litLimit - WILDCOPY_OVERLENGTH;
     BYTE const* const litEnd = literals + litLength;
 #if defined(DEBUGLEVEL) && (DEBUGLEVEL >= 6)
-    static const BYTE* g_start = NULL; 
-    if (g_start==NULL) g_start = (const BYTE*)literals;  /* note : index only works for compression within a single segment */ 
-    {   U32 const pos = (U32)((const BYTE*)literals - g_start); 
+    static const BYTE* g_start = NULL;
+    if (g_start==NULL) g_start = (const BYTE*)literals;  /* note : index only works for compression within a single segment */
+    {   U32 const pos = (U32)((const BYTE*)literals - g_start);
         DEBUGLOG(6, "Cpos%7u :%3u literals, match%4u bytes at offCode%7u",
                pos, (U32)litLength, (U32)matchLength, (U32)offBase_minus1);
-    } 
-#endif 
+    }
+#endif
     assert((size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart) < seqStorePtr->maxNbSeq);
-    /* copy Literals */ 
+    /* copy Literals */
     assert(seqStorePtr->maxNbLit <= 128 KB);
     assert(seqStorePtr->lit + litLength <= seqStorePtr->litStart + seqStorePtr->maxNbLit);
     assert(literals + litLength <= litLimit);
@@ -629,20 +629,20 @@ ZSTD_storeSeq(seqStore_t* seqStorePtr,
     } else {
         ZSTD_safecopyLiterals(seqStorePtr->lit, literals, litEnd, litLimit_w);
     }
-    seqStorePtr->lit += litLength; 
- 
-    /* literal Length */ 
-    if (litLength>0xFFFF) { 
+    seqStorePtr->lit += litLength;
+
+    /* literal Length */
+    if (litLength>0xFFFF) {
         assert(seqStorePtr->longLengthType == ZSTD_llt_none); /* there can only be a single long length */
         seqStorePtr->longLengthType = ZSTD_llt_literalLength;
-        seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart); 
-    } 
-    seqStorePtr->sequences[0].litLength = (U16)litLength; 
- 
-    /* match offset */ 
+        seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
+    }
+    seqStorePtr->sequences[0].litLength = (U16)litLength;
+
+    /* match offset */
     seqStorePtr->sequences[0].offBase = STORED_TO_OFFBASE(offBase_minus1);
- 
-    /* match Length */ 
+
+    /* match Length */
     assert(matchLength >= MINMATCH);
     {   size_t const mlBase = matchLength - MINMATCH;
         if (mlBase>0xFFFF) {
@@ -651,11 +651,11 @@ ZSTD_storeSeq(seqStore_t* seqStorePtr,
             seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
         }
         seqStorePtr->sequences[0].mlBase = (U16)mlBase;
-    } 
- 
-    seqStorePtr->sequences++; 
-} 
- 
+    }
+
+    seqStorePtr->sequences++;
+}
+
 /* ZSTD_updateRep() :
  * updates in-place @rep (array of repeat offsets)
  * @offBase_minus1 : sum-type, with same numeric representation as ZSTD_storeSeq()
@@ -679,7 +679,7 @@ ZSTD_updateRep(U32 rep[ZSTD_REP_NUM], U32 const offBase_minus1, U32 const ll0)
         }
     }
 }
- 
+
 typedef struct repcodes_s {
     U32 rep[3];
 } repcodes_t;
@@ -694,14 +694,14 @@ ZSTD_newRep(U32 const rep[ZSTD_REP_NUM], U32 const offBase_minus1, U32 const ll0
 }
 
 
-/*-************************************* 
-*  Match length counter 
-***************************************/ 
-static unsigned ZSTD_NbCommonBytes (size_t val) 
-{ 
-    if (MEM_isLittleEndian()) { 
-        if (MEM_64bits()) { 
-#       if defined(_MSC_VER) && defined(_WIN64) 
+/*-*************************************
+*  Match length counter
+***************************************/
+static unsigned ZSTD_NbCommonBytes (size_t val)
+{
+    if (MEM_isLittleEndian()) {
+        if (MEM_64bits()) {
+#       if defined(_MSC_VER) && defined(_WIN64)
 #           if STATIC_BMI2
                 return _tzcnt_u64(val) >> 3;
 #           else
@@ -714,21 +714,21 @@ static unsigned ZSTD_NbCommonBytes (size_t val)
                     __assume(0);
                 }
 #           endif
-#       elif defined(__GNUC__) && (__GNUC__ >= 4) 
-            return (__builtin_ctzll((U64)val) >> 3); 
-#       else 
-            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2, 
-                                                     0, 3, 1, 3, 1, 4, 2, 7, 
-                                                     0, 2, 3, 6, 1, 5, 3, 5, 
-                                                     1, 3, 4, 4, 2, 5, 6, 7, 
-                                                     7, 0, 1, 2, 3, 3, 4, 6, 
-                                                     2, 6, 5, 5, 3, 4, 5, 6, 
-                                                     7, 1, 2, 4, 6, 4, 4, 5, 
-                                                     7, 2, 6, 5, 7, 6, 7, 7 }; 
-            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58]; 
-#       endif 
-        } else { /* 32 bits */ 
-#       if defined(_MSC_VER) 
+#       elif defined(__GNUC__) && (__GNUC__ >= 4)
+            return (__builtin_ctzll((U64)val) >> 3);
+#       else
+            static const int DeBruijnBytePos[64] = { 0, 0, 0, 0, 0, 1, 1, 2,
+                                                     0, 3, 1, 3, 1, 4, 2, 7,
+                                                     0, 2, 3, 6, 1, 5, 3, 5,
+                                                     1, 3, 4, 4, 2, 5, 6, 7,
+                                                     7, 0, 1, 2, 3, 3, 4, 6,
+                                                     2, 6, 5, 5, 3, 4, 5, 6,
+                                                     7, 1, 2, 4, 6, 4, 4, 5,
+                                                     7, 2, 6, 5, 7, 6, 7, 7 };
+            return DeBruijnBytePos[((U64)((val & -(long long)val) * 0x0218A392CDABBD3FULL)) >> 58];
+#       endif
+        } else { /* 32 bits */
+#       if defined(_MSC_VER)
             if (val != 0) {
                 unsigned long r;
                 _BitScanForward(&r, (U32)val);
@@ -737,19 +737,19 @@ static unsigned ZSTD_NbCommonBytes (size_t val)
                 /* Should not reach this code path */
                 __assume(0);
             }
-#       elif defined(__GNUC__) && (__GNUC__ >= 3) 
-            return (__builtin_ctz((U32)val) >> 3); 
-#       else 
-            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0, 
-                                                     3, 2, 2, 1, 3, 2, 0, 1, 
-                                                     3, 3, 1, 2, 2, 2, 2, 0, 
-                                                     3, 1, 2, 0, 1, 0, 1, 1 }; 
-            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27]; 
-#       endif 
-        } 
-    } else {  /* Big Endian CPU */ 
-        if (MEM_64bits()) { 
-#       if defined(_MSC_VER) && defined(_WIN64) 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3)
+            return (__builtin_ctz((U32)val) >> 3);
+#       else
+            static const int DeBruijnBytePos[32] = { 0, 0, 3, 0, 3, 1, 3, 0,
+                                                     3, 2, 2, 1, 3, 2, 0, 1,
+                                                     3, 3, 1, 2, 2, 2, 2, 0,
+                                                     3, 1, 2, 0, 1, 0, 1, 1 };
+            return DeBruijnBytePos[((U32)((val & -(S32)val) * 0x077CB531U)) >> 27];
+#       endif
+        }
+    } else {  /* Big Endian CPU */
+        if (MEM_64bits()) {
+#       if defined(_MSC_VER) && defined(_WIN64)
 #           if STATIC_BMI2
 			    return _lzcnt_u64(val) >> 3;
 #           else
@@ -762,18 +762,18 @@ static unsigned ZSTD_NbCommonBytes (size_t val)
                     __assume(0);
                 }
 #           endif
-#       elif defined(__GNUC__) && (__GNUC__ >= 4) 
-            return (__builtin_clzll(val) >> 3); 
-#       else 
-            unsigned r; 
-            const unsigned n32 = sizeof(size_t)*4;   /* calculate this way due to compiler complaining in 32-bits mode */ 
-            if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; } 
-            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; } 
-            r += (!val); 
-            return r; 
-#       endif 
-        } else { /* 32 bits */ 
-#       if defined(_MSC_VER) 
+#       elif defined(__GNUC__) && (__GNUC__ >= 4)
+            return (__builtin_clzll(val) >> 3);
+#       else
+            unsigned r;
+            const unsigned n32 = sizeof(size_t)*4;   /* calculate this way due to compiler complaining in 32-bits mode */
+            if (!(val>>n32)) { r=4; } else { r=0; val>>=n32; }
+            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
+            r += (!val);
+            return r;
+#       endif
+        } else { /* 32 bits */
+#       if defined(_MSC_VER)
             if (val != 0) {
                 unsigned long r;
                 _BitScanReverse(&r, (unsigned long)val);
@@ -782,100 +782,100 @@ static unsigned ZSTD_NbCommonBytes (size_t val)
                 /* Should not reach this code path */
                 __assume(0);
             }
-#       elif defined(__GNUC__) && (__GNUC__ >= 3) 
-            return (__builtin_clz((U32)val) >> 3); 
-#       else 
-            unsigned r; 
-            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; } 
-            r += (!val); 
-            return r; 
-#       endif 
-    }   } 
-} 
- 
- 
-MEM_STATIC size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* const pInLimit) 
-{ 
-    const BYTE* const pStart = pIn; 
-    const BYTE* const pInLoopLimit = pInLimit - (sizeof(size_t)-1); 
- 
-    if (pIn < pInLoopLimit) { 
-        { size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn); 
-          if (diff) return ZSTD_NbCommonBytes(diff); } 
-        pIn+=sizeof(size_t); pMatch+=sizeof(size_t); 
-        while (pIn < pInLoopLimit) { 
-            size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn); 
-            if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; } 
-            pIn += ZSTD_NbCommonBytes(diff); 
-            return (size_t)(pIn - pStart); 
-    }   } 
-    if (MEM_64bits() && (pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; } 
-    if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; } 
-    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++; 
-    return (size_t)(pIn - pStart); 
-} 
- 
-/** ZSTD_count_2segments() : 
- *  can count match length with `ip` & `match` in 2 different segments. 
- *  convention : on reaching mEnd, match count continue starting from iStart 
- */ 
-MEM_STATIC size_t 
-ZSTD_count_2segments(const BYTE* ip, const BYTE* match, 
-                     const BYTE* iEnd, const BYTE* mEnd, const BYTE* iStart) 
-{ 
-    const BYTE* const vEnd = MIN( ip + (mEnd - match), iEnd); 
-    size_t const matchLength = ZSTD_count(ip, match, vEnd); 
-    if (match + matchLength != mEnd) return matchLength; 
+#       elif defined(__GNUC__) && (__GNUC__ >= 3)
+            return (__builtin_clz((U32)val) >> 3);
+#       else
+            unsigned r;
+            if (!(val>>16)) { r=2; val>>=8; } else { r=0; val>>=24; }
+            r += (!val);
+            return r;
+#       endif
+    }   }
+}
+
+
+MEM_STATIC size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* const pInLimit)
+{
+    const BYTE* const pStart = pIn;
+    const BYTE* const pInLoopLimit = pInLimit - (sizeof(size_t)-1);
+
+    if (pIn < pInLoopLimit) {
+        { size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
+          if (diff) return ZSTD_NbCommonBytes(diff); }
+        pIn+=sizeof(size_t); pMatch+=sizeof(size_t);
+        while (pIn < pInLoopLimit) {
+            size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);
+            if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; }
+            pIn += ZSTD_NbCommonBytes(diff);
+            return (size_t)(pIn - pStart);
+    }   }
+    if (MEM_64bits() && (pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; }
+    if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; }
+    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
+    return (size_t)(pIn - pStart);
+}
+
+/** ZSTD_count_2segments() :
+ *  can count match length with `ip` & `match` in 2 different segments.
+ *  convention : on reaching mEnd, match count continue starting from iStart
+ */
+MEM_STATIC size_t
+ZSTD_count_2segments(const BYTE* ip, const BYTE* match,
+                     const BYTE* iEnd, const BYTE* mEnd, const BYTE* iStart)
+{
+    const BYTE* const vEnd = MIN( ip + (mEnd - match), iEnd);
+    size_t const matchLength = ZSTD_count(ip, match, vEnd);
+    if (match + matchLength != mEnd) return matchLength;
     DEBUGLOG(7, "ZSTD_count_2segments: found a 2-parts match (current length==%zu)", matchLength);
     DEBUGLOG(7, "distance from match beginning to end dictionary = %zi", mEnd - match);
     DEBUGLOG(7, "distance from current pos to end buffer = %zi", iEnd - ip);
     DEBUGLOG(7, "next byte : ip==%02X, istart==%02X", ip[matchLength], *iStart);
     DEBUGLOG(7, "final match length = %zu", matchLength + ZSTD_count(ip+matchLength, iStart, iEnd));
-    return matchLength + ZSTD_count(ip+matchLength, iStart, iEnd); 
-} 
- 
- 
-/*-************************************* 
- *  Hashes 
- ***************************************/ 
-static const U32 prime3bytes = 506832829U; 
-static U32    ZSTD_hash3(U32 u, U32 h) { return ((u << (32-24)) * prime3bytes)  >> (32-h) ; } 
-MEM_STATIC size_t ZSTD_hash3Ptr(const void* ptr, U32 h) { return ZSTD_hash3(MEM_readLE32(ptr), h); } /* only in zstd_opt.h */ 
- 
-static const U32 prime4bytes = 2654435761U; 
-static U32    ZSTD_hash4(U32 u, U32 h) { return (u * prime4bytes) >> (32-h) ; } 
-static size_t ZSTD_hash4Ptr(const void* ptr, U32 h) { return ZSTD_hash4(MEM_read32(ptr), h); } 
- 
-static const U64 prime5bytes = 889523592379ULL; 
-static size_t ZSTD_hash5(U64 u, U32 h) { return (size_t)(((u  << (64-40)) * prime5bytes) >> (64-h)) ; } 
-static size_t ZSTD_hash5Ptr(const void* p, U32 h) { return ZSTD_hash5(MEM_readLE64(p), h); } 
- 
-static const U64 prime6bytes = 227718039650203ULL; 
-static size_t ZSTD_hash6(U64 u, U32 h) { return (size_t)(((u  << (64-48)) * prime6bytes) >> (64-h)) ; } 
-static size_t ZSTD_hash6Ptr(const void* p, U32 h) { return ZSTD_hash6(MEM_readLE64(p), h); } 
- 
-static const U64 prime7bytes = 58295818150454627ULL; 
-static size_t ZSTD_hash7(U64 u, U32 h) { return (size_t)(((u  << (64-56)) * prime7bytes) >> (64-h)) ; } 
-static size_t ZSTD_hash7Ptr(const void* p, U32 h) { return ZSTD_hash7(MEM_readLE64(p), h); } 
- 
-static const U64 prime8bytes = 0xCF1BBCDCB7A56463ULL; 
-static size_t ZSTD_hash8(U64 u, U32 h) { return (size_t)(((u) * prime8bytes) >> (64-h)) ; } 
-static size_t ZSTD_hash8Ptr(const void* p, U32 h) { return ZSTD_hash8(MEM_readLE64(p), h); } 
- 
+    return matchLength + ZSTD_count(ip+matchLength, iStart, iEnd);
+}
+
+
+/*-*************************************
+ *  Hashes
+ ***************************************/
+static const U32 prime3bytes = 506832829U;
+static U32    ZSTD_hash3(U32 u, U32 h) { return ((u << (32-24)) * prime3bytes)  >> (32-h) ; }
+MEM_STATIC size_t ZSTD_hash3Ptr(const void* ptr, U32 h) { return ZSTD_hash3(MEM_readLE32(ptr), h); } /* only in zstd_opt.h */
+
+static const U32 prime4bytes = 2654435761U;
+static U32    ZSTD_hash4(U32 u, U32 h) { return (u * prime4bytes) >> (32-h) ; }
+static size_t ZSTD_hash4Ptr(const void* ptr, U32 h) { return ZSTD_hash4(MEM_read32(ptr), h); }
+
+static const U64 prime5bytes = 889523592379ULL;
+static size_t ZSTD_hash5(U64 u, U32 h) { return (size_t)(((u  << (64-40)) * prime5bytes) >> (64-h)) ; }
+static size_t ZSTD_hash5Ptr(const void* p, U32 h) { return ZSTD_hash5(MEM_readLE64(p), h); }
+
+static const U64 prime6bytes = 227718039650203ULL;
+static size_t ZSTD_hash6(U64 u, U32 h) { return (size_t)(((u  << (64-48)) * prime6bytes) >> (64-h)) ; }
+static size_t ZSTD_hash6Ptr(const void* p, U32 h) { return ZSTD_hash6(MEM_readLE64(p), h); }
+
+static const U64 prime7bytes = 58295818150454627ULL;
+static size_t ZSTD_hash7(U64 u, U32 h) { return (size_t)(((u  << (64-56)) * prime7bytes) >> (64-h)) ; }
+static size_t ZSTD_hash7Ptr(const void* p, U32 h) { return ZSTD_hash7(MEM_readLE64(p), h); }
+
+static const U64 prime8bytes = 0xCF1BBCDCB7A56463ULL;
+static size_t ZSTD_hash8(U64 u, U32 h) { return (size_t)(((u) * prime8bytes) >> (64-h)) ; }
+static size_t ZSTD_hash8Ptr(const void* p, U32 h) { return ZSTD_hash8(MEM_readLE64(p), h); }
+
 MEM_STATIC FORCE_INLINE_ATTR
 size_t ZSTD_hashPtr(const void* p, U32 hBits, U32 mls)
-{ 
-    switch(mls) 
-    { 
-    default: 
-    case 4: return ZSTD_hash4Ptr(p, hBits); 
-    case 5: return ZSTD_hash5Ptr(p, hBits); 
-    case 6: return ZSTD_hash6Ptr(p, hBits); 
-    case 7: return ZSTD_hash7Ptr(p, hBits); 
-    case 8: return ZSTD_hash8Ptr(p, hBits); 
-    } 
-} 
- 
+{
+    switch(mls)
+    {
+    default:
+    case 4: return ZSTD_hash4Ptr(p, hBits);
+    case 5: return ZSTD_hash5Ptr(p, hBits);
+    case 6: return ZSTD_hash6Ptr(p, hBits);
+    case 7: return ZSTD_hash7Ptr(p, hBits);
+    case 8: return ZSTD_hash8Ptr(p, hBits);
+    }
+}
+
 /** ZSTD_ipow() :
  * Return base^exponent.
  */
@@ -934,32 +934,32 @@ MEM_STATIC U64 ZSTD_rollingHash_rotate(U64 hash, BYTE toRemove, BYTE toAdd, U64
     return hash;
 }
 
-/*-************************************* 
-*  Round buffer management 
-***************************************/ 
+/*-*************************************
+*  Round buffer management
+***************************************/
 #if (ZSTD_WINDOWLOG_MAX_64 > 31)
 # error "ZSTD_WINDOWLOG_MAX is too large : would overflow ZSTD_CURRENT_MAX"
 #endif
-/* Max current allowed */ 
-#define ZSTD_CURRENT_MAX ((3U << 29) + (1U << ZSTD_WINDOWLOG_MAX)) 
-/* Maximum chunk size before overflow correction needs to be called again */ 
-#define ZSTD_CHUNKSIZE_MAX                                                     \ 
-    ( ((U32)-1)                  /* Maximum ending current index */            \ 
-    - ZSTD_CURRENT_MAX)          /* Maximum beginning lowLimit */ 
- 
-/** 
- * ZSTD_window_clear(): 
- * Clears the window containing the history by simply setting it to empty. 
- */ 
-MEM_STATIC void ZSTD_window_clear(ZSTD_window_t* window) 
-{ 
-    size_t const endT = (size_t)(window->nextSrc - window->base); 
-    U32 const end = (U32)endT; 
- 
-    window->lowLimit = end; 
-    window->dictLimit = end; 
-} 
- 
+/* Max current allowed */
+#define ZSTD_CURRENT_MAX ((3U << 29) + (1U << ZSTD_WINDOWLOG_MAX))
+/* Maximum chunk size before overflow correction needs to be called again */
+#define ZSTD_CHUNKSIZE_MAX                                                     \
+    ( ((U32)-1)                  /* Maximum ending current index */            \
+    - ZSTD_CURRENT_MAX)          /* Maximum beginning lowLimit */
+
+/**
+ * ZSTD_window_clear():
+ * Clears the window containing the history by simply setting it to empty.
+ */
+MEM_STATIC void ZSTD_window_clear(ZSTD_window_t* window)
+{
+    size_t const endT = (size_t)(window->nextSrc - window->base);
+    U32 const end = (U32)endT;
+
+    window->lowLimit = end;
+    window->dictLimit = end;
+}
+
 MEM_STATIC U32 ZSTD_window_isEmpty(ZSTD_window_t const window)
 {
     return window.dictLimit == ZSTD_WINDOW_START_INDEX &&
@@ -967,16 +967,16 @@ MEM_STATIC U32 ZSTD_window_isEmpty(ZSTD_window_t const window)
            (window.nextSrc - window.base) == ZSTD_WINDOW_START_INDEX;
 }
 
-/** 
- * ZSTD_window_hasExtDict(): 
- * Returns non-zero if the window has a non-empty extDict. 
- */ 
-MEM_STATIC U32 ZSTD_window_hasExtDict(ZSTD_window_t const window) 
-{ 
-    return window.lowLimit < window.dictLimit; 
-} 
- 
-/** 
+/**
+ * ZSTD_window_hasExtDict():
+ * Returns non-zero if the window has a non-empty extDict.
+ */
+MEM_STATIC U32 ZSTD_window_hasExtDict(ZSTD_window_t const window)
+{
+    return window.lowLimit < window.dictLimit;
+}
+
+/**
  * ZSTD_matchState_dictMode():
  * Inspects the provided matchState and figures out what dictMode should be
  * passed to the compressor.
@@ -1038,17 +1038,17 @@ MEM_STATIC U32 ZSTD_window_canOverflowCorrect(ZSTD_window_t const window,
 }
 
 /**
- * ZSTD_window_needOverflowCorrection(): 
- * Returns non-zero if the indices are getting too large and need overflow 
- * protection. 
- */ 
-MEM_STATIC U32 ZSTD_window_needOverflowCorrection(ZSTD_window_t const window, 
+ * ZSTD_window_needOverflowCorrection():
+ * Returns non-zero if the indices are getting too large and need overflow
+ * protection.
+ */
+MEM_STATIC U32 ZSTD_window_needOverflowCorrection(ZSTD_window_t const window,
                                                   U32 cycleLog,
                                                   U32 maxDist,
                                                   U32 loadedDictEnd,
                                                   void const* src,
-                                                  void const* srcEnd) 
-{ 
+                                                  void const* srcEnd)
+{
     U32 const curr = (U32)((BYTE const*)srcEnd - window.base);
     if (ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY) {
         if (ZSTD_window_canOverflowCorrect(window, cycleLog, maxDist, loadedDictEnd, src)) {
@@ -1056,39 +1056,39 @@ MEM_STATIC U32 ZSTD_window_needOverflowCorrection(ZSTD_window_t const window,
         }
     }
     return curr > ZSTD_CURRENT_MAX;
-} 
- 
-/** 
- * ZSTD_window_correctOverflow(): 
- * Reduces the indices to protect from index overflow. 
- * Returns the correction made to the indices, which must be applied to every 
- * stored index. 
- * 
- * The least significant cycleLog bits of the indices must remain the same, 
- * which may be 0. Every index up to maxDist in the past must be valid. 
- */ 
-MEM_STATIC U32 ZSTD_window_correctOverflow(ZSTD_window_t* window, U32 cycleLog, 
-                                           U32 maxDist, void const* src) 
-{ 
-    /* preemptive overflow correction: 
-     * 1. correction is large enough: 
-     *    lowLimit > (3<<29) ==> current > 3<<29 + 1<<windowLog 
-     *    1<<windowLog <= newCurrent < 1<<chainLog + 1<<windowLog 
-     * 
-     *    current - newCurrent 
-     *    > (3<<29 + 1<<windowLog) - (1<<windowLog + 1<<chainLog) 
-     *    > (3<<29) - (1<<chainLog) 
-     *    > (3<<29) - (1<<30)             (NOTE: chainLog <= 30) 
-     *    > 1<<29 
-     * 
-     * 2. (ip+ZSTD_CHUNKSIZE_MAX - cctx->base) doesn't overflow: 
-     *    After correction, current is less than (1<<chainLog + 1<<windowLog). 
-     *    In 64-bit mode we are safe, because we have 64-bit ptrdiff_t. 
-     *    In 32-bit mode we are safe, because (chainLog <= 29), so 
-     *    ip+ZSTD_CHUNKSIZE_MAX - cctx->base < 1<<32. 
-     * 3. (cctx->lowLimit + 1<<windowLog) < 1<<32: 
-     *    windowLog <= 31 ==> 3<<29 + 1<<windowLog < 7<<29 < 1<<32. 
-     */ 
+}
+
+/**
+ * ZSTD_window_correctOverflow():
+ * Reduces the indices to protect from index overflow.
+ * Returns the correction made to the indices, which must be applied to every
+ * stored index.
+ *
+ * The least significant cycleLog bits of the indices must remain the same,
+ * which may be 0. Every index up to maxDist in the past must be valid.
+ */
+MEM_STATIC U32 ZSTD_window_correctOverflow(ZSTD_window_t* window, U32 cycleLog,
+                                           U32 maxDist, void const* src)
+{
+    /* preemptive overflow correction:
+     * 1. correction is large enough:
+     *    lowLimit > (3<<29) ==> current > 3<<29 + 1<<windowLog
+     *    1<<windowLog <= newCurrent < 1<<chainLog + 1<<windowLog
+     *
+     *    current - newCurrent
+     *    > (3<<29 + 1<<windowLog) - (1<<windowLog + 1<<chainLog)
+     *    > (3<<29) - (1<<chainLog)
+     *    > (3<<29) - (1<<30)             (NOTE: chainLog <= 30)
+     *    > 1<<29
+     *
+     * 2. (ip+ZSTD_CHUNKSIZE_MAX - cctx->base) doesn't overflow:
+     *    After correction, current is less than (1<<chainLog + 1<<windowLog).
+     *    In 64-bit mode we are safe, because we have 64-bit ptrdiff_t.
+     *    In 32-bit mode we are safe, because (chainLog <= 29), so
+     *    ip+ZSTD_CHUNKSIZE_MAX - cctx->base < 1<<32.
+     * 3. (cctx->lowLimit + 1<<windowLog) < 1<<32:
+     *    windowLog <= 31 ==> 3<<29 + 1<<windowLog < 7<<29 < 1<<32.
+     */
     U32 const cycleSize = 1u << cycleLog;
     U32 const cycleMask = cycleSize - 1;
     U32 const curr = (U32)((BYTE const*)src - window->base);
@@ -1112,9 +1112,9 @@ MEM_STATIC U32 ZSTD_window_correctOverflow(ZSTD_window_t* window, U32 cycleLog,
         /* Loose bound, should be around 1<<29 (see above) */
         assert(correction > 1<<28);
     }
- 
-    window->base += correction; 
-    window->dictBase += correction; 
+
+    window->base += correction;
+    window->dictBase += correction;
     if (window->lowLimit < correction + ZSTD_WINDOW_START_INDEX) {
         window->lowLimit = ZSTD_WINDOW_START_INDEX;
     } else {
@@ -1125,7 +1125,7 @@ MEM_STATIC U32 ZSTD_window_correctOverflow(ZSTD_window_t* window, U32 cycleLog,
     } else {
         window->dictLimit -= correction;
     }
- 
+
     /* Ensure we can still reference the full window. */
     assert(newCurrent >= maxDist);
     assert(newCurrent - maxDist >= ZSTD_WINDOW_START_INDEX);
@@ -1135,15 +1135,15 @@ MEM_STATIC U32 ZSTD_window_correctOverflow(ZSTD_window_t* window, U32 cycleLog,
 
     ++window->nbOverflowCorrections;
 
-    DEBUGLOG(4, "Correction of 0x%x bytes to lowLimit=0x%x", correction, 
-             window->lowLimit); 
-    return correction; 
-} 
- 
-/** 
- * ZSTD_window_enforceMaxDist(): 
- * Updates lowLimit so that: 
- *    (srcEnd - base) - lowLimit == maxDist + loadedDictEnd 
+    DEBUGLOG(4, "Correction of 0x%x bytes to lowLimit=0x%x", correction,
+             window->lowLimit);
+    return correction;
+}
+
+/**
+ * ZSTD_window_enforceMaxDist():
+ * Updates lowLimit so that:
+ *    (srcEnd - base) - lowLimit == maxDist + loadedDictEnd
  *
  * It ensures index is valid as long as index >= lowLimit.
  * This must be called before a block compression call.
@@ -1162,14 +1162,14 @@ MEM_STATIC U32 ZSTD_window_correctOverflow(ZSTD_window_t* window, U32 cycleLog,
  * In dictMatchState mode, lowLimit and dictLimit are the same,
  * and the dictionary is below them.
  * forceWindow and dictMatchState are therefore incompatible.
- */ 
+ */
 MEM_STATIC void
 ZSTD_window_enforceMaxDist(ZSTD_window_t* window,
                      const void* blockEnd,
                            U32   maxDist,
                            U32*  loadedDictEndPtr,
                      const ZSTD_matchState_t** dictMatchStatePtr)
-{ 
+{
     U32 const blockEndIdx = (U32)((BYTE const*)blockEnd - window->base);
     U32 const loadedDictEnd = (loadedDictEndPtr != NULL) ? *loadedDictEndPtr : 0;
     DEBUGLOG(5, "ZSTD_window_enforceMaxDist: blockEndIdx=%u, maxDist=%u, loadedDictEnd=%u",
@@ -1190,18 +1190,18 @@ ZSTD_window_enforceMaxDist(ZSTD_window_t* window,
     */
     if (blockEndIdx > maxDist + loadedDictEnd) {
         U32 const newLowLimit = blockEndIdx - maxDist;
-        if (window->lowLimit < newLowLimit) window->lowLimit = newLowLimit; 
-        if (window->dictLimit < window->lowLimit) { 
+        if (window->lowLimit < newLowLimit) window->lowLimit = newLowLimit;
+        if (window->dictLimit < window->lowLimit) {
             DEBUGLOG(5, "Update dictLimit to match lowLimit, from %u to %u",
                         (unsigned)window->dictLimit, (unsigned)window->lowLimit);
-            window->dictLimit = window->lowLimit; 
-        } 
+            window->dictLimit = window->lowLimit;
+        }
         /* On reaching window size, dictionaries are invalidated */
         if (loadedDictEndPtr) *loadedDictEndPtr = 0;
         if (dictMatchStatePtr) *dictMatchStatePtr = NULL;
-    } 
-} 
- 
+    }
+}
+
 /* Similar to ZSTD_window_enforceMaxDist(),
  * but only invalidates dictionary
  * when input progresses beyond window size.
@@ -1248,50 +1248,50 @@ MEM_STATIC void ZSTD_window_init(ZSTD_window_t* window) {
     window->nbOverflowCorrections = 0;
 }
 
-/** 
- * ZSTD_window_update(): 
- * Updates the window by appending [src, src + srcSize) to the window. 
- * If it is not contiguous, the current prefix becomes the extDict, and we 
- * forget about the extDict. Handles overlap of the prefix and extDict. 
- * Returns non-zero if the segment is contiguous. 
- */ 
-MEM_STATIC U32 ZSTD_window_update(ZSTD_window_t* window, 
+/**
+ * ZSTD_window_update():
+ * Updates the window by appending [src, src + srcSize) to the window.
+ * If it is not contiguous, the current prefix becomes the extDict, and we
+ * forget about the extDict. Handles overlap of the prefix and extDict.
+ * Returns non-zero if the segment is contiguous.
+ */
+MEM_STATIC U32 ZSTD_window_update(ZSTD_window_t* window,
                                   void const* src, size_t srcSize,
                                   int forceNonContiguous)
-{ 
-    BYTE const* const ip = (BYTE const*)src; 
-    U32 contiguous = 1; 
+{
+    BYTE const* const ip = (BYTE const*)src;
+    U32 contiguous = 1;
     DEBUGLOG(5, "ZSTD_window_update");
     if (srcSize == 0)
         return contiguous;
     assert(window->base != NULL);
     assert(window->dictBase != NULL);
-    /* Check if blocks follow each other */ 
+    /* Check if blocks follow each other */
     if (src != window->nextSrc || forceNonContiguous) {
-        /* not contiguous */ 
-        size_t const distanceFromBase = (size_t)(window->nextSrc - window->base); 
+        /* not contiguous */
+        size_t const distanceFromBase = (size_t)(window->nextSrc - window->base);
         DEBUGLOG(5, "Non contiguous blocks, new segment starts at %u", window->dictLimit);
-        window->lowLimit = window->dictLimit; 
-        assert(distanceFromBase == (size_t)(U32)distanceFromBase);  /* should never overflow */ 
-        window->dictLimit = (U32)distanceFromBase; 
-        window->dictBase = window->base; 
-        window->base = ip - distanceFromBase; 
+        window->lowLimit = window->dictLimit;
+        assert(distanceFromBase == (size_t)(U32)distanceFromBase);  /* should never overflow */
+        window->dictLimit = (U32)distanceFromBase;
+        window->dictBase = window->base;
+        window->base = ip - distanceFromBase;
         /* ms->nextToUpdate = window->dictLimit; */
-        if (window->dictLimit - window->lowLimit < HASH_READ_SIZE) window->lowLimit = window->dictLimit;   /* too small extDict */ 
-        contiguous = 0; 
-    } 
-    window->nextSrc = ip + srcSize; 
-    /* if input and dictionary overlap : reduce dictionary (area presumed modified by input) */ 
-    if ( (ip+srcSize > window->dictBase + window->lowLimit) 
-       & (ip < window->dictBase + window->dictLimit)) { 
-        ptrdiff_t const highInputIdx = (ip + srcSize) - window->dictBase; 
-        U32 const lowLimitMax = (highInputIdx > (ptrdiff_t)window->dictLimit) ? window->dictLimit : (U32)highInputIdx; 
-        window->lowLimit = lowLimitMax; 
+        if (window->dictLimit - window->lowLimit < HASH_READ_SIZE) window->lowLimit = window->dictLimit;   /* too small extDict */
+        contiguous = 0;
+    }
+    window->nextSrc = ip + srcSize;
+    /* if input and dictionary overlap : reduce dictionary (area presumed modified by input) */
+    if ( (ip+srcSize > window->dictBase + window->lowLimit)
+       & (ip < window->dictBase + window->dictLimit)) {
+        ptrdiff_t const highInputIdx = (ip + srcSize) - window->dictBase;
+        U32 const lowLimitMax = (highInputIdx > (ptrdiff_t)window->dictLimit) ? window->dictLimit : (U32)highInputIdx;
+        window->lowLimit = lowLimitMax;
         DEBUGLOG(5, "Overlapping extDict and input : new lowLimit = %u", window->lowLimit);
-    } 
-    return contiguous; 
-} 
- 
+    }
+    return contiguous;
+}
+
 /**
  * Returns the lowest allowed match index. It may either be in the ext-dict or the prefix.
  */
@@ -1359,15 +1359,15 @@ MEM_STATIC void ZSTD_debugTable(const U32* table, U32 max)
 #endif
 
 
-#if defined (__cplusplus) 
-} 
-#endif 
- 
+#if defined (__cplusplus)
+}
+#endif
+
 /* ===============================================================
  * Shared internal declarations
  * These prototypes may be called from sources not in lib/compress
  * =============================================================== */
- 
+
 /* ZSTD_loadCEntropy() :
  * dict : must point at beginning of a valid zstd dictionary.
  * return : size of dictionary header (size of magic number + dict ID + entropy tables)
@@ -1378,81 +1378,81 @@ size_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,
 
 void ZSTD_reset_compressedBlockState(ZSTD_compressedBlockState_t* bs);
 
-/* ============================================================== 
- * Private declarations 
- * These prototypes shall only be called from within lib/compress 
- * ============================================================== */ 
- 
-/* ZSTD_getCParamsFromCCtxParams() : 
+/* ==============================================================
+ * Private declarations
+ * These prototypes shall only be called from within lib/compress
+ * ============================================================== */
+
+/* ZSTD_getCParamsFromCCtxParams() :
  * cParams are built depending on compressionLevel, src size hints,
- * LDM and manually set compression parameters. 
+ * LDM and manually set compression parameters.
  * Note: srcSizeHint == 0 means 0!
- */ 
-ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams( 
+ */
+ZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(
         const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize, ZSTD_cParamMode_e mode);
- 
-/*! ZSTD_initCStream_internal() : 
- *  Private use only. Init streaming operation. 
- *  expects params to be valid. 
- *  must receive dict, or cdict, or none, but not both. 
- *  @return : 0, or an error code */ 
-size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs, 
-                     const void* dict, size_t dictSize, 
-                     const ZSTD_CDict* cdict, 
+
+/*! ZSTD_initCStream_internal() :
+ *  Private use only. Init streaming operation.
+ *  expects params to be valid.
+ *  must receive dict, or cdict, or none, but not both.
+ *  @return : 0, or an error code */
+size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
+                     const void* dict, size_t dictSize,
+                     const ZSTD_CDict* cdict,
                      const ZSTD_CCtx_params* params, unsigned long long pledgedSrcSize);
- 
+
 void ZSTD_resetSeqStore(seqStore_t* ssPtr);
- 
-/*! ZSTD_getCParamsFromCDict() : 
- *  as the name implies */ 
-ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict); 
- 
-/* ZSTD_compressBegin_advanced_internal() : 
- * Private use only. To be called from zstdmt_compress.c. */ 
-size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx, 
-                                    const void* dict, size_t dictSize, 
-                                    ZSTD_dictContentType_e dictContentType, 
+
+/*! ZSTD_getCParamsFromCDict() :
+ *  as the name implies */
+ZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict);
+
+/* ZSTD_compressBegin_advanced_internal() :
+ * Private use only. To be called from zstdmt_compress.c. */
+size_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,
+                                    const void* dict, size_t dictSize,
+                                    ZSTD_dictContentType_e dictContentType,
                                     ZSTD_dictTableLoadMethod_e dtlm,
-                                    const ZSTD_CDict* cdict, 
+                                    const ZSTD_CDict* cdict,
                                     const ZSTD_CCtx_params* params,
-                                    unsigned long long pledgedSrcSize); 
- 
-/* ZSTD_compress_advanced_internal() : 
- * Private use only. To be called from zstdmt_compress.c. */ 
-size_t ZSTD_compress_advanced_internal(ZSTD_CCtx* cctx, 
-                                       void* dst, size_t dstCapacity, 
-                                 const void* src, size_t srcSize, 
-                                 const void* dict,size_t dictSize, 
+                                    unsigned long long pledgedSrcSize);
+
+/* ZSTD_compress_advanced_internal() :
+ * Private use only. To be called from zstdmt_compress.c. */
+size_t ZSTD_compress_advanced_internal(ZSTD_CCtx* cctx,
+                                       void* dst, size_t dstCapacity,
+                                 const void* src, size_t srcSize,
+                                 const void* dict,size_t dictSize,
                                  const ZSTD_CCtx_params* params);
- 
- 
-/* ZSTD_writeLastEmptyBlock() : 
- * output an empty Block with end-of-frame mark to complete a frame 
- * @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h)) 
+
+
+/* ZSTD_writeLastEmptyBlock() :
+ * output an empty Block with end-of-frame mark to complete a frame
+ * @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h))
  *           or an error code if `dstCapacity` is too small (<ZSTD_blockHeaderSize)
- */ 
-size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity); 
- 
- 
-/* ZSTD_referenceExternalSequences() : 
- * Must be called before starting a compression operation. 
- * seqs must parse a prefix of the source. 
- * This cannot be used when long range matching is enabled. 
- * Zstd will use these sequences, and pass the literals to a secondary block 
- * compressor. 
- * @return : An error code on failure. 
- * NOTE: seqs are not verified! Invalid sequences can cause out-of-bounds memory 
- * access and data corruption. 
- */ 
-size_t ZSTD_referenceExternalSequences(ZSTD_CCtx* cctx, rawSeq* seq, size_t nbSeq); 
- 
+ */
+size_t ZSTD_writeLastEmptyBlock(void* dst, size_t dstCapacity);
+
+
+/* ZSTD_referenceExternalSequences() :
+ * Must be called before starting a compression operation.
+ * seqs must parse a prefix of the source.
+ * This cannot be used when long range matching is enabled.
+ * Zstd will use these sequences, and pass the literals to a secondary block
+ * compressor.
+ * @return : An error code on failure.
+ * NOTE: seqs are not verified! Invalid sequences can cause out-of-bounds memory
+ * access and data corruption.
+ */
+size_t ZSTD_referenceExternalSequences(ZSTD_CCtx* cctx, rawSeq* seq, size_t nbSeq);
+
 /** ZSTD_cycleLog() :
  *  condition for correct operation : hashLog > 1 */
 U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat);
- 
+
 /** ZSTD_CCtx_trace() :
  *  Trace the end of a compression call.
  */
 void ZSTD_CCtx_trace(ZSTD_CCtx* cctx, size_t extraCSize);
 
-#endif /* ZSTD_COMPRESS_H */ 
+#endif /* ZSTD_COMPRESS_H */