feat(rust): port block entropy statistics

Continue the incremental zstd_compress.c migration with its sequence
statistics and seqStore entropy-compression layer.  The following now
live in rust/src/zstd_compress_stats.rs:

- ZSTD_seqToCodes(), exported under its original name because the C
  dictionary builder (zdict.c) and decodecorpus link against it,
- ZSTD_buildSequencesStatistics() and its dummy variant, whose result
  struct no longer crosses the language boundary,
- ZSTD_entropyCompressSeqStore_internal(), _wExtLitBuffer(), and
  ZSTD_entropyCompressSeqStore(),
- ZSTD_buildBlockEntropyStats() with its literals/sequences helpers,
- ZSTD_copyBlockSequences() and the ZSTD_updateRep() rules it shares
  with the superblock writer.

Boundary: ZSTD_CCtx and ZSTD_CCtx_params stay private to C.  These
paths read exactly two parameter fields, so the C shims keep the
original static/exported function names and forward the strategy and
ZSTD_literalsCompressionIsDisabled() as int scalars alongside the
seqStore and entropy-table leaves.  The leaf layouts (SeqDef,
SeqStore_t, ZSTD_hufCTables_t, ZSTD_fseCTables_t, entropy metadata,
SeqCollector, ZSTD_Sequence) are pinned by compile-time asserts in
zstd_compress.c and by both-pointer-width layout tests in Rust.
ZSTD_buildSeqStore, block dispatch/splitting, and the block-size
estimation helpers remain C for a later slice.

The superblock module previously round-tripped through the C export of
ZSTD_buildBlockEntropyStats and mirrored the entropy leaf structs
privately.  It now calls the crate-internal builder directly, and the
shared struct definitions moved to zstd_compress_stats; consequently
ZSTD_rust_compressSuperBlock() takes the two parameter scalars instead
of an opaque ZSTD_CCtx_params pointer, extracted by its C shim.  Its
layout and repcode tests moved with the definitions.

One C helper family gets no shim: the static
ZSTD_entropyCompressSeqStore_wExtLitBuffer() had a single caller and
was folded into the Rust implementation.

Byte-identity was verified against the pre-change compressor: COPYING,
datagen -g5000000 -s7, and datagen -g300000 -s21 -P90, each at levels
1/3/9/19 and --fast=5, plus a superblock-heavy pass at level 19 with
--target-compressed-block-size=1024; all 18 frames are byte-identical,
covering the repeat-mode state machine, longOffsets, RLE/raw fallback,
and dstSize_tooSmall paths through the block splitter and superblock.

Test plan:
- cd rust && cargo fmt --check && cargo clippy --all-targets -- -D
  warnings && cargo test --all-targets (131 tests: new reference
  vectors for seqToCodes, RLE table headers, empty-seqStore repeat
  copies, literal-stats type selection, and repcode resolution in
  copyBlockSequences)
- cargo build --release --no-default-features --features compression
  and --features decompression
- make -C tests fuzzer && ./tests/fuzzer -i1 --no-big-tests (covers
  ZSTD_generateSequences and ZDICT training over the Rust seqToCodes)
- make -C tests test-rust-lib-smoke
- ./tests/zstreamtest -i1 and ./tests/zstreamtest --newapi -t1 -i1
- ./tests/decodecorpus -t -T1s (decodecorpus links Rust seqToCodes)
- /tmp/ref vs /tmp/got frame diff as described above: byte-identical

build/cmake/lib/CMakeLists.txt

@@ -142,7 +142,6 @@ endif()
 set(_zstd_rust_features)
 set(_zstd_rust_compression 0)
 set(_zstd_rust_decompression 0)
-set(_zstd_rust_dictbuilder 0)
 if(ZSTD_BUILD_COMPRESSION)
     list(APPEND _zstd_rust_features compression)
     set(_zstd_rust_compression 1)
@@ -151,10 +150,6 @@ if(ZSTD_BUILD_DECOMPRESSION)
     list(APPEND _zstd_rust_features decompression)
     set(_zstd_rust_decompression 1)
 endif()
-if(ZSTD_BUILD_DICTBUILDER)
-    list(APPEND _zstd_rust_features dict-builder)
-    set(_zstd_rust_dictbuilder 1)
-endif()
 
 set(_zstd_rust_huf_mode default)
 if(_zstd_huf_force_x1)
@@ -195,7 +190,7 @@ if(_zstd_rust_features)
 endif()
 
 set(_zstd_rust_build_config
-    "c${_zstd_rust_compression}-d${_zstd_rust_decompression}-b${_zstd_rust_dictbuilder}-${_zstd_rust_huf_mode}")
+    "c${_zstd_rust_compression}-d${_zstd_rust_decompression}-${_zstd_rust_huf_mode}")
 set(ZSTD_RUST_MANIFEST "${ZSTD_SOURCE_DIR}/rust/Cargo.toml")
 set(ZSTD_RUST_TARGET_DIR
     "${CMAKE_CURRENT_BINARY_DIR}/rust-target/${_zstd_rust_build_config}")

build/meson/lib/meson.build

@@ -73,9 +73,7 @@ if rust_huf_force_x1 and rust_huf_force_x2
   error('HUF_FORCE_DECOMPRESS_X1 and HUF_FORCE_DECOMPRESS_X2 are mutually exclusive')
 endif
 
-# Meson always compiles the dictBuilder sources above, so the Rust archive
+rust_features = ['compression', 'decompression']
-# must always carry the matching dict-builder module set.
-rust_features = ['compression', 'decompression', 'dict-builder']
 rust_huf_mode = 'default'
 rust_huf_c_args = []
 if rust_huf_force_x1
@@ -98,7 +96,7 @@ if rust_target == ''
   endif
 endif
 
-rust_build_config = 'c1-d1-b1-' + rust_huf_mode
+rust_build_config = 'c1-d1-' + rust_huf_mode
 rust_target_dir = join_paths(meson.current_build_dir(), 'rust-target', rust_build_config)
 is_msvc = cc_id == compiler_msvc or cc_id == 'clang-cl'
 rust_staticlib_name = is_msvc ? 'zstd_rs.lib' : 'libzstd_rs.a'

lib/Makefile

@@ -84,20 +84,16 @@ endif
 ifneq ($(ZSTD_LIB_DECOMPRESSION),0)
 RUST_CARGO_FEATURES += decompression
 endif
-ifneq ($(ZSTD_LIB_DICTBUILDER),0)
-RUST_CARGO_FEATURES += dict-builder
-endif
 
-RUST_MODULE_CONFIG := c$(ZSTD_LIB_COMPRESSION)-d$(ZSTD_LIB_DECOMPRESSION)-b$(ZSTD_LIB_DICTBUILDER)
 RUST_HUF_FEATURE :=
-RUST_BUILD_CONFIG := $(RUST_MODULE_CONFIG)-default
+RUST_BUILD_CONFIG := c$(ZSTD_LIB_COMPRESSION)-d$(ZSTD_LIB_DECOMPRESSION)-default
 ifneq ($(RUST_HUF_FORCE_X1),0)
 RUST_HUF_FEATURE := huf-force-decompress-x1
-RUST_BUILD_CONFIG := $(RUST_MODULE_CONFIG)-huf-force-decompress-x1
+RUST_BUILD_CONFIG := c$(ZSTD_LIB_COMPRESSION)-d$(ZSTD_LIB_DECOMPRESSION)-huf-force-decompress-x1
 endif
 ifneq ($(RUST_HUF_FORCE_X2),0)
 RUST_HUF_FEATURE := huf-force-decompress-x2
-RUST_BUILD_CONFIG := $(RUST_MODULE_CONFIG)-huf-force-decompress-x2
+RUST_BUILD_CONFIG := c$(ZSTD_LIB_COMPRESSION)-d$(ZSTD_LIB_DECOMPRESSION)-huf-force-decompress-x2
 endif
 ifneq ($(RUST_HUF_FEATURE),)
 ifneq ($(ZSTD_LIB_DECOMPRESSION),0)

lib/compress/zstd_compress.c

@@ -38,6 +38,123 @@ size_t ZSTD_rust_writeFrameHeader(void* dst, size_t dstCapacity,
                                   U32 windowLog, U64 pledgedSrcSize,
                                   U32 dictID);
 
+/* Context-free compression-parameter selection and sizing leaves live in
+ * Rust (rust/src/zstd_compress_params.rs).  This file retains
+ * configuration-sensitive policy: the excluded-block-compressor strategy
+ * cascade, private ZSTD_CCtx_params handling, and sanitizer workspace
+ * policy, which it feeds to the leaves as explicit scalar inputs.  The
+ * ZSTD_CParamMode_e and ZSTD_ParamSwitch_e enums are passed as int; the
+ * Rust side mirrors their values. */
+int ZSTD_rust_params_maxCLevel(void);
+int ZSTD_rust_params_minCLevel(void);
+int ZSTD_rust_params_defaultCLevel(void);
+ZSTD_bounds ZSTD_rust_params_getBounds(int param);
+size_t ZSTD_rust_params_checkCParams(ZSTD_compressionParameters cParams);
+ZSTD_compressionParameters
+ZSTD_rust_params_clampCParams(ZSTD_compressionParameters cParams);
+U32 ZSTD_rust_params_cycleLog(U32 hashLog, int strategy);
+ZSTD_compressionParameters
+ZSTD_rust_params_selectCParams(int compressionLevel, U64 srcSizeHint,
+                               size_t dictSize, int mode);
+ZSTD_compressionParameters
+ZSTD_rust_params_adjustCParams(ZSTD_compressionParameters cParams, U64 srcSize,
+                               size_t dictSize, int mode,
+                               int useRowMatchFinder);
+ZSTD_parameters ZSTD_rust_params_makeParams(ZSTD_compressionParameters cParams);
+size_t ZSTD_rust_params_maxNbSeq(size_t blockSize, U32 minMatch,
+                                 int useSequenceProducer);
+size_t ZSTD_rust_params_resolveMaxBlockSize(size_t maxBlockSize);
+
+typedef struct {
+    U32 hashLog3Max;
+    size_t matchTSize;
+    size_t optimalTSize;
+    size_t asanRedzoneSize;
+} ZSTD_rustMatchStateSizing;
+size_t ZSTD_rust_params_estimateMatchStateSize(
+        ZSTD_compressionParameters cParams, int useRowMatchFinder,
+        int enableDedicatedDictSearch, U32 forCCtx,
+        const ZSTD_rustMatchStateSizing* sizing);
+
+typedef struct {
+    size_t cdictSize;
+    size_t hufWorkspaceSize;
+    U32 hashLog3Max;
+    size_t matchTSize;
+    size_t optimalTSize;
+    size_t asanRedzoneSize;
+} ZSTD_rustCDictSizing;
+size_t ZSTD_rust_params_estimateCDictSizeFromCParams(
+        size_t dictSize, ZSTD_compressionParameters cParams,
+        int dictLoadMethod, const ZSTD_rustCDictSizing* sizing);
+
+/* Sequence statistics and seqStore entropy compression live in Rust
+ * (rust/src/zstd_compress_stats.rs), which also exports ZSTD_seqToCodes()
+ * under its original name.  The shims below extract the sequence store, the
+ * entropy-table leaves, and the only two ZSTD_CCtx_params fields these paths
+ * read (the strategy and the literals-compression switch), so the private
+ * parameter structure layout never crosses the language boundary.  The
+ * shared leaf layouts are pinned by the compile-time asserts that follow. */
+size_t ZSTD_rust_entropyCompressSeqStore_internal(
+        void* dst, size_t dstCapacity,
+        const void* literals, size_t litSize,
+        const SeqStore_t* seqStorePtr,
+        const ZSTD_entropyCTables_t* prevEntropy,
+        ZSTD_entropyCTables_t* nextEntropy,
+        int strategy, int disableLiteralCompression,
+        void* entropyWorkspace, size_t entropyWkspSize,
+        int bmi2);
+size_t ZSTD_rust_entropyCompressSeqStore(
+        const SeqStore_t* seqStorePtr,
+        const ZSTD_entropyCTables_t* prevEntropy,
+        ZSTD_entropyCTables_t* nextEntropy,
+        int strategy, int disableLiteralCompression,
+        void* dst, size_t dstCapacity,
+        size_t srcSize,
+        void* entropyWorkspace, size_t entropyWkspSize,
+        int bmi2);
+size_t ZSTD_rust_buildBlockEntropyStats(
+        const SeqStore_t* seqStorePtr,
+        const ZSTD_entropyCTables_t* prevEntropy,
+        ZSTD_entropyCTables_t* nextEntropy,
+        int strategy, int disableLiteralCompression,
+        ZSTD_entropyCTablesMetadata_t* entropyMetadata,
+        void* workspace, size_t wkspSize);
+size_t ZSTD_rust_copyBlockSequences(
+        SeqCollector* seqCollector, const SeqStore_t* seqStore,
+        const U32 prevRepcodes[ZSTD_REP_NUM]);
+
+typedef char ZSTD_rust_stats_seqdef_layout[(sizeof(SeqDef) == 8) ? 1 : -1];
+typedef char ZSTD_rust_stats_seqstore_long_length_pos[
+        (offsetof(SeqStore_t, longLengthPos) == 9 * sizeof(size_t) + 4) ? 1 : -1];
+typedef char ZSTD_rust_stats_seqstore_layout[
+        (sizeof(SeqStore_t) == 9 * sizeof(size_t) + 8) ? 1 : -1];
+typedef char ZSTD_rust_stats_huf_layout[
+        (sizeof(ZSTD_hufCTables_t) == 258 * sizeof(size_t)) ? 1 : -1];
+typedef char ZSTD_rust_stats_fse_layout[(sizeof(ZSTD_fseCTables_t) == 3552) ? 1 : -1];
+typedef char ZSTD_rust_stats_entropy_fse_offset[
+        (offsetof(ZSTD_entropyCTables_t, fse) == sizeof(ZSTD_hufCTables_t)) ? 1 : -1];
+typedef char ZSTD_rust_stats_huf_metadata_buffer[
+        (offsetof(ZSTD_hufCTablesMetadata_t, hufDesBuffer) == 4
+         && ZSTD_MAX_HUF_HEADER_SIZE == 128) ? 1 : -1];
+typedef char ZSTD_rust_stats_fse_metadata_buffer[
+        (offsetof(ZSTD_fseCTablesMetadata_t, fseTablesBuffer) == 12
+         && ZSTD_MAX_FSE_HEADERS_SIZE == 133) ? 1 : -1];
+typedef char ZSTD_rust_stats_entropy_metadata_layout[
+        (offsetof(ZSTD_entropyCTablesMetadata_t, fseMetadata)
+                == sizeof(ZSTD_hufCTablesMetadata_t)) ? 1 : -1];
+typedef char ZSTD_rust_stats_sequence_layout[(sizeof(ZSTD_Sequence) == 16) ? 1 : -1];
+typedef char ZSTD_rust_stats_seqcollector_layout[
+        (offsetof(SeqCollector, seqStart) == sizeof(size_t)
+         && offsetof(SeqCollector, seqIndex) == 2 * sizeof(size_t)
+         && sizeof(SeqCollector) == 4 * sizeof(size_t)) ? 1 : -1];
+
+#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
+#  define ZSTD_RUST_ASAN_REDZONE_SIZE ((size_t)ZSTD_CWKSP_ASAN_REDZONE_SIZE)
+#else
+#  define ZSTD_RUST_ASAN_REDZONE_SIZE ((size_t)0)
+#endif
+
 /* ***************************************************************
 *  Tuning parameters
 *****************************************************************/
@@ -276,11 +393,7 @@ static int ZSTD_resolveExternalSequenceValidation(int mode) {
 
 /* Resolves maxBlockSize to the default if no value is present. */
 static size_t ZSTD_resolveMaxBlockSize(size_t maxBlockSize) {
-    if (maxBlockSize == 0) {
+    return ZSTD_rust_params_resolveMaxBlockSize(maxBlockSize);
-        return ZSTD_BLOCKSIZE_MAX;
-    } else {
-        return maxBlockSize;
-    }
 }
 
 static ZSTD_ParamSwitch_e ZSTD_resolveExternalRepcodeSearch(ZSTD_ParamSwitch_e value, int cLevel) {
@@ -420,45 +533,17 @@ ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param)
 
     switch(param)
     {
+    /* The compression level and the seven core compression parameters are
+     * bounded by the Rust leaf. */
     case ZSTD_c_compressionLevel:
-        bounds.lowerBound = ZSTD_minCLevel();
-        bounds.upperBound = ZSTD_maxCLevel();
-        return bounds;
-
     case ZSTD_c_windowLog:
-        bounds.lowerBound = ZSTD_WINDOWLOG_MIN;
-        bounds.upperBound = ZSTD_WINDOWLOG_MAX;
-        return bounds;
-
     case ZSTD_c_hashLog:
-        bounds.lowerBound = ZSTD_HASHLOG_MIN;
-        bounds.upperBound = ZSTD_HASHLOG_MAX;
-        return bounds;
-
     case ZSTD_c_chainLog:
-        bounds.lowerBound = ZSTD_CHAINLOG_MIN;
-        bounds.upperBound = ZSTD_CHAINLOG_MAX;
-        return bounds;
-
     case ZSTD_c_searchLog:
-        bounds.lowerBound = ZSTD_SEARCHLOG_MIN;
-        bounds.upperBound = ZSTD_SEARCHLOG_MAX;
-        return bounds;
-
     case ZSTD_c_minMatch:
-        bounds.lowerBound = ZSTD_MINMATCH_MIN;
-        bounds.upperBound = ZSTD_MINMATCH_MAX;
-        return bounds;
-
     case ZSTD_c_targetLength:
-        bounds.lowerBound = ZSTD_TARGETLENGTH_MIN;
-        bounds.upperBound = ZSTD_TARGETLENGTH_MAX;
-        return bounds;
-
     case ZSTD_c_strategy:
-        bounds.lowerBound = ZSTD_STRATEGY_MIN;
+        return ZSTD_rust_params_getBounds((int)param);
-        bounds.upperBound = ZSTD_STRATEGY_MAX;
-        return bounds;
 
     case ZSTD_c_contentSizeFlag:
         bounds.lowerBound = 0;
@@ -1385,14 +1470,7 @@ size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset)
     @return : 0, or an error code if one value is beyond authorized range */
 size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
 {
-    BOUNDCHECK(ZSTD_c_windowLog, (int)cParams.windowLog);
+    return ZSTD_rust_params_checkCParams(cParams);
-    BOUNDCHECK(ZSTD_c_chainLog,  (int)cParams.chainLog);
-    BOUNDCHECK(ZSTD_c_hashLog,   (int)cParams.hashLog);
-    BOUNDCHECK(ZSTD_c_searchLog, (int)cParams.searchLog);
-    BOUNDCHECK(ZSTD_c_minMatch,  (int)cParams.minMatch);
-    BOUNDCHECK(ZSTD_c_targetLength,(int)cParams.targetLength);
-    BOUNDCHECK(ZSTD_c_strategy,  (int)cParams.strategy);
-    return 0;
 }
 
 /** ZSTD_clampCParams() :
@@ -1401,63 +1479,14 @@ size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
 static ZSTD_compressionParameters
 ZSTD_clampCParams(ZSTD_compressionParameters cParams)
 {
-#   define CLAMP_TYPE(cParam, val, type)                                      \
+    return ZSTD_rust_params_clampCParams(cParams);
-        do {                                                                  \
-            ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);         \
-            if ((int)val<bounds.lowerBound) val=(type)bounds.lowerBound;      \
-            else if ((int)val>bounds.upperBound) val=(type)bounds.upperBound; \
-        } while (0)
-#   define CLAMP(cParam, val) CLAMP_TYPE(cParam, val, unsigned)
-    CLAMP(ZSTD_c_windowLog, cParams.windowLog);
-    CLAMP(ZSTD_c_chainLog,  cParams.chainLog);
-    CLAMP(ZSTD_c_hashLog,   cParams.hashLog);
-    CLAMP(ZSTD_c_searchLog, cParams.searchLog);
-    CLAMP(ZSTD_c_minMatch,  cParams.minMatch);
-    CLAMP(ZSTD_c_targetLength,cParams.targetLength);
-    CLAMP_TYPE(ZSTD_c_strategy,cParams.strategy, ZSTD_strategy);
-    return cParams;
 }
 
 /** ZSTD_cycleLog() :
  *  condition for correct operation : hashLog > 1 */
 U32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat)
 {
-    U32 const btScale = ((U32)strat >= (U32)ZSTD_btlazy2);
+    return ZSTD_rust_params_cycleLog(hashLog, (int)strat);
-    return hashLog - btScale;
-}
-
-/** ZSTD_dictAndWindowLog() :
- * Returns an adjusted window log that is large enough to fit the source and the dictionary.
- * The zstd format says that the entire dictionary is valid if one byte of the dictionary
- * is within the window. So the hashLog and chainLog should be large enough to reference both
- * the dictionary and the window. So we must use this adjusted dictAndWindowLog when downsizing
- * the hashLog and windowLog.
- * NOTE: srcSize must not be ZSTD_CONTENTSIZE_UNKNOWN.
- */
-static U32 ZSTD_dictAndWindowLog(U32 windowLog, U64 srcSize, U64 dictSize)
-{
-    const U64 maxWindowSize = 1ULL << ZSTD_WINDOWLOG_MAX;
-    /* No dictionary ==> No change */
-    if (dictSize == 0) {
-        return windowLog;
-    }
-    assert(windowLog <= ZSTD_WINDOWLOG_MAX);
-    assert(srcSize != ZSTD_CONTENTSIZE_UNKNOWN); /* Handled in ZSTD_adjustCParams_internal() */
-    {
-        U64 const windowSize = 1ULL << windowLog;
-        U64 const dictAndWindowSize = dictSize + windowSize;
-        /* If the window size is already large enough to fit both the source and the dictionary
-         * then just use the window size. Otherwise adjust so that it fits the dictionary and
-         * the window.
-         */
-        if (windowSize >= dictSize + srcSize) {
-            return windowLog; /* Window size large enough already */
-        } else if (dictAndWindowSize >= maxWindowSize) {
-            return ZSTD_WINDOWLOG_MAX; /* Larger than max window log */
-        } else  {
-            return ZSTD_highbit32((U32)dictAndWindowSize - 1) + 1;
-        }
-    }
 }
 
 /** ZSTD_adjustCParams_internal() :
@@ -1474,8 +1503,6 @@ ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,
                             ZSTD_CParamMode_e mode,
                             ZSTD_ParamSwitch_e useRowMatchFinder)
 {
-    const U64 minSrcSize = 513; /* (1<<9) + 1 */
-    const U64 maxWindowResize = 1ULL << (ZSTD_WINDOWLOG_MAX-1);
     assert(ZSTD_checkCParams(cPar)==0);
 
     /* Cascade the selected strategy down to the next-highest one built into
@@ -1520,90 +1547,13 @@ ZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,
     }
 #endif
 
-    switch (mode) {
+    /* The remaining adjustment logic is context-free and lives in Rust.  The
-    case ZSTD_cpm_unknown:
+     * short-cache and row-hash tag widths the leaf assumes are fixed
-    case ZSTD_cpm_noAttachDict:
+     * private-header constants; keep them checked here. */
-        /* If we don't know the source size, don't make any
+    ZSTD_STATIC_ASSERT(ZSTD_SHORT_CACHE_TAG_BITS == 8);
-         * assumptions about it. We will already have selected
+    ZSTD_STATIC_ASSERT(ZSTD_ROW_HASH_TAG_BITS == 8);
-         * smaller parameters if a dictionary is in use.
+    return ZSTD_rust_params_adjustCParams(cPar, (U64)srcSize, dictSize,
-         */
+                                          (int)mode, (int)useRowMatchFinder);
-        break;
-    case ZSTD_cpm_createCDict:
-        /* Assume a small source size when creating a dictionary
-         * with an unknown source size.
-         */
-        if (dictSize && srcSize == ZSTD_CONTENTSIZE_UNKNOWN)
-            srcSize = minSrcSize;
-        break;
-    case ZSTD_cpm_attachDict:
-        /* Dictionary has its own dedicated parameters which have
-         * already been selected. We are selecting parameters
-         * for only the source.
-         */
-        dictSize = 0;
-        break;
-    default:
-        assert(0);
-        break;
-    }
-
-    /* resize windowLog if input is small enough, to use less memory */
-    if ( (srcSize <= maxWindowResize)
-      && (dictSize <= maxWindowResize) )  {
-        U32 const tSize = (U32)(srcSize + dictSize);
-        static U32 const hashSizeMin = 1 << ZSTD_HASHLOG_MIN;
-        U32 const srcLog = (tSize < hashSizeMin) ? ZSTD_HASHLOG_MIN :
-                            ZSTD_highbit32(tSize-1) + 1;
-        if (cPar.windowLog > srcLog) cPar.windowLog = srcLog;
-    }
-    if (srcSize != ZSTD_CONTENTSIZE_UNKNOWN) {
-        U32 const dictAndWindowLog = ZSTD_dictAndWindowLog(cPar.windowLog, (U64)srcSize, (U64)dictSize);
-        U32 const cycleLog = ZSTD_cycleLog(cPar.chainLog, cPar.strategy);
-        if (cPar.hashLog > dictAndWindowLog+1) cPar.hashLog = dictAndWindowLog+1;
-        if (cycleLog > dictAndWindowLog)
-            cPar.chainLog -= (cycleLog - dictAndWindowLog);
-    }
-
-    if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN)
-        cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* minimum wlog required for valid frame header */
-
-    /* We can't use more than 32 bits of hash in total, so that means that we require:
-     * (hashLog + 8) <= 32 && (chainLog + 8) <= 32
-     */
-    if (mode == ZSTD_cpm_createCDict && ZSTD_CDictIndicesAreTagged(&cPar)) {
-        U32 const maxShortCacheHashLog = 32 - ZSTD_SHORT_CACHE_TAG_BITS;
-        if (cPar.hashLog > maxShortCacheHashLog) {
-            cPar.hashLog = maxShortCacheHashLog;
-        }
-        if (cPar.chainLog > maxShortCacheHashLog) {
-            cPar.chainLog = maxShortCacheHashLog;
-        }
-    }
-
-
-    /* At this point, we aren't 100% sure if we are using the row match finder.
-     * Unless it is explicitly disabled, conservatively assume that it is enabled.
-     * In this case it will only be disabled for small sources, so shrinking the
-     * hash log a little bit shouldn't result in any ratio loss.
-     */
-    if (useRowMatchFinder == ZSTD_ps_auto)
-        useRowMatchFinder = ZSTD_ps_enable;
-
-    /* We can't hash more than 32-bits in total. So that means that we require:
-     * (hashLog - rowLog + 8) <= 32
-     */
-    if (ZSTD_rowMatchFinderUsed(cPar.strategy, useRowMatchFinder)) {
-        /* Switch to 32-entry rows if searchLog is 5 (or more) */
-        U32 const rowLog = BOUNDED(4, cPar.searchLog, 6);
-        U32 const maxRowHashLog = 32 - ZSTD_ROW_HASH_TAG_BITS;
-        U32 const maxHashLog = maxRowHashLog + rowLog;
-        assert(cPar.hashLog >= rowLog);
-        if (cPar.hashLog > maxHashLog) {
-            cPar.hashLog = maxHashLog;
-        }
-    }
-
-    return cPar;
 }
 
 ZSTD_compressionParameters
@@ -1654,47 +1604,31 @@ ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams,
                        const int enableDedicatedDictSearch,
                        const U32 forCCtx)
 {
-    /* chain table size should be 0 for fast or row-hash strategies */
+    ZSTD_rustMatchStateSizing sizing;
-    size_t const chainSize = ZSTD_allocateChainTable(cParams->strategy, useRowMatchFinder, enableDedicatedDictSearch && !forCCtx)
+    sizing.hashLog3Max = ZSTD_HASHLOG3_MAX;
-                                ? ((size_t)1 << cParams->chainLog)
+    sizing.matchTSize = sizeof(ZSTD_match_t);
-                                : 0;
+    sizing.optimalTSize = sizeof(ZSTD_optimal_t);
-    size_t const hSize = ((size_t)1) << cParams->hashLog;
+    sizing.asanRedzoneSize = ZSTD_RUST_ASAN_REDZONE_SIZE;
-    U32    const hashLog3 = (forCCtx && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;
-    size_t const h3Size = hashLog3 ? ((size_t)1) << hashLog3 : 0;
-    /* We don't use ZSTD_cwksp_alloc_size() here because the tables aren't
-     * surrounded by redzones in ASAN. */
-    size_t const tableSpace = chainSize * sizeof(U32)
-                            + hSize * sizeof(U32)
-                            + h3Size * sizeof(U32);
-    size_t const optPotentialSpace =
-        ZSTD_cwksp_aligned64_alloc_size((MaxML+1) * sizeof(U32))
-      + ZSTD_cwksp_aligned64_alloc_size((MaxLL+1) * sizeof(U32))
-      + ZSTD_cwksp_aligned64_alloc_size((MaxOff+1) * sizeof(U32))
-      + ZSTD_cwksp_aligned64_alloc_size((1<<Litbits) * sizeof(U32))
-      + ZSTD_cwksp_aligned64_alloc_size(ZSTD_OPT_SIZE * sizeof(ZSTD_match_t))
-      + ZSTD_cwksp_aligned64_alloc_size(ZSTD_OPT_SIZE * sizeof(ZSTD_optimal_t));
-    size_t const lazyAdditionalSpace = ZSTD_rowMatchFinderUsed(cParams->strategy, useRowMatchFinder)
-                                            ? ZSTD_cwksp_aligned64_alloc_size(hSize)
-                                            : 0;
-    size_t const optSpace = (forCCtx && (cParams->strategy >= ZSTD_btopt))
-                                ? optPotentialSpace
-                                : 0;
-    size_t const slackSpace = ZSTD_cwksp_slack_space_required();
 
+    /* The Rust leaf hardcodes the frozen format bounds and workspace rules;
+     * keep them checked against the private headers here. */
+    ZSTD_STATIC_ASSERT(MaxML == 52 && MaxLL == 35 && MaxOff == 31);
+    ZSTD_STATIC_ASSERT(Litbits == 8 && ZSTD_OPT_SIZE == 4099);
+    ZSTD_STATIC_ASSERT(ZSTD_CWKSP_ALIGNMENT_BYTES == 64);
     /* tables are guaranteed to be sized in multiples of 64 bytes (or 16 uint32_t) */
     ZSTD_STATIC_ASSERT(ZSTD_HASHLOG_MIN >= 4 && ZSTD_WINDOWLOG_MIN >= 4 && ZSTD_CHAINLOG_MIN >= 4);
     assert(useRowMatchFinder != ZSTD_ps_auto);
 
-    DEBUGLOG(4, "chainSize: %u - hSize: %u - h3Size: %u",
+    return ZSTD_rust_params_estimateMatchStateSize(*cParams,
-                (U32)chainSize, (U32)hSize, (U32)h3Size);
+                                                   (int)useRowMatchFinder,
-    return tableSpace + optSpace + slackSpace + lazyAdditionalSpace;
+                                                   enableDedicatedDictSearch,
+                                                   forCCtx, &sizing);
 }
 
 /* Helper function for calculating memory requirements.
  * Gives a tighter bound than ZSTD_sequenceBound() by taking minMatch into account. */
 static size_t ZSTD_maxNbSeq(size_t blockSize, unsigned minMatch, int useSequenceProducer) {
-    U32 const divider = (minMatch==3 || useSequenceProducer) ? 3 : 4;
+    return ZSTD_rust_params_maxNbSeq(blockSize, minMatch, useSequenceProducer);
-    return blockSize / divider;
 }
 
 static size_t ZSTD_estimateCCtxSize_usingCCtxParams_internal(
@@ -2688,33 +2622,7 @@ static void ZSTD_reduceIndex (ZSTD_MatchState_t* ms, ZSTD_CCtx_params const* par
 
 /* See doc/zstd_compression_format.md for detailed format description */
 
-int ZSTD_seqToCodes(const SeqStore_t* seqStorePtr)
+/* ZSTD_seqToCodes() lives in rust/src/zstd_compress_stats.rs. */
-{
-    const SeqDef* const sequences = seqStorePtr->sequencesStart;
-    BYTE* const llCodeTable = seqStorePtr->llCode;
-    BYTE* const ofCodeTable = seqStorePtr->ofCode;
-    BYTE* const mlCodeTable = seqStorePtr->mlCode;
-    U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-    U32 u;
-    int longOffsets = 0;
-    assert(nbSeq <= seqStorePtr->maxNbSeq);
-    for (u=0; u<nbSeq; u++) {
-        U32 const llv = sequences[u].litLength;
-        U32 const ofCode = ZSTD_highbit32(sequences[u].offBase);
-        U32 const mlv = sequences[u].mlBase;
-        llCodeTable[u] = (BYTE)ZSTD_LLcode(llv);
-        ofCodeTable[u] = (BYTE)ofCode;
-        mlCodeTable[u] = (BYTE)ZSTD_MLcode(mlv);
-        assert(!(MEM_64bits() && ofCode >= STREAM_ACCUMULATOR_MIN));
-        if (MEM_32bits() && ofCode >= STREAM_ACCUMULATOR_MIN)
-            longOffsets = 1;
-    }
-    if (seqStorePtr->longLengthType==ZSTD_llt_literalLength)
-        llCodeTable[seqStorePtr->longLengthPos] = MaxLL;
-    if (seqStorePtr->longLengthType==ZSTD_llt_matchLength)
-        mlCodeTable[seqStorePtr->longLengthPos] = MaxML;
-    return longOffsets;
-}
 
 /* ZSTD_useTargetCBlockSize():
  * Returns if target compressed block size param is being used.
@@ -2738,150 +2646,11 @@ static int ZSTD_blockSplitterEnabled(ZSTD_CCtx_params* cctxParams)
     return (cctxParams->postBlockSplitter == ZSTD_ps_enable);
 }
 
-/* Type returned by ZSTD_buildSequencesStatistics containing finalized symbol encoding types
+/* ZSTD_buildSequencesStatistics() and the ZSTD_entropyCompressSeqStore*()
- * and size of the sequences statistics
+ * implementations live in rust/src/zstd_compress_stats.rs.  The wrappers
- */
+ * below keep the original signatures and extract the only two
-typedef struct {
+ * ZSTD_CCtx_params fields those paths read. */
-    U32 LLtype;
-    U32 Offtype;
-    U32 MLtype;
-    size_t size;
-    size_t lastCountSize; /* Accounts for bug in 1.3.4. More detail in ZSTD_entropyCompressSeqStore_internal() */
-    int longOffsets;
-} ZSTD_symbolEncodingTypeStats_t;
 
-/* ZSTD_buildSequencesStatistics():
- * Returns a ZSTD_symbolEncodingTypeStats_t, or a zstd error code in the `size` field.
- * Modifies `nextEntropy` to have the appropriate values as a side effect.
- * nbSeq must be greater than 0.
- *
- * entropyWkspSize must be of size at least ENTROPY_WORKSPACE_SIZE - (MaxSeq + 1)*sizeof(U32)
- */
-static ZSTD_symbolEncodingTypeStats_t
-ZSTD_buildSequencesStatistics(
-                const SeqStore_t* seqStorePtr, size_t nbSeq,
-                const ZSTD_fseCTables_t* prevEntropy, ZSTD_fseCTables_t* nextEntropy,
-                      BYTE* dst, const BYTE* const dstEnd,
-                      ZSTD_strategy strategy, unsigned* countWorkspace,
-                      void* entropyWorkspace, size_t entropyWkspSize)
-{
-    BYTE* const ostart = dst;
-    const BYTE* const oend = dstEnd;
-    BYTE* op = ostart;
-    FSE_CTable* CTable_LitLength = nextEntropy->litlengthCTable;
-    FSE_CTable* CTable_OffsetBits = nextEntropy->offcodeCTable;
-    FSE_CTable* CTable_MatchLength = nextEntropy->matchlengthCTable;
-    const BYTE* const ofCodeTable = seqStorePtr->ofCode;
-    const BYTE* const llCodeTable = seqStorePtr->llCode;
-    const BYTE* const mlCodeTable = seqStorePtr->mlCode;
-    ZSTD_symbolEncodingTypeStats_t stats;
-
-    stats.lastCountSize = 0;
-    /* convert length/distances into codes */
-    stats.longOffsets = ZSTD_seqToCodes(seqStorePtr);
-    assert(op <= oend);
-    assert(nbSeq != 0); /* ZSTD_selectEncodingType() divides by nbSeq */
-    /* build CTable for Literal Lengths */
-    {   unsigned max = MaxLL;
-        size_t const mostFrequent = HIST_countFast_wksp(countWorkspace, &max, llCodeTable, nbSeq, entropyWorkspace, entropyWkspSize);   /* can't fail */
-        DEBUGLOG(5, "Building LL table");
-        nextEntropy->litlength_repeatMode = prevEntropy->litlength_repeatMode;
-        stats.LLtype = ZSTD_selectEncodingType(&nextEntropy->litlength_repeatMode,
-                                        countWorkspace, max, mostFrequent, nbSeq,
-                                        LLFSELog, prevEntropy->litlengthCTable,
-                                        LL_defaultNorm, LL_defaultNormLog,
-                                        ZSTD_defaultAllowed, strategy);
-        assert(set_basic < set_compressed && set_rle < set_compressed);
-        assert(!(stats.LLtype < set_compressed && nextEntropy->litlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
-        {   size_t const countSize = ZSTD_buildCTable(
-                op, (size_t)(oend - op),
-                CTable_LitLength, LLFSELog, (SymbolEncodingType_e)stats.LLtype,
-                countWorkspace, max, llCodeTable, nbSeq,
-                LL_defaultNorm, LL_defaultNormLog, MaxLL,
-                prevEntropy->litlengthCTable,
-                sizeof(prevEntropy->litlengthCTable),
-                entropyWorkspace, entropyWkspSize);
-            if (ZSTD_isError(countSize)) {
-                DEBUGLOG(3, "ZSTD_buildCTable for LitLens failed");
-                stats.size = countSize;
-                return stats;
-            }
-            if (stats.LLtype == set_compressed)
-                stats.lastCountSize = countSize;
-            op += countSize;
-            assert(op <= oend);
-    }   }
-    /* build CTable for Offsets */
-    {   unsigned max = MaxOff;
-        size_t const mostFrequent = HIST_countFast_wksp(
-            countWorkspace, &max, ofCodeTable, nbSeq, entropyWorkspace, entropyWkspSize);  /* can't fail */
-        /* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */
-        ZSTD_DefaultPolicy_e const defaultPolicy = (max <= DefaultMaxOff) ? ZSTD_defaultAllowed : ZSTD_defaultDisallowed;
-        DEBUGLOG(5, "Building OF table");
-        nextEntropy->offcode_repeatMode = prevEntropy->offcode_repeatMode;
-        stats.Offtype = ZSTD_selectEncodingType(&nextEntropy->offcode_repeatMode,
-                                        countWorkspace, max, mostFrequent, nbSeq,
-                                        OffFSELog, prevEntropy->offcodeCTable,
-                                        OF_defaultNorm, OF_defaultNormLog,
-                                        defaultPolicy, strategy);
-        assert(!(stats.Offtype < set_compressed && nextEntropy->offcode_repeatMode != FSE_repeat_none)); /* We don't copy tables */
-        {   size_t const countSize = ZSTD_buildCTable(
-                op, (size_t)(oend - op),
-                CTable_OffsetBits, OffFSELog, (SymbolEncodingType_e)stats.Offtype,
-                countWorkspace, max, ofCodeTable, nbSeq,
-                OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,
-                prevEntropy->offcodeCTable,
-                sizeof(prevEntropy->offcodeCTable),
-                entropyWorkspace, entropyWkspSize);
-            if (ZSTD_isError(countSize)) {
-                DEBUGLOG(3, "ZSTD_buildCTable for Offsets failed");
-                stats.size = countSize;
-                return stats;
-            }
-            if (stats.Offtype == set_compressed)
-                stats.lastCountSize = countSize;
-            op += countSize;
-            assert(op <= oend);
-    }   }
-    /* build CTable for MatchLengths */
-    {   unsigned max = MaxML;
-        size_t const mostFrequent = HIST_countFast_wksp(
-            countWorkspace, &max, mlCodeTable, nbSeq, entropyWorkspace, entropyWkspSize);   /* can't fail */
-        DEBUGLOG(5, "Building ML table (remaining space : %i)", (int)(oend-op));
-        nextEntropy->matchlength_repeatMode = prevEntropy->matchlength_repeatMode;
-        stats.MLtype = ZSTD_selectEncodingType(&nextEntropy->matchlength_repeatMode,
-                                        countWorkspace, max, mostFrequent, nbSeq,
-                                        MLFSELog, prevEntropy->matchlengthCTable,
-                                        ML_defaultNorm, ML_defaultNormLog,
-                                        ZSTD_defaultAllowed, strategy);
-        assert(!(stats.MLtype < set_compressed && nextEntropy->matchlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */
-        {   size_t const countSize = ZSTD_buildCTable(
-                op, (size_t)(oend - op),
-                CTable_MatchLength, MLFSELog, (SymbolEncodingType_e)stats.MLtype,
-                countWorkspace, max, mlCodeTable, nbSeq,
-                ML_defaultNorm, ML_defaultNormLog, MaxML,
-                prevEntropy->matchlengthCTable,
-                sizeof(prevEntropy->matchlengthCTable),
-                entropyWorkspace, entropyWkspSize);
-            if (ZSTD_isError(countSize)) {
-                DEBUGLOG(3, "ZSTD_buildCTable for MatchLengths failed");
-                stats.size = countSize;
-                return stats;
-            }
-            if (stats.MLtype == set_compressed)
-                stats.lastCountSize = countSize;
-            op += countSize;
-            assert(op <= oend);
-    }   }
-    stats.size = (size_t)(op-ostart);
-    return stats;
-}
-
-/* ZSTD_entropyCompressSeqStore_internal():
- * compresses both literals and sequences
- * Returns compressed size of block, or a zstd error.
- */
-#define SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO 20
 MEM_STATIC size_t
 ZSTD_entropyCompressSeqStore_internal(
                               void* dst, size_t dstCapacity,
@@ -2893,150 +2662,13 @@ ZSTD_entropyCompressSeqStore_internal(
                               void* entropyWorkspace, size_t entropyWkspSize,
                         const int bmi2)
 {
-    ZSTD_strategy const strategy = cctxParams->cParams.strategy;
+    return ZSTD_rust_entropyCompressSeqStore_internal(
-    unsigned* count = (unsigned*)entropyWorkspace;
+                dst, dstCapacity,
-    FSE_CTable* CTable_LitLength = nextEntropy->fse.litlengthCTable;
+                literals, litSize,
-    FSE_CTable* CTable_OffsetBits = nextEntropy->fse.offcodeCTable;
+                seqStorePtr, prevEntropy, nextEntropy,
-    FSE_CTable* CTable_MatchLength = nextEntropy->fse.matchlengthCTable;
+                (int)cctxParams->cParams.strategy,
-    const SeqDef* const sequences = seqStorePtr->sequencesStart;
+                ZSTD_literalsCompressionIsDisabled(cctxParams),
-    const size_t nbSeq = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
+                entropyWorkspace, entropyWkspSize, bmi2);
-    const BYTE* const ofCodeTable = seqStorePtr->ofCode;
-    const BYTE* const llCodeTable = seqStorePtr->llCode;
-    const BYTE* const mlCodeTable = seqStorePtr->mlCode;
-    BYTE* const ostart = (BYTE*)dst;
-    BYTE* const oend = ostart + dstCapacity;
-    BYTE* op = ostart;
-    size_t lastCountSize;
-    int longOffsets = 0;
-
-    entropyWorkspace = count + (MaxSeq + 1);
-    entropyWkspSize -= (MaxSeq + 1) * sizeof(*count);
-
-    DEBUGLOG(5, "ZSTD_entropyCompressSeqStore_internal (nbSeq=%zu, dstCapacity=%zu)", nbSeq, dstCapacity);
-    ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<<MAX(MLFSELog,LLFSELog)));
-    assert(entropyWkspSize >= HUF_WORKSPACE_SIZE);
-
-    /* Compress literals */
-    {   size_t const numSequences = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-        /* Base suspicion of uncompressibility on ratio of literals to sequences */
-        int const suspectUncompressible = (numSequences == 0) || (litSize / numSequences >= SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO);
-
-        size_t const cSize = ZSTD_compressLiterals(
-                                    op, dstCapacity,
-                                    literals, litSize,
-                                    entropyWorkspace, entropyWkspSize,
-                                    &prevEntropy->huf, &nextEntropy->huf,
-                                    cctxParams->cParams.strategy,
-                                    ZSTD_literalsCompressionIsDisabled(cctxParams),
-                                    suspectUncompressible, bmi2);
-        FORWARD_IF_ERROR(cSize, "ZSTD_compressLiterals failed");
-        assert(cSize <= dstCapacity);
-        op += cSize;
-    }
-
-    /* Sequences Header */
-    RETURN_ERROR_IF((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/,
-                    dstSize_tooSmall, "Can't fit seq hdr in output buf!");
-    if (nbSeq < 128) {
-        *op++ = (BYTE)nbSeq;
-    } else if (nbSeq < LONGNBSEQ) {
-        op[0] = (BYTE)((nbSeq>>8) + 0x80);
-        op[1] = (BYTE)nbSeq;
-        op+=2;
-    } else {
-        op[0]=0xFF;
-        MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ));
-        op+=3;
-    }
-    assert(op <= oend);
-    if (nbSeq==0) {
-        /* Copy the old tables over as if we repeated them */
-        ZSTD_memcpy(&nextEntropy->fse, &prevEntropy->fse, sizeof(prevEntropy->fse));
-        return (size_t)(op - ostart);
-    }
-    {   BYTE* const seqHead = op++;
-        /* build stats for sequences */
-        const ZSTD_symbolEncodingTypeStats_t stats =
-                ZSTD_buildSequencesStatistics(seqStorePtr, nbSeq,
-                                             &prevEntropy->fse, &nextEntropy->fse,
-                                              op, oend,
-                                              strategy, count,
-                                              entropyWorkspace, entropyWkspSize);
-        FORWARD_IF_ERROR(stats.size, "ZSTD_buildSequencesStatistics failed!");
-        *seqHead = (BYTE)((stats.LLtype<<6) + (stats.Offtype<<4) + (stats.MLtype<<2));
-        lastCountSize = stats.lastCountSize;
-        op += stats.size;
-        longOffsets = stats.longOffsets;
-    }
-
-    {   size_t const bitstreamSize = ZSTD_encodeSequences(
-                                        op, (size_t)(oend - op),
-                                        CTable_MatchLength, mlCodeTable,
-                                        CTable_OffsetBits, ofCodeTable,
-                                        CTable_LitLength, llCodeTable,
-                                        sequences, nbSeq,
-                                        longOffsets, bmi2);
-        FORWARD_IF_ERROR(bitstreamSize, "ZSTD_encodeSequences failed");
-        op += bitstreamSize;
-        assert(op <= oend);
-        /* zstd versions <= 1.3.4 mistakenly report corruption when
-         * FSE_readNCount() receives a buffer < 4 bytes.
-         * Fixed by https://github.com/facebook/zstd/pull/1146.
-         * This can happen when the last set_compressed table present is 2
-         * bytes and the bitstream is only one byte.
-         * In this exceedingly rare case, we will simply emit an uncompressed
-         * block, since it isn't worth optimizing.
-         */
-        if (lastCountSize && (lastCountSize + bitstreamSize) < 4) {
-            /* lastCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */
-            assert(lastCountSize + bitstreamSize == 3);
-            DEBUGLOG(5, "Avoiding bug in zstd decoder in versions <= 1.3.4 by "
-                        "emitting an uncompressed block.");
-            return 0;
-        }
-    }
-
-    DEBUGLOG(5, "compressed block size : %u", (unsigned)(op - ostart));
-    return (size_t)(op - ostart);
-}
-
-static size_t
-ZSTD_entropyCompressSeqStore_wExtLitBuffer(
-                          void* dst, size_t dstCapacity,
-                    const void* literals, size_t litSize,
-                          size_t blockSize,
-                    const SeqStore_t* seqStorePtr,
-                    const ZSTD_entropyCTables_t* prevEntropy,
-                          ZSTD_entropyCTables_t* nextEntropy,
-                    const ZSTD_CCtx_params* cctxParams,
-                          void* entropyWorkspace, size_t entropyWkspSize,
-                          int bmi2)
-{
-    size_t const cSize = ZSTD_entropyCompressSeqStore_internal(
-                            dst, dstCapacity,
-                            literals, litSize,
-                            seqStorePtr, prevEntropy, nextEntropy, cctxParams,
-                            entropyWorkspace, entropyWkspSize, bmi2);
-    if (cSize == 0) return 0;
-    /* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block.
-     * Since we ran out of space, block must be not compressible, so fall back to raw uncompressed block.
-     */
-    if ((cSize == ERROR(dstSize_tooSmall)) & (blockSize <= dstCapacity)) {
-        DEBUGLOG(4, "not enough dstCapacity (%zu) for ZSTD_entropyCompressSeqStore_internal()=> do not compress block", dstCapacity);
-        return 0;  /* block not compressed */
-    }
-    FORWARD_IF_ERROR(cSize, "ZSTD_entropyCompressSeqStore_internal failed");
-
-    /* Check compressibility */
-    {   size_t const maxCSize = blockSize - ZSTD_minGain(blockSize, cctxParams->cParams.strategy);
-        if (cSize >= maxCSize) return 0;  /* block not compressed */
-    }
-    DEBUGLOG(5, "ZSTD_entropyCompressSeqStore() cSize: %zu", cSize);
-    /* libzstd decoder before  > v1.5.4 is not compatible with compressed blocks of size ZSTD_BLOCKSIZE_MAX exactly.
-     * This restriction is indirectly already fulfilled by respecting ZSTD_minGain() condition above.
-     */
-    assert(cSize < ZSTD_BLOCKSIZE_MAX);
-    return cSize;
 }
 
 static size_t
@@ -3050,13 +2682,12 @@ ZSTD_entropyCompressSeqStore(
                           void* entropyWorkspace, size_t entropyWkspSize,
                           int bmi2)
 {
-    return ZSTD_entropyCompressSeqStore_wExtLitBuffer(
+    return ZSTD_rust_entropyCompressSeqStore(
+                seqStorePtr, prevEntropy, nextEntropy,
+                (int)cctxParams->cParams.strategy,
+                ZSTD_literalsCompressionIsDisabled(cctxParams),
                 dst, dstCapacity,
-                seqStorePtr->litStart, (size_t)(seqStorePtr->lit - seqStorePtr->litStart),
                 srcSize,
-                seqStorePtr,
-                prevEntropy, nextEntropy,
-                cctxParams,
                 entropyWorkspace, entropyWkspSize,
                 bmi2);
 }
@@ -3426,87 +3057,8 @@ static size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)
 
 static size_t ZSTD_copyBlockSequences(SeqCollector* seqCollector, const SeqStore_t* seqStore, const U32 prevRepcodes[ZSTD_REP_NUM])
 {
-    const SeqDef* inSeqs = seqStore->sequencesStart;
+    /* The implementation lives in rust/src/zstd_compress_stats.rs. */
-    const size_t nbInSequences = (size_t)(seqStore->sequences - inSeqs);
+    return ZSTD_rust_copyBlockSequences(seqCollector, seqStore, prevRepcodes);
-    const size_t nbInLiterals = (size_t)(seqStore->lit - seqStore->litStart);
-
-    ZSTD_Sequence* outSeqs = seqCollector->seqIndex == 0 ? seqCollector->seqStart : seqCollector->seqStart + seqCollector->seqIndex;
-    const size_t nbOutSequences = nbInSequences + 1;
-    size_t nbOutLiterals = 0;
-    Repcodes_t repcodes;
-    size_t i;
-
-    /* Bounds check that we have enough space for every input sequence
-     * and the block delimiter
-     */
-    assert(seqCollector->seqIndex <= seqCollector->maxSequences);
-    RETURN_ERROR_IF(
-        nbOutSequences > (size_t)(seqCollector->maxSequences - seqCollector->seqIndex),
-        dstSize_tooSmall,
-        "Not enough space to copy sequences");
-
-    ZSTD_memcpy(&repcodes, prevRepcodes, sizeof(repcodes));
-    for (i = 0; i < nbInSequences; ++i) {
-        U32 rawOffset;
-        outSeqs[i].litLength = inSeqs[i].litLength;
-        outSeqs[i].matchLength = inSeqs[i].mlBase + MINMATCH;
-        outSeqs[i].rep = 0;
-
-        /* Handle the possible single length >= 64K
-         * There can only be one because we add MINMATCH to every match length,
-         * and blocks are at most 128K.
-         */
-        if (i == seqStore->longLengthPos) {
-            if (seqStore->longLengthType == ZSTD_llt_literalLength) {
-                outSeqs[i].litLength += 0x10000;
-            } else if (seqStore->longLengthType == ZSTD_llt_matchLength) {
-                outSeqs[i].matchLength += 0x10000;
-            }
-        }
-
-        /* Determine the raw offset given the offBase, which may be a repcode. */
-        if (OFFBASE_IS_REPCODE(inSeqs[i].offBase)) {
-            const U32 repcode = OFFBASE_TO_REPCODE(inSeqs[i].offBase);
-            assert(repcode > 0);
-            outSeqs[i].rep = repcode;
-            if (outSeqs[i].litLength != 0) {
-                rawOffset = repcodes.rep[repcode - 1];
-            } else {
-                if (repcode == 3) {
-                    assert(repcodes.rep[0] > 1);
-                    rawOffset = repcodes.rep[0] - 1;
-                } else {
-                    rawOffset = repcodes.rep[repcode];
-                }
-            }
-        } else {
-            rawOffset = OFFBASE_TO_OFFSET(inSeqs[i].offBase);
-        }
-        outSeqs[i].offset = rawOffset;
-
-        /* Update repcode history for the sequence */
-        ZSTD_updateRep(repcodes.rep,
-                       inSeqs[i].offBase,
-                       inSeqs[i].litLength == 0);
-
-        nbOutLiterals += outSeqs[i].litLength;
-    }
-    /* Insert last literals (if any exist) in the block as a sequence with ml == off == 0.
-     * If there are no last literals, then we'll emit (of: 0, ml: 0, ll: 0), which is a marker
-     * for the block boundary, according to the API.
-     */
-    assert(nbInLiterals >= nbOutLiterals);
-    {
-        const size_t lastLLSize = nbInLiterals - nbOutLiterals;
-        outSeqs[nbInSequences].litLength = (U32)lastLLSize;
-        outSeqs[nbInSequences].matchLength = 0;
-        outSeqs[nbInSequences].offset = 0;
-        assert(nbOutSequences == nbInSequences + 1);
-    }
-    seqCollector->seqIndex += nbOutSequences;
-    assert(seqCollector->seqIndex <= seqCollector->maxSequences);
-
-    return 0;
 }
 
 /* ZSTD_sequenceBound() lives in rust/src/zstd_compress_api.rs. */
@@ -3602,178 +3154,14 @@ writeBlockHeader(void* op, size_t cSize, size_t blockSize, U32 lastBlock)
     DEBUGLOG(5, "writeBlockHeader: cSize: %zu blockSize: %zu lastBlock: %u", cSize, blockSize, lastBlock);
 }
 
-/** ZSTD_buildBlockEntropyStats_literals() :
- *  Builds entropy for the literals.
- *  Stores literals block type (raw, rle, compressed, repeat) and
- *  huffman description table to hufMetadata.
- *  Requires ENTROPY_WORKSPACE_SIZE workspace
- * @return : size of huffman description table, or an error code
- */
-static size_t
-ZSTD_buildBlockEntropyStats_literals(void* const src, size_t srcSize,
-                               const ZSTD_hufCTables_t* prevHuf,
-                                     ZSTD_hufCTables_t* nextHuf,
-                                     ZSTD_hufCTablesMetadata_t* hufMetadata,
-                               const int literalsCompressionIsDisabled,
-                                     void* workspace, size_t wkspSize,
-                                     int hufFlags)
-{
-    BYTE* const wkspStart = (BYTE*)workspace;
-    BYTE* const wkspEnd = wkspStart + wkspSize;
-    BYTE* const countWkspStart = wkspStart;
-    unsigned* const countWksp = (unsigned*)workspace;
-    const size_t countWkspSize = (HUF_SYMBOLVALUE_MAX + 1) * sizeof(unsigned);
-    BYTE* const nodeWksp = countWkspStart + countWkspSize;
-    const size_t nodeWkspSize = (size_t)(wkspEnd - nodeWksp);
-    unsigned maxSymbolValue = HUF_SYMBOLVALUE_MAX;
-    unsigned huffLog = LitHufLog;
-    HUF_repeat repeat = prevHuf->repeatMode;
-    DEBUGLOG(5, "ZSTD_buildBlockEntropyStats_literals (srcSize=%zu)", srcSize);
-
-    /* Prepare nextEntropy assuming reusing the existing table */
-    ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-
-    if (literalsCompressionIsDisabled) {
-        DEBUGLOG(5, "set_basic - disabled");
-        hufMetadata->hType = set_basic;
-        return 0;
-    }
-
-    /* small ? don't even attempt compression (speed opt) */
-#ifndef COMPRESS_LITERALS_SIZE_MIN
-# define COMPRESS_LITERALS_SIZE_MIN 63  /* heuristic */
-#endif
-    {   size_t const minLitSize = (prevHuf->repeatMode == HUF_repeat_valid) ? 6 : COMPRESS_LITERALS_SIZE_MIN;
-        if (srcSize <= minLitSize) {
-            DEBUGLOG(5, "set_basic - too small");
-            hufMetadata->hType = set_basic;
-            return 0;
-    }   }
-
-    /* Scan input and build symbol stats */
-    {   size_t const largest =
-            HIST_count_wksp (countWksp, &maxSymbolValue,
-                            (const BYTE*)src, srcSize,
-                            workspace, wkspSize);
-        FORWARD_IF_ERROR(largest, "HIST_count_wksp failed");
-        if (largest == srcSize) {
-            /* only one literal symbol */
-            DEBUGLOG(5, "set_rle");
-            hufMetadata->hType = set_rle;
-            return 0;
-        }
-        if (largest <= (srcSize >> 7)+4) {
-            /* heuristic: likely not compressible */
-            DEBUGLOG(5, "set_basic - no gain");
-            hufMetadata->hType = set_basic;
-            return 0;
-    }   }
-
-    /* Validate the previous Huffman table */
-    if (repeat == HUF_repeat_check
-      && !HUF_validateCTable((HUF_CElt const*)prevHuf->CTable, countWksp, maxSymbolValue)) {
-        repeat = HUF_repeat_none;
-    }
-
-    /* Build Huffman Tree */
-    ZSTD_memset(nextHuf->CTable, 0, sizeof(nextHuf->CTable));
-    huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue, nodeWksp, nodeWkspSize, nextHuf->CTable, countWksp, hufFlags);
-    assert(huffLog <= LitHufLog);
-    {   size_t const maxBits = HUF_buildCTable_wksp((HUF_CElt*)nextHuf->CTable, countWksp,
-                                                    maxSymbolValue, huffLog,
-                                                    nodeWksp, nodeWkspSize);
-        FORWARD_IF_ERROR(maxBits, "HUF_buildCTable_wksp");
-        huffLog = (U32)maxBits;
-    }
-    {   /* Build and write the CTable */
-        size_t const newCSize = HUF_estimateCompressedSize(
-                (HUF_CElt*)nextHuf->CTable, countWksp, maxSymbolValue);
-        size_t const hSize = HUF_writeCTable_wksp(
-                hufMetadata->hufDesBuffer, sizeof(hufMetadata->hufDesBuffer),
-                (HUF_CElt*)nextHuf->CTable, maxSymbolValue, huffLog,
-                nodeWksp, nodeWkspSize);
-        /* Check against repeating the previous CTable */
-        if (repeat != HUF_repeat_none) {
-            size_t const oldCSize = HUF_estimateCompressedSize(
-                    (HUF_CElt const*)prevHuf->CTable, countWksp, maxSymbolValue);
-            if (oldCSize < srcSize && (oldCSize <= hSize + newCSize || hSize + 12 >= srcSize)) {
-                DEBUGLOG(5, "set_repeat - smaller");
-                ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-                hufMetadata->hType = set_repeat;
-                return 0;
-        }   }
-        if (newCSize + hSize >= srcSize) {
-            DEBUGLOG(5, "set_basic - no gains");
-            ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));
-            hufMetadata->hType = set_basic;
-            return 0;
-        }
-        DEBUGLOG(5, "set_compressed (hSize=%u)", (U32)hSize);
-        hufMetadata->hType = set_compressed;
-        nextHuf->repeatMode = HUF_repeat_check;
-        return hSize;
-    }
-}
-
-
-/* ZSTD_buildDummySequencesStatistics():
- * Returns a ZSTD_symbolEncodingTypeStats_t with all encoding types as set_basic,
- * and updates nextEntropy to the appropriate repeatMode.
- */
-static ZSTD_symbolEncodingTypeStats_t
-ZSTD_buildDummySequencesStatistics(ZSTD_fseCTables_t* nextEntropy)
-{
-    ZSTD_symbolEncodingTypeStats_t stats = {set_basic, set_basic, set_basic, 0, 0, 0};
-    nextEntropy->litlength_repeatMode = FSE_repeat_none;
-    nextEntropy->offcode_repeatMode = FSE_repeat_none;
-    nextEntropy->matchlength_repeatMode = FSE_repeat_none;
-    return stats;
-}
-
-/** ZSTD_buildBlockEntropyStats_sequences() :
- *  Builds entropy for the sequences.
- *  Stores symbol compression modes and fse table to fseMetadata.
- *  Requires ENTROPY_WORKSPACE_SIZE wksp.
- * @return : size of fse tables or error code */
-static size_t
-ZSTD_buildBlockEntropyStats_sequences(
-                const SeqStore_t* seqStorePtr,
-                const ZSTD_fseCTables_t* prevEntropy,
-                      ZSTD_fseCTables_t* nextEntropy,
-                const ZSTD_CCtx_params* cctxParams,
-                      ZSTD_fseCTablesMetadata_t* fseMetadata,
-                      void* workspace, size_t wkspSize)
-{
-    ZSTD_strategy const strategy = cctxParams->cParams.strategy;
-    size_t const nbSeq = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);
-    BYTE* const ostart = fseMetadata->fseTablesBuffer;
-    BYTE* const oend = ostart + sizeof(fseMetadata->fseTablesBuffer);
-    BYTE* op = ostart;
-    unsigned* countWorkspace = (unsigned*)workspace;
-    unsigned* entropyWorkspace = countWorkspace + (MaxSeq + 1);
-    size_t entropyWorkspaceSize = wkspSize - (MaxSeq + 1) * sizeof(*countWorkspace);
-    ZSTD_symbolEncodingTypeStats_t stats;
-
-    DEBUGLOG(5, "ZSTD_buildBlockEntropyStats_sequences (nbSeq=%zu)", nbSeq);
-    stats = nbSeq != 0 ? ZSTD_buildSequencesStatistics(seqStorePtr, nbSeq,
-                                          prevEntropy, nextEntropy, op, oend,
-                                          strategy, countWorkspace,
-                                          entropyWorkspace, entropyWorkspaceSize)
-                       : ZSTD_buildDummySequencesStatistics(nextEntropy);
-    FORWARD_IF_ERROR(stats.size, "ZSTD_buildSequencesStatistics failed!");
-    fseMetadata->llType = (SymbolEncodingType_e) stats.LLtype;
-    fseMetadata->ofType = (SymbolEncodingType_e) stats.Offtype;
-    fseMetadata->mlType = (SymbolEncodingType_e) stats.MLtype;
-    fseMetadata->lastCountSize = stats.lastCountSize;
-    return stats.size;
-}
-
-
 /** ZSTD_buildBlockEntropyStats() :
  *  Builds entropy for the block.
  *  Requires workspace size ENTROPY_WORKSPACE_SIZE
  * @return : 0 on success, or an error code
  *  Note : also employed in superblock
+ *
+ *  The implementation, together with its literals/sequences/dummy helpers,
+ *  lives in rust/src/zstd_compress_stats.rs.
  */
 size_t ZSTD_buildBlockEntropyStats(
             const SeqStore_t* seqStorePtr,
@@ -3783,26 +3171,12 @@ size_t ZSTD_buildBlockEntropyStats(
                   ZSTD_entropyCTablesMetadata_t* entropyMetadata,
                   void* workspace, size_t wkspSize)
 {
-    size_t const litSize = (size_t)(seqStorePtr->lit - seqStorePtr->litStart);
+    return ZSTD_rust_buildBlockEntropyStats(
-    int const huf_useOptDepth = (cctxParams->cParams.strategy >= HUF_OPTIMAL_DEPTH_THRESHOLD);
+                seqStorePtr, prevEntropy, nextEntropy,
-    int const hufFlags = huf_useOptDepth ? HUF_flags_optimalDepth : 0;
+                (int)cctxParams->cParams.strategy,
-
+                ZSTD_literalsCompressionIsDisabled(cctxParams),
-    entropyMetadata->hufMetadata.hufDesSize =
+                entropyMetadata,
-        ZSTD_buildBlockEntropyStats_literals(seqStorePtr->litStart, litSize,
+                workspace, wkspSize);
-                                            &prevEntropy->huf, &nextEntropy->huf,
-                                            &entropyMetadata->hufMetadata,
-                                            ZSTD_literalsCompressionIsDisabled(cctxParams),
-                                            workspace, wkspSize, hufFlags);
-
-    FORWARD_IF_ERROR(entropyMetadata->hufMetadata.hufDesSize, "ZSTD_buildBlockEntropyStats_literals failed");
-    entropyMetadata->fseMetadata.fseTablesSize =
-        ZSTD_buildBlockEntropyStats_sequences(seqStorePtr,
-                                              &prevEntropy->fse, &nextEntropy->fse,
-                                              cctxParams,
-                                              &entropyMetadata->fseMetadata,
-                                              workspace, wkspSize);
-    FORWARD_IF_ERROR(entropyMetadata->fseMetadata.fseTablesSize, "ZSTD_buildBlockEntropyStats_sequences failed");
-    return 0;
 }
 
 /* Returns the size estimate for the literals section (header + content) of a block */
@@ -5430,15 +4804,15 @@ size_t ZSTD_estimateCDictSize_advanced(
         size_t dictSize, ZSTD_compressionParameters cParams,
         ZSTD_dictLoadMethod_e dictLoadMethod)
 {
-    DEBUGLOG(5, "sizeof(ZSTD_CDict) : %u", (unsigned)sizeof(ZSTD_CDict));
+    ZSTD_rustCDictSizing sizing;
-    return ZSTD_cwksp_alloc_size(sizeof(ZSTD_CDict))
+    sizing.cdictSize = sizeof(ZSTD_CDict);
-         + ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE)
+    sizing.hufWorkspaceSize = HUF_WORKSPACE_SIZE;
-         /* enableDedicatedDictSearch == 1 ensures that CDict estimation will not be too small
+    sizing.hashLog3Max = ZSTD_HASHLOG3_MAX;
-          * in case we are using DDS with row-hash. */
+    sizing.matchTSize = sizeof(ZSTD_match_t);
-         + ZSTD_sizeof_matchState(&cParams, ZSTD_resolveRowMatchFinderMode(ZSTD_ps_auto, &cParams),
+    sizing.optimalTSize = sizeof(ZSTD_optimal_t);
-                                  /* enableDedicatedDictSearch */ 1, /* forCCtx */ 0)
+    sizing.asanRedzoneSize = ZSTD_RUST_ASAN_REDZONE_SIZE;
-         + (dictLoadMethod == ZSTD_dlm_byRef ? 0
+    return ZSTD_rust_params_estimateCDictSizeFromCParams(
-            : ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void *))));
+            dictSize, cParams, (int)dictLoadMethod, &sizing);
 }
 
 size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel)
@@ -7576,11 +6950,12 @@ size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
 
 
 /*-=====  Pre-defined compression levels  =====-*/
-#include "clevels.h"
+/* The compression-level tables (formerly included from clevels.h) live in
+ * rust/src/zstd_compress_params.rs. */
 
-int ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }
+int ZSTD_maxCLevel(void) { return ZSTD_rust_params_maxCLevel(); }
-int ZSTD_minCLevel(void) { return (int)-ZSTD_TARGETLENGTH_MAX; }
+int ZSTD_minCLevel(void) { return ZSTD_rust_params_minCLevel(); }
-int ZSTD_defaultCLevel(void) { return ZSTD_CLEVEL_DEFAULT; }
+int ZSTD_defaultCLevel(void) { return ZSTD_rust_params_defaultCLevel(); }
 
 static ZSTD_compressionParameters ZSTD_dedicatedDictSearch_getCParams(int const compressionLevel, size_t const dictSize)
 {
@@ -7639,26 +7014,6 @@ static void ZSTD_dedicatedDictSearch_revertCParams(
     }
 }
 
-static U64 ZSTD_getCParamRowSize(U64 srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode)
-{
-    switch (mode) {
-    case ZSTD_cpm_unknown:
-    case ZSTD_cpm_noAttachDict:
-    case ZSTD_cpm_createCDict:
-        break;
-    case ZSTD_cpm_attachDict:
-        dictSize = 0;
-        break;
-    default:
-        assert(0);
-        break;
-    }
-    {   int const unknown = srcSizeHint == ZSTD_CONTENTSIZE_UNKNOWN;
-        size_t const addedSize = unknown && dictSize > 0 ? 500 : 0;
-        return unknown && dictSize == 0 ? ZSTD_CONTENTSIZE_UNKNOWN : srcSizeHint+dictSize+addedSize;
-    }
-}
-
 /*! ZSTD_getCParams_internal() :
  * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.
  *  Note: srcSizeHint 0 means 0, use ZSTD_CONTENTSIZE_UNKNOWN for unknown.
@@ -7666,27 +7021,12 @@ static U64 ZSTD_getCParamRowSize(U64 srcSizeHint, size_t dictSize, ZSTD_CParamMo
  *  Note: `mode` controls how we treat the `dictSize`. See docs for `ZSTD_CParamMode_e`. */
 static ZSTD_compressionParameters ZSTD_getCParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode)
 {
-    U64 const rSize = ZSTD_getCParamRowSize(srcSizeHint, dictSize, mode);
+    /* Table selection is context-free and lives in Rust; the adjustment step
-    U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);
+     * stays behind ZSTD_adjustCParams_internal() so this build's strategy
-    int row;
+     * cascade applies. */
-    DEBUGLOG(5, "ZSTD_getCParams_internal (cLevel=%i)", compressionLevel);
+    ZSTD_compressionParameters const cp = ZSTD_rust_params_selectCParams(
-
+            compressionLevel, srcSizeHint, dictSize, (int)mode);
-    /* row */
+    return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize, mode, ZSTD_ps_auto);
-    if (compressionLevel == 0) row = ZSTD_CLEVEL_DEFAULT;   /* 0 == default */
-    else if (compressionLevel < 0) row = 0;   /* entry 0 is baseline for fast mode */
-    else if (compressionLevel > ZSTD_MAX_CLEVEL) row = ZSTD_MAX_CLEVEL;
-    else row = compressionLevel;
-
-    {   ZSTD_compressionParameters cp = ZSTD_defaultCParameters[tableID][row];
-        DEBUGLOG(5, "ZSTD_getCParams_internal selected tableID: %u row: %u strat: %u", tableID, row, (U32)cp.strategy);
-        /* acceleration factor */
-        if (compressionLevel < 0) {
-            int const clampedCompressionLevel = MAX(ZSTD_minCLevel(), compressionLevel);
-            cp.targetLength = (unsigned)(-clampedCompressionLevel);
-        }
-        /* refine parameters based on srcSize & dictSize */
-        return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize, mode, ZSTD_ps_auto);
-    }
 }
 
 /*! ZSTD_getCParams() :
@@ -7705,13 +7045,9 @@ ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long l
 static ZSTD_parameters
 ZSTD_getParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode)
 {
-    ZSTD_parameters params;
     ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize, mode);
     DEBUGLOG(5, "ZSTD_getParams (cLevel=%i)", compressionLevel);
-    ZSTD_memset(&params, 0, sizeof(params));
+    return ZSTD_rust_params_makeParams(cParams);
-    params.cParams = cParams;
-    params.fParams.contentSizeFlag = 1;
-    return params;
 }
 
 /*! ZSTD_getParams() :

lib/compress/zstd_compress_superblock.c

@@ -29,7 +29,7 @@ size_t ZSTD_rust_compressSuperBlock(
         const SeqStore_t* seqStore,
         const ZSTD_compressedBlockState_t* prevCBlock,
         ZSTD_compressedBlockState_t* nextCBlock,
-        const ZSTD_CCtx_params* cctxParams,
+        int strategy, int disableLiteralCompression,
         void* workspace, size_t wkspSize,
         int bmi2, U32 windowLog, size_t targetCBlockSize,
         void* dst, size_t dstCapacity,
@@ -45,7 +45,8 @@ size_t ZSTD_compressSuperBlock(ZSTD_CCtx* zc,
             &zc->seqStore,
             zc->blockState.prevCBlock,
             zc->blockState.nextCBlock,
-            &zc->appliedParams,
+            (int)zc->appliedParams.cParams.strategy,
+            ZSTD_literalsCompressionIsDisabled(&zc->appliedParams),
             zc->tmpWorkspace, zc->tmpWkspSize,
             zc->bmi2, zc->appliedParams.cParams.windowLog,
             zc->appliedParams.targetCBlockSize,

lib/dictBuilder/divsufsort.c

@@ -24,9 +24,1890 @@
  * OTHER DEALINGS IN THE SOFTWARE.
  */
 
-/* divsufsort() is implemented in rust/src/divsufsort.rs, which provides the
+/*- Compiler specifics -*/
- * symbol directly.  This translation unit keeps the header's prototypes in
+#ifdef __clang__
- * the build so the dictionary builder continues to compile against the
+#pragma clang diagnostic ignored "-Wshorten-64-to-32"
- * original interface.  divbwt() has no callers in zstd and is declaration-
+#endif
- * only; it moves to Rust if a user ever appears. */
+
+#if defined(_MSC_VER)
+#  pragma warning(disable : 4244)
+#  pragma warning(disable : 4127)    /* C4127 : Condition expression is constant */
+#endif
+
+
+/*- Dependencies -*/
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
 #include "divsufsort.h"
+
+/*- Constants -*/
+#if defined(INLINE)
+# undef INLINE
+#endif
+#if !defined(INLINE)
+# define INLINE __inline
+#endif
+#if defined(ALPHABET_SIZE) && (ALPHABET_SIZE < 1)
+# undef ALPHABET_SIZE
+#endif
+#if !defined(ALPHABET_SIZE)
+# define ALPHABET_SIZE (256)
+#endif
+#define BUCKET_A_SIZE (ALPHABET_SIZE)
+#define BUCKET_B_SIZE (ALPHABET_SIZE * ALPHABET_SIZE)
+#if defined(SS_INSERTIONSORT_THRESHOLD)
+# if SS_INSERTIONSORT_THRESHOLD < 1
+#  undef SS_INSERTIONSORT_THRESHOLD
+#  define SS_INSERTIONSORT_THRESHOLD (1)
+# endif
+#else
+# define SS_INSERTIONSORT_THRESHOLD (8)
+#endif
+#if defined(SS_BLOCKSIZE)
+# if SS_BLOCKSIZE < 0
+#  undef SS_BLOCKSIZE
+#  define SS_BLOCKSIZE (0)
+# elif 32768 <= SS_BLOCKSIZE
+#  undef SS_BLOCKSIZE
+#  define SS_BLOCKSIZE (32767)
+# endif
+#else
+# define SS_BLOCKSIZE (1024)
+#endif
+/* minstacksize = log(SS_BLOCKSIZE) / log(3) * 2 */
+#if SS_BLOCKSIZE == 0
+# define SS_MISORT_STACKSIZE (96)
+#elif SS_BLOCKSIZE <= 4096
+# define SS_MISORT_STACKSIZE (16)
+#else
+# define SS_MISORT_STACKSIZE (24)
+#endif
+#define SS_SMERGE_STACKSIZE (32)
+#define TR_INSERTIONSORT_THRESHOLD (8)
+#define TR_STACKSIZE (64)
+
+
+/*- Macros -*/
+#ifndef SWAP
+# define SWAP(_a, _b) do { t = (_a); (_a) = (_b); (_b) = t; } while(0)
+#endif /* SWAP */
+#ifndef MIN
+# define MIN(_a, _b) (((_a) < (_b)) ? (_a) : (_b))
+#endif /* MIN */
+#ifndef MAX
+# define MAX(_a, _b) (((_a) > (_b)) ? (_a) : (_b))
+#endif /* MAX */
+#define STACK_PUSH(_a, _b, _c, _d)\
+  do {\
+    assert(ssize < STACK_SIZE);\
+    stack[ssize].a = (_a), stack[ssize].b = (_b),\
+    stack[ssize].c = (_c), stack[ssize++].d = (_d);\
+  } while(0)
+#define STACK_PUSH5(_a, _b, _c, _d, _e)\
+  do {\
+    assert(ssize < STACK_SIZE);\
+    stack[ssize].a = (_a), stack[ssize].b = (_b),\
+    stack[ssize].c = (_c), stack[ssize].d = (_d), stack[ssize++].e = (_e);\
+  } while(0)
+#define STACK_POP(_a, _b, _c, _d)\
+  do {\
+    assert(0 <= ssize);\
+    if(ssize == 0) { return; }\
+    (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\
+    (_c) = stack[ssize].c, (_d) = stack[ssize].d;\
+  } while(0)
+#define STACK_POP5(_a, _b, _c, _d, _e)\
+  do {\
+    assert(0 <= ssize);\
+    if(ssize == 0) { return; }\
+    (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\
+    (_c) = stack[ssize].c, (_d) = stack[ssize].d, (_e) = stack[ssize].e;\
+  } while(0)
+#define BUCKET_A(_c0) bucket_A[(_c0)]
+#if ALPHABET_SIZE == 256
+#define BUCKET_B(_c0, _c1) (bucket_B[((_c1) << 8) | (_c0)])
+#define BUCKET_BSTAR(_c0, _c1) (bucket_B[((_c0) << 8) | (_c1)])
+#else
+#define BUCKET_B(_c0, _c1) (bucket_B[(_c1) * ALPHABET_SIZE + (_c0)])
+#define BUCKET_BSTAR(_c0, _c1) (bucket_B[(_c0) * ALPHABET_SIZE + (_c1)])
+#endif
+
+
+/*- Private Functions -*/
+
+static const int lg_table[256]= {
+ -1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
+  5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
+  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
+  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
+};
+
+#if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE)
+
+static INLINE
+int
+ss_ilg(int n) {
+#if SS_BLOCKSIZE == 0
+  return (n & 0xffff0000) ?
+          ((n & 0xff000000) ?
+            24 + lg_table[(n >> 24) & 0xff] :
+            16 + lg_table[(n >> 16) & 0xff]) :
+          ((n & 0x0000ff00) ?
+             8 + lg_table[(n >>  8) & 0xff] :
+             0 + lg_table[(n >>  0) & 0xff]);
+#elif SS_BLOCKSIZE < 256
+  return lg_table[n];
+#else
+  return (n & 0xff00) ?
+          8 + lg_table[(n >> 8) & 0xff] :
+          0 + lg_table[(n >> 0) & 0xff];
+#endif
+}
+
+#endif /* (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) */
+
+#if SS_BLOCKSIZE != 0
+
+static const int sqq_table[256] = {
+  0,  16,  22,  27,  32,  35,  39,  42,  45,  48,  50,  53,  55,  57,  59,  61,
+ 64,  65,  67,  69,  71,  73,  75,  76,  78,  80,  81,  83,  84,  86,  87,  89,
+ 90,  91,  93,  94,  96,  97,  98,  99, 101, 102, 103, 104, 106, 107, 108, 109,
+110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
+128, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
+143, 144, 144, 145, 146, 147, 148, 149, 150, 150, 151, 152, 153, 154, 155, 155,
+156, 157, 158, 159, 160, 160, 161, 162, 163, 163, 164, 165, 166, 167, 167, 168,
+169, 170, 170, 171, 172, 173, 173, 174, 175, 176, 176, 177, 178, 178, 179, 180,
+181, 181, 182, 183, 183, 184, 185, 185, 186, 187, 187, 188, 189, 189, 190, 191,
+192, 192, 193, 193, 194, 195, 195, 196, 197, 197, 198, 199, 199, 200, 201, 201,
+202, 203, 203, 204, 204, 205, 206, 206, 207, 208, 208, 209, 209, 210, 211, 211,
+212, 212, 213, 214, 214, 215, 215, 216, 217, 217, 218, 218, 219, 219, 220, 221,
+221, 222, 222, 223, 224, 224, 225, 225, 226, 226, 227, 227, 228, 229, 229, 230,
+230, 231, 231, 232, 232, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238,
+239, 240, 240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247,
+247, 248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255
+};
+
+static INLINE
+int
+ss_isqrt(int x) {
+  int y, e;
+
+  if(x >= (SS_BLOCKSIZE * SS_BLOCKSIZE)) { return SS_BLOCKSIZE; }
+  e = (x & 0xffff0000) ?
+        ((x & 0xff000000) ?
+          24 + lg_table[(x >> 24) & 0xff] :
+          16 + lg_table[(x >> 16) & 0xff]) :
+        ((x & 0x0000ff00) ?
+           8 + lg_table[(x >>  8) & 0xff] :
+           0 + lg_table[(x >>  0) & 0xff]);
+
+  if(e >= 16) {
+    y = sqq_table[x >> ((e - 6) - (e & 1))] << ((e >> 1) - 7);
+    if(e >= 24) { y = (y + 1 + x / y) >> 1; }
+    y = (y + 1 + x / y) >> 1;
+  } else if(e >= 8) {
+    y = (sqq_table[x >> ((e - 6) - (e & 1))] >> (7 - (e >> 1))) + 1;
+  } else {
+    return sqq_table[x] >> 4;
+  }
+
+  return (x < (y * y)) ? y - 1 : y;
+}
+
+#endif /* SS_BLOCKSIZE != 0 */
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Compares two suffixes. */
+static INLINE
+int
+ss_compare(const unsigned char *T,
+           const int *p1, const int *p2,
+           int depth) {
+  const unsigned char *U1, *U2, *U1n, *U2n;
+
+  for(U1 = T + depth + *p1,
+      U2 = T + depth + *p2,
+      U1n = T + *(p1 + 1) + 2,
+      U2n = T + *(p2 + 1) + 2;
+      (U1 < U1n) && (U2 < U2n) && (*U1 == *U2);
+      ++U1, ++U2) {
+  }
+
+  return U1 < U1n ?
+        (U2 < U2n ? *U1 - *U2 : 1) :
+        (U2 < U2n ? -1 : 0);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+#if (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1)
+
+/* Insertionsort for small size groups */
+static
+void
+ss_insertionsort(const unsigned char *T, const int *PA,
+                 int *first, int *last, int depth) {
+  int *i, *j;
+  int t;
+  int r;
+
+  for(i = last - 2; first <= i; --i) {
+    for(t = *i, j = i + 1; 0 < (r = ss_compare(T, PA + t, PA + *j, depth));) {
+      do { *(j - 1) = *j; } while((++j < last) && (*j < 0));
+      if(last <= j) { break; }
+    }
+    if(r == 0) { *j = ~*j; }
+    *(j - 1) = t;
+  }
+}
+
+#endif /* (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1) */
+
+
+/*---------------------------------------------------------------------------*/
+
+#if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE)
+
+static INLINE
+void
+ss_fixdown(const unsigned char *Td, const int *PA,
+           int *SA, int i, int size) {
+  int j, k;
+  int v;
+  int c, d, e;
+
+  for(v = SA[i], c = Td[PA[v]]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) {
+    d = Td[PA[SA[k = j++]]];
+    if(d < (e = Td[PA[SA[j]]])) { k = j; d = e; }
+    if(d <= c) { break; }
+  }
+  SA[i] = v;
+}
+
+/* Simple top-down heapsort. */
+static
+void
+ss_heapsort(const unsigned char *Td, const int *PA, int *SA, int size) {
+  int i, m;
+  int t;
+
+  m = size;
+  if((size % 2) == 0) {
+    m--;
+    if(Td[PA[SA[m / 2]]] < Td[PA[SA[m]]]) { SWAP(SA[m], SA[m / 2]); }
+  }
+
+  for(i = m / 2 - 1; 0 <= i; --i) { ss_fixdown(Td, PA, SA, i, m); }
+  if((size % 2) == 0) { SWAP(SA[0], SA[m]); ss_fixdown(Td, PA, SA, 0, m); }
+  for(i = m - 1; 0 < i; --i) {
+    t = SA[0], SA[0] = SA[i];
+    ss_fixdown(Td, PA, SA, 0, i);
+    SA[i] = t;
+  }
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Returns the median of three elements. */
+static INLINE
+int *
+ss_median3(const unsigned char *Td, const int *PA,
+           int *v1, int *v2, int *v3) {
+  int *t;
+  if(Td[PA[*v1]] > Td[PA[*v2]]) { SWAP(v1, v2); }
+  if(Td[PA[*v2]] > Td[PA[*v3]]) {
+    if(Td[PA[*v1]] > Td[PA[*v3]]) { return v1; }
+    else { return v3; }
+  }
+  return v2;
+}
+
+/* Returns the median of five elements. */
+static INLINE
+int *
+ss_median5(const unsigned char *Td, const int *PA,
+           int *v1, int *v2, int *v3, int *v4, int *v5) {
+  int *t;
+  if(Td[PA[*v2]] > Td[PA[*v3]]) { SWAP(v2, v3); }
+  if(Td[PA[*v4]] > Td[PA[*v5]]) { SWAP(v4, v5); }
+  if(Td[PA[*v2]] > Td[PA[*v4]]) { SWAP(v2, v4); SWAP(v3, v5); }
+  if(Td[PA[*v1]] > Td[PA[*v3]]) { SWAP(v1, v3); }
+  if(Td[PA[*v1]] > Td[PA[*v4]]) { SWAP(v1, v4); SWAP(v3, v5); }
+  if(Td[PA[*v3]] > Td[PA[*v4]]) { return v4; }
+  return v3;
+}
+
+/* Returns the pivot element. */
+static INLINE
+int *
+ss_pivot(const unsigned char *Td, const int *PA, int *first, int *last) {
+  int *middle;
+  int t;
+
+  t = last - first;
+  middle = first + t / 2;
+
+  if(t <= 512) {
+    if(t <= 32) {
+      return ss_median3(Td, PA, first, middle, last - 1);
+    } else {
+      t >>= 2;
+      return ss_median5(Td, PA, first, first + t, middle, last - 1 - t, last - 1);
+    }
+  }
+  t >>= 3;
+  first  = ss_median3(Td, PA, first, first + t, first + (t << 1));
+  middle = ss_median3(Td, PA, middle - t, middle, middle + t);
+  last   = ss_median3(Td, PA, last - 1 - (t << 1), last - 1 - t, last - 1);
+  return ss_median3(Td, PA, first, middle, last);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Binary partition for substrings. */
+static INLINE
+int *
+ss_partition(const int *PA,
+                    int *first, int *last, int depth) {
+  int *a, *b;
+  int t;
+  for(a = first - 1, b = last;;) {
+    for(; (++a < b) && ((PA[*a] + depth) >= (PA[*a + 1] + 1));) { *a = ~*a; }
+    for(; (a < --b) && ((PA[*b] + depth) <  (PA[*b + 1] + 1));) { }
+    if(b <= a) { break; }
+    t = ~*b;
+    *b = *a;
+    *a = t;
+  }
+  if(first < a) { *first = ~*first; }
+  return a;
+}
+
+/* Multikey introsort for medium size groups. */
+static
+void
+ss_mintrosort(const unsigned char *T, const int *PA,
+              int *first, int *last,
+              int depth) {
+#define STACK_SIZE SS_MISORT_STACKSIZE
+  struct { int *a, *b, c; int d; } stack[STACK_SIZE];
+  const unsigned char *Td;
+  int *a, *b, *c, *d, *e, *f;
+  int s, t;
+  int ssize;
+  int limit;
+  int v, x = 0;
+
+  for(ssize = 0, limit = ss_ilg(last - first);;) {
+
+    if((last - first) <= SS_INSERTIONSORT_THRESHOLD) {
+#if 1 < SS_INSERTIONSORT_THRESHOLD
+      if(1 < (last - first)) { ss_insertionsort(T, PA, first, last, depth); }
+#endif
+      STACK_POP(first, last, depth, limit);
+      continue;
+    }
+
+    Td = T + depth;
+    if(limit-- == 0) { ss_heapsort(Td, PA, first, last - first); }
+    if(limit < 0) {
+      for(a = first + 1, v = Td[PA[*first]]; a < last; ++a) {
+        if((x = Td[PA[*a]]) != v) {
+          if(1 < (a - first)) { break; }
+          v = x;
+          first = a;
+        }
+      }
+      if(Td[PA[*first] - 1] < v) {
+        first = ss_partition(PA, first, a, depth);
+      }
+      if((a - first) <= (last - a)) {
+        if(1 < (a - first)) {
+          STACK_PUSH(a, last, depth, -1);
+          last = a, depth += 1, limit = ss_ilg(a - first);
+        } else {
+          first = a, limit = -1;
+        }
+      } else {
+        if(1 < (last - a)) {
+          STACK_PUSH(first, a, depth + 1, ss_ilg(a - first));
+          first = a, limit = -1;
+        } else {
+          last = a, depth += 1, limit = ss_ilg(a - first);
+        }
+      }
+      continue;
+    }
+
+    /* choose pivot */
+    a = ss_pivot(Td, PA, first, last);
+    v = Td[PA[*a]];
+    SWAP(*first, *a);
+
+    /* partition */
+    for(b = first; (++b < last) && ((x = Td[PA[*b]]) == v);) { }
+    if(((a = b) < last) && (x < v)) {
+      for(; (++b < last) && ((x = Td[PA[*b]]) <= v);) {
+        if(x == v) { SWAP(*b, *a); ++a; }
+      }
+    }
+    for(c = last; (b < --c) && ((x = Td[PA[*c]]) == v);) { }
+    if((b < (d = c)) && (x > v)) {
+      for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) {
+        if(x == v) { SWAP(*c, *d); --d; }
+      }
+    }
+    for(; b < c;) {
+      SWAP(*b, *c);
+      for(; (++b < c) && ((x = Td[PA[*b]]) <= v);) {
+        if(x == v) { SWAP(*b, *a); ++a; }
+      }
+      for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) {
+        if(x == v) { SWAP(*c, *d); --d; }
+      }
+    }
+
+    if(a <= d) {
+      c = b - 1;
+
+      if((s = a - first) > (t = b - a)) { s = t; }
+      for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
+      if((s = d - c) > (t = last - d - 1)) { s = t; }
+      for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
+
+      a = first + (b - a), c = last - (d - c);
+      b = (v <= Td[PA[*a] - 1]) ? a : ss_partition(PA, a, c, depth);
+
+      if((a - first) <= (last - c)) {
+        if((last - c) <= (c - b)) {
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
+          STACK_PUSH(c, last, depth, limit);
+          last = a;
+        } else if((a - first) <= (c - b)) {
+          STACK_PUSH(c, last, depth, limit);
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
+          last = a;
+        } else {
+          STACK_PUSH(c, last, depth, limit);
+          STACK_PUSH(first, a, depth, limit);
+          first = b, last = c, depth += 1, limit = ss_ilg(c - b);
+        }
+      } else {
+        if((a - first) <= (c - b)) {
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
+          STACK_PUSH(first, a, depth, limit);
+          first = c;
+        } else if((last - c) <= (c - b)) {
+          STACK_PUSH(first, a, depth, limit);
+          STACK_PUSH(b, c, depth + 1, ss_ilg(c - b));
+          first = c;
+        } else {
+          STACK_PUSH(first, a, depth, limit);
+          STACK_PUSH(c, last, depth, limit);
+          first = b, last = c, depth += 1, limit = ss_ilg(c - b);
+        }
+      }
+    } else {
+      limit += 1;
+      if(Td[PA[*first] - 1] < v) {
+        first = ss_partition(PA, first, last, depth);
+        limit = ss_ilg(last - first);
+      }
+      depth += 1;
+    }
+  }
+#undef STACK_SIZE
+}
+
+#endif /* (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) */
+
+
+/*---------------------------------------------------------------------------*/
+
+#if SS_BLOCKSIZE != 0
+
+static INLINE
+void
+ss_blockswap(int *a, int *b, int n) {
+  int t;
+  for(; 0 < n; --n, ++a, ++b) {
+    t = *a, *a = *b, *b = t;
+  }
+}
+
+static INLINE
+void
+ss_rotate(int *first, int *middle, int *last) {
+  int *a, *b, t;
+  int l, r;
+  l = middle - first, r = last - middle;
+  for(; (0 < l) && (0 < r);) {
+    if(l == r) { ss_blockswap(first, middle, l); break; }
+    if(l < r) {
+      a = last - 1, b = middle - 1;
+      t = *a;
+      do {
+        *a-- = *b, *b-- = *a;
+        if(b < first) {
+          *a = t;
+          last = a;
+          if((r -= l + 1) <= l) { break; }
+          a -= 1, b = middle - 1;
+          t = *a;
+        }
+      } while(1);
+    } else {
+      a = first, b = middle;
+      t = *a;
+      do {
+        *a++ = *b, *b++ = *a;
+        if(last <= b) {
+          *a = t;
+          first = a + 1;
+          if((l -= r + 1) <= r) { break; }
+          a += 1, b = middle;
+          t = *a;
+        }
+      } while(1);
+    }
+  }
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+static
+void
+ss_inplacemerge(const unsigned char *T, const int *PA,
+                int *first, int *middle, int *last,
+                int depth) {
+  const int *p;
+  int *a, *b;
+  int len, half;
+  int q, r;
+  int x;
+
+  for(;;) {
+    if(*(last - 1) < 0) { x = 1; p = PA + ~*(last - 1); }
+    else                { x = 0; p = PA +  *(last - 1); }
+    for(a = first, len = middle - first, half = len >> 1, r = -1;
+        0 < len;
+        len = half, half >>= 1) {
+      b = a + half;
+      q = ss_compare(T, PA + ((0 <= *b) ? *b : ~*b), p, depth);
+      if(q < 0) {
+        a = b + 1;
+        half -= (len & 1) ^ 1;
+      } else {
+        r = q;
+      }
+    }
+    if(a < middle) {
+      if(r == 0) { *a = ~*a; }
+      ss_rotate(a, middle, last);
+      last -= middle - a;
+      middle = a;
+      if(first == middle) { break; }
+    }
+    --last;
+    if(x != 0) { while(*--last < 0) { } }
+    if(middle == last) { break; }
+  }
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Merge-forward with internal buffer. */
+static
+void
+ss_mergeforward(const unsigned char *T, const int *PA,
+                int *first, int *middle, int *last,
+                int *buf, int depth) {
+  int *a, *b, *c, *bufend;
+  int t;
+  int r;
+
+  bufend = buf + (middle - first) - 1;
+  ss_blockswap(buf, first, middle - first);
+
+  for(t = *(a = first), b = buf, c = middle;;) {
+    r = ss_compare(T, PA + *b, PA + *c, depth);
+    if(r < 0) {
+      do {
+        *a++ = *b;
+        if(bufend <= b) { *bufend = t; return; }
+        *b++ = *a;
+      } while(*b < 0);
+    } else if(r > 0) {
+      do {
+        *a++ = *c, *c++ = *a;
+        if(last <= c) {
+          while(b < bufend) { *a++ = *b, *b++ = *a; }
+          *a = *b, *b = t;
+          return;
+        }
+      } while(*c < 0);
+    } else {
+      *c = ~*c;
+      do {
+        *a++ = *b;
+        if(bufend <= b) { *bufend = t; return; }
+        *b++ = *a;
+      } while(*b < 0);
+
+      do {
+        *a++ = *c, *c++ = *a;
+        if(last <= c) {
+          while(b < bufend) { *a++ = *b, *b++ = *a; }
+          *a = *b, *b = t;
+          return;
+        }
+      } while(*c < 0);
+    }
+  }
+}
+
+/* Merge-backward with internal buffer. */
+static
+void
+ss_mergebackward(const unsigned char *T, const int *PA,
+                 int *first, int *middle, int *last,
+                 int *buf, int depth) {
+  const int *p1, *p2;
+  int *a, *b, *c, *bufend;
+  int t;
+  int r;
+  int x;
+
+  bufend = buf + (last - middle) - 1;
+  ss_blockswap(buf, middle, last - middle);
+
+  x = 0;
+  if(*bufend < 0)       { p1 = PA + ~*bufend; x |= 1; }
+  else                  { p1 = PA +  *bufend; }
+  if(*(middle - 1) < 0) { p2 = PA + ~*(middle - 1); x |= 2; }
+  else                  { p2 = PA +  *(middle - 1); }
+  for(t = *(a = last - 1), b = bufend, c = middle - 1;;) {
+    r = ss_compare(T, p1, p2, depth);
+    if(0 < r) {
+      if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; }
+      *a-- = *b;
+      if(b <= buf) { *buf = t; break; }
+      *b-- = *a;
+      if(*b < 0) { p1 = PA + ~*b; x |= 1; }
+      else       { p1 = PA +  *b; }
+    } else if(r < 0) {
+      if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; }
+      *a-- = *c, *c-- = *a;
+      if(c < first) {
+        while(buf < b) { *a-- = *b, *b-- = *a; }
+        *a = *b, *b = t;
+        break;
+      }
+      if(*c < 0) { p2 = PA + ~*c; x |= 2; }
+      else       { p2 = PA +  *c; }
+    } else {
+      if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; }
+      *a-- = ~*b;
+      if(b <= buf) { *buf = t; break; }
+      *b-- = *a;
+      if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; }
+      *a-- = *c, *c-- = *a;
+      if(c < first) {
+        while(buf < b) { *a-- = *b, *b-- = *a; }
+        *a = *b, *b = t;
+        break;
+      }
+      if(*b < 0) { p1 = PA + ~*b; x |= 1; }
+      else       { p1 = PA +  *b; }
+      if(*c < 0) { p2 = PA + ~*c; x |= 2; }
+      else       { p2 = PA +  *c; }
+    }
+  }
+}
+
+/* D&C based merge. */
+static
+void
+ss_swapmerge(const unsigned char *T, const int *PA,
+             int *first, int *middle, int *last,
+             int *buf, int bufsize, int depth) {
+#define STACK_SIZE SS_SMERGE_STACKSIZE
+#define GETIDX(a) ((0 <= (a)) ? (a) : (~(a)))
+#define MERGE_CHECK(a, b, c)\
+  do {\
+    if(((c) & 1) ||\
+       (((c) & 2) && (ss_compare(T, PA + GETIDX(*((a) - 1)), PA + *(a), depth) == 0))) {\
+      *(a) = ~*(a);\
+    }\
+    if(((c) & 4) && ((ss_compare(T, PA + GETIDX(*((b) - 1)), PA + *(b), depth) == 0))) {\
+      *(b) = ~*(b);\
+    }\
+  } while(0)
+  struct { int *a, *b, *c; int d; } stack[STACK_SIZE];
+  int *l, *r, *lm, *rm;
+  int m, len, half;
+  int ssize;
+  int check, next;
+
+  for(check = 0, ssize = 0;;) {
+    if((last - middle) <= bufsize) {
+      if((first < middle) && (middle < last)) {
+        ss_mergebackward(T, PA, first, middle, last, buf, depth);
+      }
+      MERGE_CHECK(first, last, check);
+      STACK_POP(first, middle, last, check);
+      continue;
+    }
+
+    if((middle - first) <= bufsize) {
+      if(first < middle) {
+        ss_mergeforward(T, PA, first, middle, last, buf, depth);
+      }
+      MERGE_CHECK(first, last, check);
+      STACK_POP(first, middle, last, check);
+      continue;
+    }
+
+    for(m = 0, len = MIN(middle - first, last - middle), half = len >> 1;
+        0 < len;
+        len = half, half >>= 1) {
+      if(ss_compare(T, PA + GETIDX(*(middle + m + half)),
+                       PA + GETIDX(*(middle - m - half - 1)), depth) < 0) {
+        m += half + 1;
+        half -= (len & 1) ^ 1;
+      }
+    }
+
+    if(0 < m) {
+      lm = middle - m, rm = middle + m;
+      ss_blockswap(lm, middle, m);
+      l = r = middle, next = 0;
+      if(rm < last) {
+        if(*rm < 0) {
+          *rm = ~*rm;
+          if(first < lm) { for(; *--l < 0;) { } next |= 4; }
+          next |= 1;
+        } else if(first < lm) {
+          for(; *r < 0; ++r) { }
+          next |= 2;
+        }
+      }
+
+      if((l - first) <= (last - r)) {
+        STACK_PUSH(r, rm, last, (next & 3) | (check & 4));
+        middle = lm, last = l, check = (check & 3) | (next & 4);
+      } else {
+        if((next & 2) && (r == middle)) { next ^= 6; }
+        STACK_PUSH(first, lm, l, (check & 3) | (next & 4));
+        first = r, middle = rm, check = (next & 3) | (check & 4);
+      }
+    } else {
+      if(ss_compare(T, PA + GETIDX(*(middle - 1)), PA + *middle, depth) == 0) {
+        *middle = ~*middle;
+      }
+      MERGE_CHECK(first, last, check);
+      STACK_POP(first, middle, last, check);
+    }
+  }
+#undef STACK_SIZE
+}
+
+#endif /* SS_BLOCKSIZE != 0 */
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Substring sort */
+static
+void
+sssort(const unsigned char *T, const int *PA,
+       int *first, int *last,
+       int *buf, int bufsize,
+       int depth, int n, int lastsuffix) {
+  int *a;
+#if SS_BLOCKSIZE != 0
+  int *b, *middle, *curbuf;
+  int j, k, curbufsize, limit;
+#endif
+  int i;
+
+  if(lastsuffix != 0) { ++first; }
+
+#if SS_BLOCKSIZE == 0
+  ss_mintrosort(T, PA, first, last, depth);
+#else
+  if((bufsize < SS_BLOCKSIZE) &&
+      (bufsize < (last - first)) &&
+      (bufsize < (limit = ss_isqrt(last - first)))) {
+    if(SS_BLOCKSIZE < limit) { limit = SS_BLOCKSIZE; }
+    buf = middle = last - limit, bufsize = limit;
+  } else {
+    middle = last, limit = 0;
+  }
+  for(a = first, i = 0; SS_BLOCKSIZE < (middle - a); a += SS_BLOCKSIZE, ++i) {
+#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
+    ss_mintrosort(T, PA, a, a + SS_BLOCKSIZE, depth);
+#elif 1 < SS_BLOCKSIZE
+    ss_insertionsort(T, PA, a, a + SS_BLOCKSIZE, depth);
+#endif
+    curbufsize = last - (a + SS_BLOCKSIZE);
+    curbuf = a + SS_BLOCKSIZE;
+    if(curbufsize <= bufsize) { curbufsize = bufsize, curbuf = buf; }
+    for(b = a, k = SS_BLOCKSIZE, j = i; j & 1; b -= k, k <<= 1, j >>= 1) {
+      ss_swapmerge(T, PA, b - k, b, b + k, curbuf, curbufsize, depth);
+    }
+  }
+#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
+  ss_mintrosort(T, PA, a, middle, depth);
+#elif 1 < SS_BLOCKSIZE
+  ss_insertionsort(T, PA, a, middle, depth);
+#endif
+  for(k = SS_BLOCKSIZE; i != 0; k <<= 1, i >>= 1) {
+    if(i & 1) {
+      ss_swapmerge(T, PA, a - k, a, middle, buf, bufsize, depth);
+      a -= k;
+    }
+  }
+  if(limit != 0) {
+#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE
+    ss_mintrosort(T, PA, middle, last, depth);
+#elif 1 < SS_BLOCKSIZE
+    ss_insertionsort(T, PA, middle, last, depth);
+#endif
+    ss_inplacemerge(T, PA, first, middle, last, depth);
+  }
+#endif
+
+  if(lastsuffix != 0) {
+    /* Insert last type B* suffix. */
+    int PAi[2]; PAi[0] = PA[*(first - 1)], PAi[1] = n - 2;
+    for(a = first, i = *(first - 1);
+        (a < last) && ((*a < 0) || (0 < ss_compare(T, &(PAi[0]), PA + *a, depth)));
+        ++a) {
+      *(a - 1) = *a;
+    }
+    *(a - 1) = i;
+  }
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+static INLINE
+int
+tr_ilg(int n) {
+  return (n & 0xffff0000) ?
+          ((n & 0xff000000) ?
+            24 + lg_table[(n >> 24) & 0xff] :
+            16 + lg_table[(n >> 16) & 0xff]) :
+          ((n & 0x0000ff00) ?
+             8 + lg_table[(n >>  8) & 0xff] :
+             0 + lg_table[(n >>  0) & 0xff]);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Simple insertionsort for small size groups. */
+static
+void
+tr_insertionsort(const int *ISAd, int *first, int *last) {
+  int *a, *b;
+  int t, r;
+
+  for(a = first + 1; a < last; ++a) {
+    for(t = *a, b = a - 1; 0 > (r = ISAd[t] - ISAd[*b]);) {
+      do { *(b + 1) = *b; } while((first <= --b) && (*b < 0));
+      if(b < first) { break; }
+    }
+    if(r == 0) { *b = ~*b; }
+    *(b + 1) = t;
+  }
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+static INLINE
+void
+tr_fixdown(const int *ISAd, int *SA, int i, int size) {
+  int j, k;
+  int v;
+  int c, d, e;
+
+  for(v = SA[i], c = ISAd[v]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) {
+    d = ISAd[SA[k = j++]];
+    if(d < (e = ISAd[SA[j]])) { k = j; d = e; }
+    if(d <= c) { break; }
+  }
+  SA[i] = v;
+}
+
+/* Simple top-down heapsort. */
+static
+void
+tr_heapsort(const int *ISAd, int *SA, int size) {
+  int i, m;
+  int t;
+
+  m = size;
+  if((size % 2) == 0) {
+    m--;
+    if(ISAd[SA[m / 2]] < ISAd[SA[m]]) { SWAP(SA[m], SA[m / 2]); }
+  }
+
+  for(i = m / 2 - 1; 0 <= i; --i) { tr_fixdown(ISAd, SA, i, m); }
+  if((size % 2) == 0) { SWAP(SA[0], SA[m]); tr_fixdown(ISAd, SA, 0, m); }
+  for(i = m - 1; 0 < i; --i) {
+    t = SA[0], SA[0] = SA[i];
+    tr_fixdown(ISAd, SA, 0, i);
+    SA[i] = t;
+  }
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Returns the median of three elements. */
+static INLINE
+int *
+tr_median3(const int *ISAd, int *v1, int *v2, int *v3) {
+  int *t;
+  if(ISAd[*v1] > ISAd[*v2]) { SWAP(v1, v2); }
+  if(ISAd[*v2] > ISAd[*v3]) {
+    if(ISAd[*v1] > ISAd[*v3]) { return v1; }
+    else { return v3; }
+  }
+  return v2;
+}
+
+/* Returns the median of five elements. */
+static INLINE
+int *
+tr_median5(const int *ISAd,
+           int *v1, int *v2, int *v3, int *v4, int *v5) {
+  int *t;
+  if(ISAd[*v2] > ISAd[*v3]) { SWAP(v2, v3); }
+  if(ISAd[*v4] > ISAd[*v5]) { SWAP(v4, v5); }
+  if(ISAd[*v2] > ISAd[*v4]) { SWAP(v2, v4); SWAP(v3, v5); }
+  if(ISAd[*v1] > ISAd[*v3]) { SWAP(v1, v3); }
+  if(ISAd[*v1] > ISAd[*v4]) { SWAP(v1, v4); SWAP(v3, v5); }
+  if(ISAd[*v3] > ISAd[*v4]) { return v4; }
+  return v3;
+}
+
+/* Returns the pivot element. */
+static INLINE
+int *
+tr_pivot(const int *ISAd, int *first, int *last) {
+  int *middle;
+  int t;
+
+  t = last - first;
+  middle = first + t / 2;
+
+  if(t <= 512) {
+    if(t <= 32) {
+      return tr_median3(ISAd, first, middle, last - 1);
+    } else {
+      t >>= 2;
+      return tr_median5(ISAd, first, first + t, middle, last - 1 - t, last - 1);
+    }
+  }
+  t >>= 3;
+  first  = tr_median3(ISAd, first, first + t, first + (t << 1));
+  middle = tr_median3(ISAd, middle - t, middle, middle + t);
+  last   = tr_median3(ISAd, last - 1 - (t << 1), last - 1 - t, last - 1);
+  return tr_median3(ISAd, first, middle, last);
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+typedef struct _trbudget_t trbudget_t;
+struct _trbudget_t {
+  int chance;
+  int remain;
+  int incval;
+  int count;
+};
+
+static INLINE
+void
+trbudget_init(trbudget_t *budget, int chance, int incval) {
+  budget->chance = chance;
+  budget->remain = budget->incval = incval;
+}
+
+static INLINE
+int
+trbudget_check(trbudget_t *budget, int size) {
+  if(size <= budget->remain) { budget->remain -= size; return 1; }
+  if(budget->chance == 0) { budget->count += size; return 0; }
+  budget->remain += budget->incval - size;
+  budget->chance -= 1;
+  return 1;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+static INLINE
+void
+tr_partition(const int *ISAd,
+             int *first, int *middle, int *last,
+             int **pa, int **pb, int v) {
+  int *a, *b, *c, *d, *e, *f;
+  int t, s;
+  int x = 0;
+
+  for(b = middle - 1; (++b < last) && ((x = ISAd[*b]) == v);) { }
+  if(((a = b) < last) && (x < v)) {
+    for(; (++b < last) && ((x = ISAd[*b]) <= v);) {
+      if(x == v) { SWAP(*b, *a); ++a; }
+    }
+  }
+  for(c = last; (b < --c) && ((x = ISAd[*c]) == v);) { }
+  if((b < (d = c)) && (x > v)) {
+    for(; (b < --c) && ((x = ISAd[*c]) >= v);) {
+      if(x == v) { SWAP(*c, *d); --d; }
+    }
+  }
+  for(; b < c;) {
+    SWAP(*b, *c);
+    for(; (++b < c) && ((x = ISAd[*b]) <= v);) {
+      if(x == v) { SWAP(*b, *a); ++a; }
+    }
+    for(; (b < --c) && ((x = ISAd[*c]) >= v);) {
+      if(x == v) { SWAP(*c, *d); --d; }
+    }
+  }
+
+  if(a <= d) {
+    c = b - 1;
+    if((s = a - first) > (t = b - a)) { s = t; }
+    for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
+    if((s = d - c) > (t = last - d - 1)) { s = t; }
+    for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }
+    first += (b - a), last -= (d - c);
+  }
+  *pa = first, *pb = last;
+}
+
+static
+void
+tr_copy(int *ISA, const int *SA,
+        int *first, int *a, int *b, int *last,
+        int depth) {
+  /* sort suffixes of middle partition
+     by using sorted order of suffixes of left and right partition. */
+  int *c, *d, *e;
+  int s, v;
+
+  v = b - SA - 1;
+  for(c = first, d = a - 1; c <= d; ++c) {
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
+      *++d = s;
+      ISA[s] = d - SA;
+    }
+  }
+  for(c = last - 1, e = d + 1, d = b; e < d; --c) {
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
+      *--d = s;
+      ISA[s] = d - SA;
+    }
+  }
+}
+
+static
+void
+tr_partialcopy(int *ISA, const int *SA,
+               int *first, int *a, int *b, int *last,
+               int depth) {
+  int *c, *d, *e;
+  int s, v;
+  int rank, lastrank, newrank = -1;
+
+  v = b - SA - 1;
+  lastrank = -1;
+  for(c = first, d = a - 1; c <= d; ++c) {
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
+      *++d = s;
+      rank = ISA[s + depth];
+      if(lastrank != rank) { lastrank = rank; newrank = d - SA; }
+      ISA[s] = newrank;
+    }
+  }
+
+  lastrank = -1;
+  for(e = d; first <= e; --e) {
+    rank = ISA[*e];
+    if(lastrank != rank) { lastrank = rank; newrank = e - SA; }
+    if(newrank != rank) { ISA[*e] = newrank; }
+  }
+
+  lastrank = -1;
+  for(c = last - 1, e = d + 1, d = b; e < d; --c) {
+    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {
+      *--d = s;
+      rank = ISA[s + depth];
+      if(lastrank != rank) { lastrank = rank; newrank = d - SA; }
+      ISA[s] = newrank;
+    }
+  }
+}
+
+static
+void
+tr_introsort(int *ISA, const int *ISAd,
+             int *SA, int *first, int *last,
+             trbudget_t *budget) {
+#define STACK_SIZE TR_STACKSIZE
+  struct { const int *a; int *b, *c; int d, e; }stack[STACK_SIZE];
+  int *a, *b, *c;
+  int t;
+  int v, x = 0;
+  int incr = ISAd - ISA;
+  int limit, next;
+  int ssize, trlink = -1;
+
+  for(ssize = 0, limit = tr_ilg(last - first);;) {
+
+    if(limit < 0) {
+      if(limit == -1) {
+        /* tandem repeat partition */
+        tr_partition(ISAd - incr, first, first, last, &a, &b, last - SA - 1);
+
+        /* update ranks */
+        if(a < last) {
+          for(c = first, v = a - SA - 1; c < a; ++c) { ISA[*c] = v; }
+        }
+        if(b < last) {
+          for(c = a, v = b - SA - 1; c < b; ++c) { ISA[*c] = v; }
+        }
+
+        /* push */
+        if(1 < (b - a)) {
+          STACK_PUSH5(NULL, a, b, 0, 0);
+          STACK_PUSH5(ISAd - incr, first, last, -2, trlink);
+          trlink = ssize - 2;
+        }
+        if((a - first) <= (last - b)) {
+          if(1 < (a - first)) {
+            STACK_PUSH5(ISAd, b, last, tr_ilg(last - b), trlink);
+            last = a, limit = tr_ilg(a - first);
+          } else if(1 < (last - b)) {
+            first = b, limit = tr_ilg(last - b);
+          } else {
+            STACK_POP5(ISAd, first, last, limit, trlink);
+          }
+        } else {
+          if(1 < (last - b)) {
+            STACK_PUSH5(ISAd, first, a, tr_ilg(a - first), trlink);
+            first = b, limit = tr_ilg(last - b);
+          } else if(1 < (a - first)) {
+            last = a, limit = tr_ilg(a - first);
+          } else {
+            STACK_POP5(ISAd, first, last, limit, trlink);
+          }
+        }
+      } else if(limit == -2) {
+        /* tandem repeat copy */
+        a = stack[--ssize].b, b = stack[ssize].c;
+        if(stack[ssize].d == 0) {
+          tr_copy(ISA, SA, first, a, b, last, ISAd - ISA);
+        } else {
+          if(0 <= trlink) { stack[trlink].d = -1; }
+          tr_partialcopy(ISA, SA, first, a, b, last, ISAd - ISA);
+        }
+        STACK_POP5(ISAd, first, last, limit, trlink);
+      } else {
+        /* sorted partition */
+        if(0 <= *first) {
+          a = first;
+          do { ISA[*a] = a - SA; } while((++a < last) && (0 <= *a));
+          first = a;
+        }
+        if(first < last) {
+          a = first; do { *a = ~*a; } while(*++a < 0);
+          next = (ISA[*a] != ISAd[*a]) ? tr_ilg(a - first + 1) : -1;
+          if(++a < last) { for(b = first, v = a - SA - 1; b < a; ++b) { ISA[*b] = v; } }
+
+          /* push */
+          if(trbudget_check(budget, a - first)) {
+            if((a - first) <= (last - a)) {
+              STACK_PUSH5(ISAd, a, last, -3, trlink);
+              ISAd += incr, last = a, limit = next;
+            } else {
+              if(1 < (last - a)) {
+                STACK_PUSH5(ISAd + incr, first, a, next, trlink);
+                first = a, limit = -3;
+              } else {
+                ISAd += incr, last = a, limit = next;
+              }
+            }
+          } else {
+            if(0 <= trlink) { stack[trlink].d = -1; }
+            if(1 < (last - a)) {
+              first = a, limit = -3;
+            } else {
+              STACK_POP5(ISAd, first, last, limit, trlink);
+            }
+          }
+        } else {
+          STACK_POP5(ISAd, first, last, limit, trlink);
+        }
+      }
+      continue;
+    }
+
+    if((last - first) <= TR_INSERTIONSORT_THRESHOLD) {
+      tr_insertionsort(ISAd, first, last);
+      limit = -3;
+      continue;
+    }
+
+    if(limit-- == 0) {
+      tr_heapsort(ISAd, first, last - first);
+      for(a = last - 1; first < a; a = b) {
+        for(x = ISAd[*a], b = a - 1; (first <= b) && (ISAd[*b] == x); --b) { *b = ~*b; }
+      }
+      limit = -3;
+      continue;
+    }
+
+    /* choose pivot */
+    a = tr_pivot(ISAd, first, last);
+    SWAP(*first, *a);
+    v = ISAd[*first];
+
+    /* partition */
+    tr_partition(ISAd, first, first + 1, last, &a, &b, v);
+    if((last - first) != (b - a)) {
+      next = (ISA[*a] != v) ? tr_ilg(b - a) : -1;
+
+      /* update ranks */
+      for(c = first, v = a - SA - 1; c < a; ++c) { ISA[*c] = v; }
+      if(b < last) { for(c = a, v = b - SA - 1; c < b; ++c) { ISA[*c] = v; } }
+
+      /* push */
+      if((1 < (b - a)) && (trbudget_check(budget, b - a))) {
+        if((a - first) <= (last - b)) {
+          if((last - b) <= (b - a)) {
+            if(1 < (a - first)) {
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              STACK_PUSH5(ISAd, b, last, limit, trlink);
+              last = a;
+            } else if(1 < (last - b)) {
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              first = b;
+            } else {
+              ISAd += incr, first = a, last = b, limit = next;
+            }
+          } else if((a - first) <= (b - a)) {
+            if(1 < (a - first)) {
+              STACK_PUSH5(ISAd, b, last, limit, trlink);
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              last = a;
+            } else {
+              STACK_PUSH5(ISAd, b, last, limit, trlink);
+              ISAd += incr, first = a, last = b, limit = next;
+            }
+          } else {
+            STACK_PUSH5(ISAd, b, last, limit, trlink);
+            STACK_PUSH5(ISAd, first, a, limit, trlink);
+            ISAd += incr, first = a, last = b, limit = next;
+          }
+        } else {
+          if((a - first) <= (b - a)) {
+            if(1 < (last - b)) {
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              STACK_PUSH5(ISAd, first, a, limit, trlink);
+              first = b;
+            } else if(1 < (a - first)) {
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              last = a;
+            } else {
+              ISAd += incr, first = a, last = b, limit = next;
+            }
+          } else if((last - b) <= (b - a)) {
+            if(1 < (last - b)) {
+              STACK_PUSH5(ISAd, first, a, limit, trlink);
+              STACK_PUSH5(ISAd + incr, a, b, next, trlink);
+              first = b;
+            } else {
+              STACK_PUSH5(ISAd, first, a, limit, trlink);
+              ISAd += incr, first = a, last = b, limit = next;
+            }
+          } else {
+            STACK_PUSH5(ISAd, first, a, limit, trlink);
+            STACK_PUSH5(ISAd, b, last, limit, trlink);
+            ISAd += incr, first = a, last = b, limit = next;
+          }
+        }
+      } else {
+        if((1 < (b - a)) && (0 <= trlink)) { stack[trlink].d = -1; }
+        if((a - first) <= (last - b)) {
+          if(1 < (a - first)) {
+            STACK_PUSH5(ISAd, b, last, limit, trlink);
+            last = a;
+          } else if(1 < (last - b)) {
+            first = b;
+          } else {
+            STACK_POP5(ISAd, first, last, limit, trlink);
+          }
+        } else {
+          if(1 < (last - b)) {
+            STACK_PUSH5(ISAd, first, a, limit, trlink);
+            first = b;
+          } else if(1 < (a - first)) {
+            last = a;
+          } else {
+            STACK_POP5(ISAd, first, last, limit, trlink);
+          }
+        }
+      }
+    } else {
+      if(trbudget_check(budget, last - first)) {
+        limit = tr_ilg(last - first), ISAd += incr;
+      } else {
+        if(0 <= trlink) { stack[trlink].d = -1; }
+        STACK_POP5(ISAd, first, last, limit, trlink);
+      }
+    }
+  }
+#undef STACK_SIZE
+}
+
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Tandem repeat sort */
+static
+void
+trsort(int *ISA, int *SA, int n, int depth) {
+  int *ISAd;
+  int *first, *last;
+  trbudget_t budget;
+  int t, skip, unsorted;
+
+  trbudget_init(&budget, tr_ilg(n) * 2 / 3, n);
+/*  trbudget_init(&budget, tr_ilg(n) * 3 / 4, n); */
+  for(ISAd = ISA + depth; -n < *SA; ISAd += ISAd - ISA) {
+    first = SA;
+    skip = 0;
+    unsorted = 0;
+    do {
+      if((t = *first) < 0) { first -= t; skip += t; }
+      else {
+        if(skip != 0) { *(first + skip) = skip; skip = 0; }
+        last = SA + ISA[t] + 1;
+        if(1 < (last - first)) {
+          budget.count = 0;
+          tr_introsort(ISA, ISAd, SA, first, last, &budget);
+          if(budget.count != 0) { unsorted += budget.count; }
+          else { skip = first - last; }
+        } else if((last - first) == 1) {
+          skip = -1;
+        }
+        first = last;
+      }
+    } while(first < (SA + n));
+    if(skip != 0) { *(first + skip) = skip; }
+    if(unsorted == 0) { break; }
+  }
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/* Sorts suffixes of type B*. */
+static
+int
+sort_typeBstar(const unsigned char *T, int *SA,
+               int *bucket_A, int *bucket_B,
+               int n, int openMP) {
+  int *PAb, *ISAb, *buf;
+#ifdef LIBBSC_OPENMP
+  int *curbuf;
+  int l;
+#endif
+  int i, j, k, t, m, bufsize;
+  int c0, c1;
+#ifdef LIBBSC_OPENMP
+  int d0, d1;
+#endif
+  (void)openMP;
+
+  /* Initialize bucket arrays. */
+  for(i = 0; i < BUCKET_A_SIZE; ++i) { bucket_A[i] = 0; }
+  for(i = 0; i < BUCKET_B_SIZE; ++i) { bucket_B[i] = 0; }
+
+  /* Count the number of occurrences of the first one or two characters of each
+     type A, B and B* suffix. Moreover, store the beginning position of all
+     type B* suffixes into the array SA. */
+  for(i = n - 1, m = n, c0 = T[n - 1]; 0 <= i;) {
+    /* type A suffix. */
+    do { ++BUCKET_A(c1 = c0); } while((0 <= --i) && ((c0 = T[i]) >= c1));
+    if(0 <= i) {
+      /* type B* suffix. */
+      ++BUCKET_BSTAR(c0, c1);
+      SA[--m] = i;
+      /* type B suffix. */
+      for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) {
+        ++BUCKET_B(c0, c1);
+      }
+    }
+  }
+  m = n - m;
+/*
+note:
+  A type B* suffix is lexicographically smaller than a type B suffix that
+  begins with the same first two characters.
+*/
+
+  /* Calculate the index of start/end point of each bucket. */
+  for(c0 = 0, i = 0, j = 0; c0 < ALPHABET_SIZE; ++c0) {
+    t = i + BUCKET_A(c0);
+    BUCKET_A(c0) = i + j; /* start point */
+    i = t + BUCKET_B(c0, c0);
+    for(c1 = c0 + 1; c1 < ALPHABET_SIZE; ++c1) {
+      j += BUCKET_BSTAR(c0, c1);
+      BUCKET_BSTAR(c0, c1) = j; /* end point */
+      i += BUCKET_B(c0, c1);
+    }
+  }
+
+  if(0 < m) {
+    /* Sort the type B* suffixes by their first two characters. */
+    PAb = SA + n - m; ISAb = SA + m;
+    for(i = m - 2; 0 <= i; --i) {
+      t = PAb[i], c0 = T[t], c1 = T[t + 1];
+      SA[--BUCKET_BSTAR(c0, c1)] = i;
+    }
+    t = PAb[m - 1], c0 = T[t], c1 = T[t + 1];
+    SA[--BUCKET_BSTAR(c0, c1)] = m - 1;
+
+    /* Sort the type B* substrings using sssort. */
+#ifdef LIBBSC_OPENMP
+    if (openMP)
+    {
+        buf = SA + m;
+        c0 = ALPHABET_SIZE - 2, c1 = ALPHABET_SIZE - 1, j = m;
+#pragma omp parallel default(shared) private(bufsize, curbuf, k, l, d0, d1)
+        {
+          bufsize = (n - (2 * m)) / omp_get_num_threads();
+          curbuf = buf + omp_get_thread_num() * bufsize;
+          k = 0;
+          for(;;) {
+            #pragma omp critical(sssort_lock)
+            {
+              if(0 < (l = j)) {
+                d0 = c0, d1 = c1;
+                do {
+                  k = BUCKET_BSTAR(d0, d1);
+                  if(--d1 <= d0) {
+                    d1 = ALPHABET_SIZE - 1;
+                    if(--d0 < 0) { break; }
+                  }
+                } while(((l - k) <= 1) && (0 < (l = k)));
+                c0 = d0, c1 = d1, j = k;
+              }
+            }
+            if(l == 0) { break; }
+            sssort(T, PAb, SA + k, SA + l,
+                   curbuf, bufsize, 2, n, *(SA + k) == (m - 1));
+          }
+        }
+    }
+    else
+    {
+        buf = SA + m, bufsize = n - (2 * m);
+        for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) {
+          for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) {
+            i = BUCKET_BSTAR(c0, c1);
+            if(1 < (j - i)) {
+              sssort(T, PAb, SA + i, SA + j,
+                     buf, bufsize, 2, n, *(SA + i) == (m - 1));
+            }
+          }
+        }
+    }
+#else
+    buf = SA + m, bufsize = n - (2 * m);
+    for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) {
+      for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) {
+        i = BUCKET_BSTAR(c0, c1);
+        if(1 < (j - i)) {
+          sssort(T, PAb, SA + i, SA + j,
+                 buf, bufsize, 2, n, *(SA + i) == (m - 1));
+        }
+      }
+    }
+#endif
+
+    /* Compute ranks of type B* substrings. */
+    for(i = m - 1; 0 <= i; --i) {
+      if(0 <= SA[i]) {
+        j = i;
+        do { ISAb[SA[i]] = i; } while((0 <= --i) && (0 <= SA[i]));
+        SA[i + 1] = i - j;
+        if(i <= 0) { break; }
+      }
+      j = i;
+      do { ISAb[SA[i] = ~SA[i]] = j; } while(SA[--i] < 0);
+      ISAb[SA[i]] = j;
+    }
+
+    /* Construct the inverse suffix array of type B* suffixes using trsort. */
+    trsort(ISAb, SA, m, 1);
+
+    /* Set the sorted order of type B* suffixes. */
+    for(i = n - 1, j = m, c0 = T[n - 1]; 0 <= i;) {
+      for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) >= c1); --i, c1 = c0) { }
+      if(0 <= i) {
+        t = i;
+        for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) { }
+        SA[ISAb[--j]] = ((t == 0) || (1 < (t - i))) ? t : ~t;
+      }
+    }
+
+    /* Calculate the index of start/end point of each bucket. */
+    BUCKET_B(ALPHABET_SIZE - 1, ALPHABET_SIZE - 1) = n; /* end point */
+    for(c0 = ALPHABET_SIZE - 2, k = m - 1; 0 <= c0; --c0) {
+      i = BUCKET_A(c0 + 1) - 1;
+      for(c1 = ALPHABET_SIZE - 1; c0 < c1; --c1) {
+        t = i - BUCKET_B(c0, c1);
+        BUCKET_B(c0, c1) = i; /* end point */
+
+        /* Move all type B* suffixes to the correct position. */
+        for(i = t, j = BUCKET_BSTAR(c0, c1);
+            j <= k;
+            --i, --k) { SA[i] = SA[k]; }
+      }
+      BUCKET_BSTAR(c0, c0 + 1) = i - BUCKET_B(c0, c0) + 1; /* start point */
+      BUCKET_B(c0, c0) = i; /* end point */
+    }
+  }
+
+  return m;
+}
+
+/* Constructs the suffix array by using the sorted order of type B* suffixes. */
+static
+void
+construct_SA(const unsigned char *T, int *SA,
+             int *bucket_A, int *bucket_B,
+             int n, int m) {
+  int *i, *j, *k;
+  int s;
+  int c0, c1, c2;
+
+  if(0 < m) {
+    /* Construct the sorted order of type B suffixes by using
+       the sorted order of type B* suffixes. */
+    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
+      /* Scan the suffix array from right to left. */
+      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),
+          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;
+          i <= j;
+          --j) {
+        if(0 < (s = *j)) {
+          assert(T[s] == c1);
+          assert(((s + 1) < n) && (T[s] <= T[s + 1]));
+          assert(T[s - 1] <= T[s]);
+          *j = ~s;
+          c0 = T[--s];
+          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }
+          if(c0 != c2) {
+            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; }
+            k = SA + BUCKET_B(c2 = c0, c1);
+          }
+          assert(k < j); assert(k != NULL);
+          *k-- = s;
+        } else {
+          assert(((s == 0) && (T[s] == c1)) || (s < 0));
+          *j = ~s;
+        }
+      }
+    }
+  }
+
+  /* Construct the suffix array by using
+     the sorted order of type B suffixes. */
+  k = SA + BUCKET_A(c2 = T[n - 1]);
+  *k++ = (T[n - 2] < c2) ? ~(n - 1) : (n - 1);
+  /* Scan the suffix array from left to right. */
+  for(i = SA, j = SA + n; i < j; ++i) {
+    if(0 < (s = *i)) {
+      assert(T[s - 1] >= T[s]);
+      c0 = T[--s];
+      if((s == 0) || (T[s - 1] < c0)) { s = ~s; }
+      if(c0 != c2) {
+        BUCKET_A(c2) = k - SA;
+        k = SA + BUCKET_A(c2 = c0);
+      }
+      assert(i < k);
+      *k++ = s;
+    } else {
+      assert(s < 0);
+      *i = ~s;
+    }
+  }
+}
+
+/* Constructs the burrows-wheeler transformed string directly
+   by using the sorted order of type B* suffixes. */
+static
+int
+construct_BWT(const unsigned char *T, int *SA,
+              int *bucket_A, int *bucket_B,
+              int n, int m) {
+  int *i, *j, *k, *orig;
+  int s;
+  int c0, c1, c2;
+
+  if(0 < m) {
+    /* Construct the sorted order of type B suffixes by using
+       the sorted order of type B* suffixes. */
+    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
+      /* Scan the suffix array from right to left. */
+      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),
+          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;
+          i <= j;
+          --j) {
+        if(0 < (s = *j)) {
+          assert(T[s] == c1);
+          assert(((s + 1) < n) && (T[s] <= T[s + 1]));
+          assert(T[s - 1] <= T[s]);
+          c0 = T[--s];
+          *j = ~((int)c0);
+          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }
+          if(c0 != c2) {
+            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; }
+            k = SA + BUCKET_B(c2 = c0, c1);
+          }
+          assert(k < j); assert(k != NULL);
+          *k-- = s;
+        } else if(s != 0) {
+          *j = ~s;
+#ifndef NDEBUG
+        } else {
+          assert(T[s] == c1);
+#endif
+        }
+      }
+    }
+  }
+
+  /* Construct the BWTed string by using
+     the sorted order of type B suffixes. */
+  k = SA + BUCKET_A(c2 = T[n - 1]);
+  *k++ = (T[n - 2] < c2) ? ~((int)T[n - 2]) : (n - 1);
+  /* Scan the suffix array from left to right. */
+  for(i = SA, j = SA + n, orig = SA; i < j; ++i) {
+    if(0 < (s = *i)) {
+      assert(T[s - 1] >= T[s]);
+      c0 = T[--s];
+      *i = c0;
+      if((0 < s) && (T[s - 1] < c0)) { s = ~((int)T[s - 1]); }
+      if(c0 != c2) {
+        BUCKET_A(c2) = k - SA;
+        k = SA + BUCKET_A(c2 = c0);
+      }
+      assert(i < k);
+      *k++ = s;
+    } else if(s != 0) {
+      *i = ~s;
+    } else {
+      orig = i;
+    }
+  }
+
+  return orig - SA;
+}
+
+/* Constructs the burrows-wheeler transformed string directly
+   by using the sorted order of type B* suffixes. */
+static
+int
+construct_BWT_indexes(const unsigned char *T, int *SA,
+                      int *bucket_A, int *bucket_B,
+                      int n, int m,
+                      unsigned char * num_indexes, int * indexes) {
+  int *i, *j, *k, *orig;
+  int s;
+  int c0, c1, c2;
+
+  int mod = n / 8;
+  {
+      mod |= mod >> 1;  mod |= mod >> 2;
+      mod |= mod >> 4;  mod |= mod >> 8;
+      mod |= mod >> 16; mod >>= 1;
+
+      *num_indexes = (unsigned char)((n - 1) / (mod + 1));
+  }
+
+  if(0 < m) {
+    /* Construct the sorted order of type B suffixes by using
+       the sorted order of type B* suffixes. */
+    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
+      /* Scan the suffix array from right to left. */
+      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),
+          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;
+          i <= j;
+          --j) {
+        if(0 < (s = *j)) {
+          assert(T[s] == c1);
+          assert(((s + 1) < n) && (T[s] <= T[s + 1]));
+          assert(T[s - 1] <= T[s]);
+
+          if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = j - SA;
+
+          c0 = T[--s];
+          *j = ~((int)c0);
+          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }
+          if(c0 != c2) {
+            if(0 <= c2) { BUCKET_B(c2, c1) = k - SA; }
+            k = SA + BUCKET_B(c2 = c0, c1);
+          }
+          assert(k < j); assert(k != NULL);
+          *k-- = s;
+        } else if(s != 0) {
+          *j = ~s;
+#ifndef NDEBUG
+        } else {
+          assert(T[s] == c1);
+#endif
+        }
+      }
+    }
+  }
+
+  /* Construct the BWTed string by using
+     the sorted order of type B suffixes. */
+  k = SA + BUCKET_A(c2 = T[n - 1]);
+  if (T[n - 2] < c2) {
+    if (((n - 1) & mod) == 0) indexes[(n - 1) / (mod + 1) - 1] = k - SA;
+    *k++ = ~((int)T[n - 2]);
+  }
+  else {
+    *k++ = n - 1;
+  }
+
+  /* Scan the suffix array from left to right. */
+  for(i = SA, j = SA + n, orig = SA; i < j; ++i) {
+    if(0 < (s = *i)) {
+      assert(T[s - 1] >= T[s]);
+
+      if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = i - SA;
+
+      c0 = T[--s];
+      *i = c0;
+      if(c0 != c2) {
+        BUCKET_A(c2) = k - SA;
+        k = SA + BUCKET_A(c2 = c0);
+      }
+      assert(i < k);
+      if((0 < s) && (T[s - 1] < c0)) {
+          if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = k - SA;
+          *k++ = ~((int)T[s - 1]);
+      } else
+        *k++ = s;
+    } else if(s != 0) {
+      *i = ~s;
+    } else {
+      orig = i;
+    }
+  }
+
+  return orig - SA;
+}
+
+
+/*---------------------------------------------------------------------------*/
+
+/*- Function -*/
+
+int
+divsufsort(const unsigned char *T, int *SA, int n, int openMP) {
+  int *bucket_A, *bucket_B;
+  int m;
+  int err = 0;
+
+  /* Check arguments. */
+  if((T == NULL) || (SA == NULL) || (n < 0)) { return -1; }
+  else if(n == 0) { return 0; }
+  else if(n == 1) { SA[0] = 0; return 0; }
+  else if(n == 2) { m = (T[0] < T[1]); SA[m ^ 1] = 0, SA[m] = 1; return 0; }
+
+  bucket_A = (int *)malloc(BUCKET_A_SIZE * sizeof(int));
+  bucket_B = (int *)malloc(BUCKET_B_SIZE * sizeof(int));
+
+  /* Suffixsort. */
+  if((bucket_A != NULL) && (bucket_B != NULL)) {
+    m = sort_typeBstar(T, SA, bucket_A, bucket_B, n, openMP);
+    construct_SA(T, SA, bucket_A, bucket_B, n, m);
+  } else {
+    err = -2;
+  }
+
+  free(bucket_B);
+  free(bucket_A);
+
+  return err;
+}
+
+int
+divbwt(const unsigned char *T, unsigned char *U, int *A, int n, unsigned char * num_indexes, int * indexes, int openMP) {
+  int *B;
+  int *bucket_A, *bucket_B;
+  int m, pidx, i;
+
+  /* Check arguments. */
+  if((T == NULL) || (U == NULL) || (n < 0)) { return -1; }
+  else if(n <= 1) { if(n == 1) { U[0] = T[0]; } return n; }
+
+  if((B = A) == NULL) { B = (int *)malloc((size_t)(n + 1) * sizeof(int)); }
+  bucket_A = (int *)malloc(BUCKET_A_SIZE * sizeof(int));
+  bucket_B = (int *)malloc(BUCKET_B_SIZE * sizeof(int));
+
+  /* Burrows-Wheeler Transform. */
+  if((B != NULL) && (bucket_A != NULL) && (bucket_B != NULL)) {
+    m = sort_typeBstar(T, B, bucket_A, bucket_B, n, openMP);
+
+    if (num_indexes == NULL || indexes == NULL) {
+        pidx = construct_BWT(T, B, bucket_A, bucket_B, n, m);
+    } else {
+        pidx = construct_BWT_indexes(T, B, bucket_A, bucket_B, n, m, num_indexes, indexes);
+    }
+
+    /* Copy to output string. */
+    U[0] = T[n - 1];
+    for(i = 0; i < pidx; ++i) { U[i + 1] = (unsigned char)B[i]; }
+    for(i += 1; i < n; ++i) { U[i] = (unsigned char)B[i]; }
+    pidx += 1;
+  } else {
+    pidx = -2;
+  }
+
+  free(bucket_B);
+  free(bucket_A);
+  if(A == NULL) { free(B); }
+
+  return pidx;
+}

programs/Makefile

@@ -71,7 +71,7 @@ RUST_TARGET_32 ?= i686-unknown-linux-gnu
 RUST_STATICLIB_32 := $(RUST_TARGET_DIR)/$(RUST_TARGET_32)/release/libzstd_rs.a
 RUST_CARGO_FLAGS := --manifest-path $(RUST_MANIFEST) --release \
                     --target-dir $(RUST_TARGET_DIR) --no-default-features
-RUST_CARGO_FLAGS += --features compression,decompression,dict-builder
+RUST_CARGO_FLAGS += --features compression,decompression
 ifneq ($(RUST_HUF_FEATURE),)
 RUST_CARGO_FLAGS += --features $(RUST_HUF_FEATURE)
 endif
@@ -96,7 +96,7 @@ $(RUST_CLI_STATICLIB): $(RUST_CLI_SOURCES)
 $(RUST_CLI_STATICLIB_32): $(RUST_CLI_SOURCES)
 	$(CARGO) build $(RUST_CLI_CARGO_FLAGS) --target $(RUST_TARGET_32)
 
-RUST_DECOMPRESS_BUILD_CONFIG := lib-c0-d1-b0-$(RUST_BUILD_CONFIG)
+RUST_DECOMPRESS_BUILD_CONFIG := lib-c0-d1-$(RUST_BUILD_CONFIG)
 RUST_DECOMPRESS_TARGET_DIR := $(RUST_DIR)/target/$(RUST_DECOMPRESS_BUILD_CONFIG)
 RUST_DECOMPRESS_STATICLIB := $(RUST_DECOMPRESS_TARGET_DIR)/release/libzstd_rs.a
 RUST_DECOMPRESS_CARGO_FLAGS := --manifest-path $(RUST_MANIFEST) --release \
@@ -119,7 +119,7 @@ RUST_DECOMPRESS_CLI_CARGO_FLAGS := --manifest-path $(RUST_CLI_MANIFEST) --releas
 $(RUST_DECOMPRESS_CLI_STATICLIB): $(RUST_CLI_SOURCES)
 	$(CARGO) build $(RUST_DECOMPRESS_CLI_CARGO_FLAGS)
 
-RUST_COMPRESS_BUILD_CONFIG := lib-c1-d0-b0-$(RUST_BUILD_CONFIG)
+RUST_COMPRESS_BUILD_CONFIG := lib-c1-d0-$(RUST_BUILD_CONFIG)
 RUST_COMPRESS_TARGET_DIR := $(RUST_DIR)/target/$(RUST_COMPRESS_BUILD_CONFIG)
 RUST_COMPRESS_STATICLIB := $(RUST_COMPRESS_TARGET_DIR)/release/libzstd_rs.a
 RUST_COMPRESS_CARGO_FLAGS := --manifest-path $(RUST_MANIFEST) --release \
@@ -129,17 +129,6 @@ RUST_COMPRESS_CARGO_FLAGS := --manifest-path $(RUST_MANIFEST) --release \
 $(RUST_COMPRESS_STATICLIB): $(RUST_SOURCES)
 	$(CARGO) build $(RUST_COMPRESS_CARGO_FLAGS)
 
-RUST_DICTBUILDER_BUILD_CONFIG := lib-c1-d0-b1-$(RUST_BUILD_CONFIG)
-RUST_DICTBUILDER_TARGET_DIR := $(RUST_DIR)/target/$(RUST_DICTBUILDER_BUILD_CONFIG)
-RUST_DICTBUILDER_STATICLIB := $(RUST_DICTBUILDER_TARGET_DIR)/release/libzstd_rs.a
-RUST_DICTBUILDER_CARGO_FLAGS := --manifest-path $(RUST_MANIFEST) --release \
-                                 --target-dir $(RUST_DICTBUILDER_TARGET_DIR) \
-                                 --no-default-features \
-                                 --features compression,dict-builder
-
-$(RUST_DICTBUILDER_STATICLIB): $(RUST_SOURCES)
-	$(CARGO) build $(RUST_DICTBUILDER_CARGO_FLAGS)
-
 RUST_COMPRESS_CLI_BUILD_CONFIG := cli-c1-d0-$(RUST_BUILD_CONFIG)
 RUST_COMPRESS_CLI_TARGET_DIR := $(RUST_DIR)/target/$(RUST_COMPRESS_CLI_BUILD_CONFIG)
 RUST_COMPRESS_CLI_STATICLIB := $(RUST_COMPRESS_CLI_TARGET_DIR)/release/libzstd_cli_rs.a
@@ -423,7 +412,7 @@ zstd-compress: $(ZSTDLIB_COMMON_SRC) $(ZSTDLIB_COMPRESS_SRC) zstdcli.c util.c ti
 
 ## zstd-dictBuilder: executable supporting dictionary creation and compression (only)
 CLEAN += zstd-dictBuilder
-zstd-dictBuilder: $(ZSTDLIB_COMMON_SRC) $(ZSTDLIB_COMPRESS_SRC) $(ZDICT_SRC) zstdcli.c util.c timefn.c fileio.c fileio_asyncio.c dibio.c $(RUST_DICTBUILDER_STATICLIB) $(RUST_COMPRESS_CLI_STATICLIB)
+zstd-dictBuilder: $(ZSTDLIB_COMMON_SRC) $(ZSTDLIB_COMPRESS_SRC) $(ZDICT_SRC) zstdcli.c util.c timefn.c fileio.c fileio_asyncio.c dibio.c $(RUST_COMPRESS_STATICLIB) $(RUST_COMPRESS_CLI_STATICLIB)
 	$(CC) $(FLAGS) -DZSTD_NOBENCH -DZSTD_NODECOMPRESS -DZSTD_NOTRACE $^ -o $@$(EXT)
 
 RUST_DIRECT_LINK_TARGETS := zstd32 zstd-nolegacy zstd-small zstd-frugal \

rust/Cargo.toml

@@ -7,10 +7,9 @@ edition = "2021"
 crate-type = ["staticlib"]
 
 [features]
-default = ["compression", "decompression", "dict-builder"]
+default = ["compression", "decompression"]
 compression = []
 decompression = []
-dict-builder = []
 huf-force-decompress-x1 = []
 huf-force-decompress-x2 = []
 

rust/README.md

@@ -31,9 +31,22 @@ zstd ABI:
   - `zstd_presplit` chooses split points for full compression blocks.
   - `zstd_compress_literals` emits raw, RLE, and Huffman literal sections
     while preserving the compressor's Huffman-table repeat state.
+  - `zstd_compress_stats` converts stored sequences into symbol codes,
+    selects each block's symbol encoding types, compresses a seqStore's
+    literals and sequences into a compressed-block body, builds the block
+    entropy statistics shared with the superblock writer and the block
+    splitter, and exports collected sequences in the public `ZSTD_Sequence`
+    format.  Its C shims extract the sequence store, the entropy-table
+    leaves, and the two `ZSTD_CCtx_params` scalars these paths read.
   - `zstd_compress_frame` serializes frame headers, skippable frames, and the
     last empty block; it takes scalar frame parameters so the C-owned
     `ZSTD_CCtx_params` layout never crosses the language boundary.
+  - `zstd_compress_params` owns the compression-level tables (formerly
+    `clevels.h`), parameter bounds, clamping, validation, table selection,
+    source/dictionary adjustment, and match-state/CDict size estimation.
+    The C integration layer keeps the public `ZSTD_*` symbols and feeds the
+    leaves configuration-owned scalars: the excluded-block-compressor
+    strategy cascade, struct sizes, and sanitizer redzone policy.
   - `zstd_fast` and `zstd_double_fast` implement the single- and two-table
     fast block match finders, including attached and external dictionary paths.
   - `zstd_lazy` implements greedy, lazy, lazy2, and binary-tree matching,
@@ -42,10 +55,6 @@ zstd ABI:
     the dynamic-programming optimal parser itself remains in C for now.
   - `zstd_ldm` implements long-distance-match parameter selection, table
     maintenance, sequence generation, and sequence consumption.
-- Dictionary building
-  - `divsufsort` constructs the suffix array that drives the legacy `ZDICT`
-    trainer (`ZDICT_trainFromBuffer_legacy`).  The sample analysis and
-    dictionary assembly in `zdict.c`, `cover.c`, and `fastcover.c` remain C.
 - Runtime support
   - `threading` provides platform pthread wrappers required by zstd headers.
   - `pool` implements the bounded worker pool used by multithreaded compression.
@@ -64,11 +73,10 @@ zstd ABI:
     `fileio` backend still owns file opening, safe replacement, sparse writes,
     metadata, and streaming I/O.
 
-The optimal block matcher, high-level frame compression, dictionary-building
+The optimal block matcher, high-level frame compression, dictionary-building,
-except suffix-array construction, legacy decoding callbacks, and the CLI
+legacy decoding callbacks, and the CLI file-I/O backend are still C. They must
-file-I/O backend are still C. They must move before the rewrite is complete.
+move before the rewrite is complete. Keeping that boundary explicit prevents a
-Keeping that boundary explicit prevents a passing hybrid build from being
+passing hybrid build from being mistaken for the final all-Rust result.
-mistaken for the final all-Rust result.
 
 ## Compatibility boundary
 
@@ -79,9 +87,8 @@ makefile source list as a small shim so header configuration and platform
 preprocessor behavior stay available during the transition.
 
 The library, test, and program makefiles select an archive directory for the
-active C configuration: enabled compression/decompression/dictionary-builder
+active C configuration: enabled compression/decompression modules, default or
-modules, default or forced HUF X1/X2, and the matching Rust target for 32-bit
+forced HUF X1/X2, and the matching Rust target for 32-bit C binaries. The
-C binaries. The
 native static archive flattens Rust object members rather than nesting a Rust
 archive, while the native shared library retains all migrated Rust exports.
 When the HUF mode changes, the test and program paths also rebuild cached C

rust/src/divsufsort.rs

@@ -1,2756 +0,0 @@
-#![allow(clippy::missing_safety_doc)]
-#![allow(clippy::too_many_arguments)]
-
-//! Suffix-array construction for the dictionary builder.
-//!
-//! Port of `lib/dictBuilder/divsufsort.c` (libdivsufsort-lite, Copyright (c)
-//! 2003-2008 Yuta Mori, MIT license) in the exact configuration zstd compiles
-//! it with: `ALPHABET_SIZE = 256`, `SS_INSERTIONSORT_THRESHOLD = 8`,
-//! `SS_BLOCKSIZE = 1024`, and no OpenMP.  Only `divsufsort()` is exported;
-//! `divbwt()` has no callers anywhere in zstd and was not ported.
-//!
-//! The C implementation walks raw `int*` cursors through the caller's SA
-//! buffer, including transient one-before-the-range positions.  Every such
-//! cursor is translated to an `isize` index into one `&mut [i32]` slice
-//! covering the whole buffer, so all arithmetic — including the
-//! bitwise-complement rank marking and the C `int` value semantics — matches
-//! the original exactly while staying bounds-checked.
-
-use std::os::raw::c_int;
-use std::slice;
-
-const BUCKET_A_SIZE: usize = 256; /* ALPHABET_SIZE */
-const BUCKET_B_SIZE: usize = 256 * 256; /* ALPHABET_SIZE * ALPHABET_SIZE */
-const ALPHABET_SIZE: i32 = 256;
-const SS_INSERTIONSORT_THRESHOLD: isize = 8;
-const SS_BLOCKSIZE: isize = 1024;
-/* minstacksize = log(SS_BLOCKSIZE) / log(3) * 2 */
-const SS_MISORT_STACKSIZE: usize = 16;
-const SS_SMERGE_STACKSIZE: usize = 32;
-const TR_INSERTIONSORT_THRESHOLD: isize = 8;
-const TR_STACKSIZE: usize = 64;
-
-#[rustfmt::skip]
-static LG_TABLE: [i32; 256] = [
- -1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
-  5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
-];
-
-#[rustfmt::skip]
-static SQQ_TABLE: [i32; 256] = [
-  0,  16,  22,  27,  32,  35,  39,  42,  45,  48,  50,  53,  55,  57,  59,  61,
- 64,  65,  67,  69,  71,  73,  75,  76,  78,  80,  81,  83,  84,  86,  87,  89,
- 90,  91,  93,  94,  96,  97,  98,  99, 101, 102, 103, 104, 106, 107, 108, 109,
-110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,
-128, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
-143, 144, 144, 145, 146, 147, 148, 149, 150, 150, 151, 152, 153, 154, 155, 155,
-156, 157, 158, 159, 160, 160, 161, 162, 163, 163, 164, 165, 166, 167, 167, 168,
-169, 170, 170, 171, 172, 173, 173, 174, 175, 176, 176, 177, 178, 178, 179, 180,
-181, 181, 182, 183, 183, 184, 185, 185, 186, 187, 187, 188, 189, 189, 190, 191,
-192, 192, 193, 193, 194, 195, 195, 196, 197, 197, 198, 199, 199, 200, 201, 201,
-202, 203, 203, 204, 204, 205, 206, 206, 207, 208, 208, 209, 209, 210, 211, 211,
-212, 212, 213, 214, 214, 215, 215, 216, 217, 217, 218, 218, 219, 219, 220, 221,
-221, 222, 222, 223, 224, 224, 225, 225, 226, 226, 227, 227, 228, 229, 229, 230,
-230, 231, 231, 232, 232, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238,
-239, 240, 240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247,
-247, 248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255,
-];
-
-/* `ss_ilg` in its `256 <= SS_BLOCKSIZE` configuration. */
-#[inline]
-fn ss_ilg(n: isize) -> i32 {
-    let n = n as i32;
-    if n & 0xff00 != 0 {
-        8 + LG_TABLE[((n >> 8) & 0xff) as usize]
-    } else {
-        LG_TABLE[(n & 0xff) as usize]
-    }
-}
-
-#[inline]
-fn ss_isqrt(x: isize) -> isize {
-    if x >= SS_BLOCKSIZE * SS_BLOCKSIZE {
-        return SS_BLOCKSIZE;
-    }
-    let x = x as i32;
-    let e = if (x as u32) & 0xffff_0000 != 0 {
-        if (x as u32) & 0xff00_0000 != 0 {
-            24 + LG_TABLE[((x >> 24) & 0xff) as usize]
-        } else {
-            16 + LG_TABLE[((x >> 16) & 0xff) as usize]
-        }
-    } else if x & 0xff00 != 0 {
-        8 + LG_TABLE[((x >> 8) & 0xff) as usize]
-    } else {
-        LG_TABLE[(x & 0xff) as usize]
-    };
-
-    let mut y;
-    if e >= 16 {
-        y = SQQ_TABLE[(x >> ((e - 6) - (e & 1))) as usize] << ((e >> 1) - 7);
-        if e >= 24 {
-            y = (y + 1 + x / y) >> 1;
-        }
-        y = (y + 1 + x / y) >> 1;
-    } else if e >= 8 {
-        y = (SQQ_TABLE[(x >> ((e - 6) - (e & 1))) as usize] >> (7 - (e >> 1))) + 1;
-    } else {
-        return (SQQ_TABLE[x as usize] >> 4) as isize;
-    }
-
-    (if x < y * y { y - 1 } else { y }) as isize
-}
-
-/* --------------------------------------------------------------------- */
-
-/// Compares two suffixes.  `(p10, p11)` and `(p20, p21)` are the `p[0]`/`p[1]`
-/// pairs the C routine reads through its `const int*` arguments; passing the
-/// values directly also serves `sssort()`'s local two-element `PAi` array.
-#[inline]
-fn ss_compare(t: &[u8], p10: i32, p11: i32, p20: i32, p21: i32, depth: i32) -> i32 {
-    let mut u1 = (depth + p10) as isize;
-    let mut u2 = (depth + p20) as isize;
-    let u1n = (p11 + 2) as isize;
-    let u2n = (p21 + 2) as isize;
-
-    while u1 < u1n && u2 < u2n && t[u1 as usize] == t[u2 as usize] {
-        u1 += 1;
-        u2 += 1;
-    }
-
-    if u1 < u1n {
-        if u2 < u2n {
-            t[u1 as usize] as i32 - t[u2 as usize] as i32
-        } else {
-            1
-        }
-    } else if u2 < u2n {
-        -1
-    } else {
-        0
-    }
-}
-
-/// `ss_compare(T, p1, p2, depth)` for pointers `p1`/`p2` into the SA buffer.
-#[inline]
-fn ss_compare_pa(t: &[u8], sa: &[i32], p1: isize, p2: isize, depth: i32) -> i32 {
-    ss_compare(
-        t,
-        sa[p1 as usize],
-        sa[(p1 + 1) as usize],
-        sa[p2 as usize],
-        sa[(p2 + 1) as usize],
-        depth,
-    )
-}
-
-/* --------------------------------------------------------------------- */
-
-/* Insertionsort for small size groups */
-fn ss_insertionsort(t: &[u8], sa: &mut [i32], pa: isize, first: isize, last: isize, depth: i32) {
-    let mut i = last - 2;
-    while first <= i {
-        let t0 = sa[i as usize];
-        let mut j = i + 1;
-        let mut r;
-        loop {
-            r = ss_compare_pa(t, sa, pa + t0 as isize, pa + sa[j as usize] as isize, depth);
-            if r <= 0 {
-                break;
-            }
-            loop {
-                sa[(j - 1) as usize] = sa[j as usize];
-                j += 1;
-                if !(j < last && sa[j as usize] < 0) {
-                    break;
-                }
-            }
-            if last <= j {
-                break;
-            }
-        }
-        if r == 0 {
-            sa[j as usize] = !sa[j as usize];
-        }
-        sa[(j - 1) as usize] = t0;
-        i -= 1;
-    }
-}
-
-/* --------------------------------------------------------------------- */
-
-/// `Td[PA[SA[p]]]` — the depth-`td` sorting key of the suffix stored at `p`.
-#[inline(always)]
-fn ss_key(t: &[u8], sa: &[i32], td: isize, pa: isize, p: isize) -> i32 {
-    t[(td + sa[(pa + sa[p as usize] as isize) as usize] as isize) as usize] as i32
-}
-
-/// `Td[v]` for an already-loaded SA element `v` (`Td[PA[v]]` in C).
-#[inline(always)]
-fn ss_key_of(t: &[u8], sa: &[i32], td: isize, pa: isize, v: i32) -> i32 {
-    t[(td + sa[(pa + v as isize) as usize] as isize) as usize] as i32
-}
-
-/// `Td[PA[SA[p]] - 1]` — the character preceding the depth-`td` key.
-#[inline(always)]
-fn ss_key_pred(t: &[u8], sa: &[i32], td: isize, pa: isize, p: isize) -> i32 {
-    t[(td + sa[(pa + sa[p as usize] as isize) as usize] as isize - 1) as usize] as i32
-}
-
-fn ss_fixdown(t: &[u8], td: isize, sa: &mut [i32], pa: isize, base: isize, i: isize, size: isize) {
-    let mut i = i;
-    let v = sa[(base + i) as usize];
-    let c = ss_key_of(t, sa, td, pa, v);
-    loop {
-        let mut j = 2 * i + 1;
-        if j >= size {
-            break;
-        }
-        let mut k = j;
-        j += 1;
-        let mut d = ss_key(t, sa, td, pa, base + k);
-        let e = ss_key(t, sa, td, pa, base + j);
-        if d < e {
-            k = j;
-            d = e;
-        }
-        if d <= c {
-            break;
-        }
-        sa[(base + i) as usize] = sa[(base + k) as usize];
-        i = k;
-    }
-    sa[(base + i) as usize] = v;
-}
-
-/* Simple top-down heapsort. */
-fn ss_heapsort(t: &[u8], td: isize, sa: &mut [i32], pa: isize, base: isize, size: isize) {
-    let mut m = size;
-    if size % 2 == 0 {
-        m -= 1;
-        if ss_key(t, sa, td, pa, base + m / 2) < ss_key(t, sa, td, pa, base + m) {
-            sa.swap((base + m) as usize, (base + m / 2) as usize);
-        }
-    }
-
-    let mut i = m / 2 - 1;
-    while 0 <= i {
-        ss_fixdown(t, td, sa, pa, base, i, m);
-        i -= 1;
-    }
-    if size % 2 == 0 {
-        sa.swap(base as usize, (base + m) as usize);
-        ss_fixdown(t, td, sa, pa, base, 0, m);
-    }
-    let mut i = m - 1;
-    while 0 < i {
-        let t0 = sa[base as usize];
-        sa[base as usize] = sa[(base + i) as usize];
-        ss_fixdown(t, td, sa, pa, base, 0, i);
-        sa[(base + i) as usize] = t0;
-        i -= 1;
-    }
-}
-
-/* --------------------------------------------------------------------- */
-
-/* Returns the median of three elements. */
-#[inline]
-fn ss_median3(
-    t: &[u8],
-    sa: &[i32],
-    td: isize,
-    pa: isize,
-    v1: isize,
-    v2: isize,
-    v3: isize,
-) -> isize {
-    let mut v1 = v1;
-    let mut v2 = v2;
-    if ss_key(t, sa, td, pa, v1) > ss_key(t, sa, td, pa, v2) {
-        std::mem::swap(&mut v1, &mut v2);
-    }
-    if ss_key(t, sa, td, pa, v2) > ss_key(t, sa, td, pa, v3) {
-        if ss_key(t, sa, td, pa, v1) > ss_key(t, sa, td, pa, v3) {
-            return v1;
-        }
-        return v3;
-    }
-    v2
-}
-
-/* Returns the median of five elements. */
-#[inline]
-fn ss_median5(
-    t: &[u8],
-    sa: &[i32],
-    td: isize,
-    pa: isize,
-    v1: isize,
-    v2: isize,
-    v3: isize,
-    v4: isize,
-    v5: isize,
-) -> isize {
-    let mut v1 = v1;
-    let mut v2 = v2;
-    let mut v3 = v3;
-    let mut v4 = v4;
-    let mut v5 = v5;
-    if ss_key(t, sa, td, pa, v2) > ss_key(t, sa, td, pa, v3) {
-        std::mem::swap(&mut v2, &mut v3);
-    }
-    if ss_key(t, sa, td, pa, v4) > ss_key(t, sa, td, pa, v5) {
-        std::mem::swap(&mut v4, &mut v5);
-    }
-    if ss_key(t, sa, td, pa, v2) > ss_key(t, sa, td, pa, v4) {
-        std::mem::swap(&mut v2, &mut v4);
-        std::mem::swap(&mut v3, &mut v5);
-    }
-    if ss_key(t, sa, td, pa, v1) > ss_key(t, sa, td, pa, v3) {
-        std::mem::swap(&mut v1, &mut v3);
-    }
-    if ss_key(t, sa, td, pa, v1) > ss_key(t, sa, td, pa, v4) {
-        std::mem::swap(&mut v1, &mut v4);
-        std::mem::swap(&mut v3, &mut v5);
-    }
-    if ss_key(t, sa, td, pa, v3) > ss_key(t, sa, td, pa, v4) {
-        return v4;
-    }
-    v3
-}
-
-/* Returns the pivot element. */
-#[inline]
-fn ss_pivot(t: &[u8], sa: &[i32], td: isize, pa: isize, first: isize, last: isize) -> isize {
-    let mut t0 = last - first;
-    let middle = first + t0 / 2;
-
-    if t0 <= 512 {
-        if t0 <= 32 {
-            return ss_median3(t, sa, td, pa, first, middle, last - 1);
-        }
-        t0 >>= 2;
-        return ss_median5(
-            t,
-            sa,
-            td,
-            pa,
-            first,
-            first + t0,
-            middle,
-            last - 1 - t0,
-            last - 1,
-        );
-    }
-    t0 >>= 3;
-    let first = ss_median3(t, sa, td, pa, first, first + t0, first + (t0 << 1));
-    let middle = ss_median3(t, sa, td, pa, middle - t0, middle, middle + t0);
-    let last = ss_median3(t, sa, td, pa, last - 1 - (t0 << 1), last - 1 - t0, last - 1);
-    ss_median3(t, sa, td, pa, first, middle, last)
-}
-
-/* --------------------------------------------------------------------- */
-
-/* Binary partition for substrings. */
-/* The `>= x + 1` comparison deliberately mirrors the C expression shape. */
-#[allow(clippy::int_plus_one)]
-fn ss_partition(sa: &mut [i32], pa: isize, first: isize, last: isize, depth: i32) -> isize {
-    let mut a = first - 1;
-    let mut b = last;
-    loop {
-        loop {
-            a += 1;
-            if !(a < b) {
-                break;
-            }
-            if !(sa[(pa + sa[a as usize] as isize) as usize] + depth
-                >= sa[(pa + sa[a as usize] as isize + 1) as usize] + 1)
-            {
-                break;
-            }
-            sa[a as usize] = !sa[a as usize];
-        }
-        loop {
-            b -= 1;
-            if !(a < b) {
-                break;
-            }
-            if !(sa[(pa + sa[b as usize] as isize) as usize] + depth
-                < sa[(pa + sa[b as usize] as isize + 1) as usize] + 1)
-            {
-                break;
-            }
-        }
-        if b <= a {
-            break;
-        }
-        let t0 = !sa[b as usize];
-        sa[b as usize] = sa[a as usize];
-        sa[a as usize] = t0;
-    }
-    if first < a {
-        sa[first as usize] = !sa[first as usize];
-    }
-    a
-}
-
-/* Multikey introsort for medium size groups. */
-fn ss_mintrosort(t: &[u8], sa: &mut [i32], pa: isize, first: isize, last: isize, depth: i32) {
-    let mut stack = [(0isize, 0isize, 0i32, 0i32); SS_MISORT_STACKSIZE];
-    let mut ssize = 0usize;
-    let mut first = first;
-    let mut last = last;
-    let mut depth = depth;
-    let mut limit = ss_ilg(last - first);
-    let mut x: i32 = 0;
-
-    loop {
-        if last - first <= SS_INSERTIONSORT_THRESHOLD {
-            if 1 < last - first {
-                ss_insertionsort(t, sa, pa, first, last, depth);
-            }
-            /* STACK_POP */
-            if ssize == 0 {
-                return;
-            }
-            ssize -= 1;
-            (first, last, depth, limit) = stack[ssize];
-            continue;
-        }
-
-        let td = depth as isize;
-        if limit == 0 {
-            ss_heapsort(t, td, sa, pa, first, last - first);
-        }
-        limit -= 1;
-        if limit < 0 {
-            let mut a = first + 1;
-            let mut v = ss_key(t, sa, td, pa, first);
-            while a < last {
-                x = ss_key(t, sa, td, pa, a);
-                if x != v {
-                    if 1 < a - first {
-                        break;
-                    }
-                    v = x;
-                    first = a;
-                }
-                a += 1;
-            }
-            if ss_key_pred(t, sa, td, pa, first) < v {
-                first = ss_partition(sa, pa, first, a, depth);
-            }
-            if a - first <= last - a {
-                if 1 < a - first {
-                    stack[ssize] = (a, last, depth, -1);
-                    ssize += 1;
-                    last = a;
-                    depth += 1;
-                    limit = ss_ilg(a - first);
-                } else {
-                    first = a;
-                    limit = -1;
-                }
-            } else if 1 < last - a {
-                stack[ssize] = (first, a, depth + 1, ss_ilg(a - first));
-                ssize += 1;
-                first = a;
-                limit = -1;
-            } else {
-                last = a;
-                depth += 1;
-                limit = ss_ilg(a - first);
-            }
-            continue;
-        }
-
-        /* choose pivot */
-        let mut a = ss_pivot(t, sa, td, pa, first, last);
-        let v = ss_key(t, sa, td, pa, a);
-        sa.swap(first as usize, a as usize);
-
-        /* partition */
-        let mut b = first;
-        loop {
-            b += 1;
-            if !(b < last) {
-                break;
-            }
-            x = ss_key(t, sa, td, pa, b);
-            if x != v {
-                break;
-            }
-        }
-        a = b;
-        if a < last && x < v {
-            loop {
-                b += 1;
-                if !(b < last) {
-                    break;
-                }
-                x = ss_key(t, sa, td, pa, b);
-                if !(x <= v) {
-                    break;
-                }
-                if x == v {
-                    sa.swap(b as usize, a as usize);
-                    a += 1;
-                }
-            }
-        }
-        let mut c = last;
-        loop {
-            c -= 1;
-            if !(b < c) {
-                break;
-            }
-            x = ss_key(t, sa, td, pa, c);
-            if x != v {
-                break;
-            }
-        }
-        let mut d = c;
-        if b < d && x > v {
-            loop {
-                c -= 1;
-                if !(b < c) {
-                    break;
-                }
-                x = ss_key(t, sa, td, pa, c);
-                if !(x >= v) {
-                    break;
-                }
-                if x == v {
-                    sa.swap(c as usize, d as usize);
-                    d -= 1;
-                }
-            }
-        }
-        while b < c {
-            sa.swap(b as usize, c as usize);
-            loop {
-                b += 1;
-                if !(b < c) {
-                    break;
-                }
-                x = ss_key(t, sa, td, pa, b);
-                if !(x <= v) {
-                    break;
-                }
-                if x == v {
-                    sa.swap(b as usize, a as usize);
-                    a += 1;
-                }
-            }
-            loop {
-                c -= 1;
-                if !(b < c) {
-                    break;
-                }
-                x = ss_key(t, sa, td, pa, c);
-                if !(x >= v) {
-                    break;
-                }
-                if x == v {
-                    sa.swap(c as usize, d as usize);
-                    d -= 1;
-                }
-            }
-        }
-
-        if a <= d {
-            c = b - 1;
-
-            let mut s = a - first;
-            let t0 = b - a;
-            if s > t0 {
-                s = t0;
-            }
-            let mut e = first;
-            let mut f = b - s;
-            while 0 < s {
-                sa.swap(e as usize, f as usize);
-                s -= 1;
-                e += 1;
-                f += 1;
-            }
-            let mut s = d - c;
-            let t0 = last - d - 1;
-            if s > t0 {
-                s = t0;
-            }
-            let mut e = b;
-            let mut f = last - s;
-            while 0 < s {
-                sa.swap(e as usize, f as usize);
-                s -= 1;
-                e += 1;
-                f += 1;
-            }
-
-            a = first + (b - a);
-            c = last - (d - c);
-            b = if v <= ss_key_pred(t, sa, td, pa, a) {
-                a
-            } else {
-                ss_partition(sa, pa, a, c, depth)
-            };
-
-            if a - first <= last - c {
-                if last - c <= c - b {
-                    stack[ssize] = (b, c, depth + 1, ss_ilg(c - b));
-                    ssize += 1;
-                    stack[ssize] = (c, last, depth, limit);
-                    ssize += 1;
-                    last = a;
-                } else if a - first <= c - b {
-                    stack[ssize] = (c, last, depth, limit);
-                    ssize += 1;
-                    stack[ssize] = (b, c, depth + 1, ss_ilg(c - b));
-                    ssize += 1;
-                    last = a;
-                } else {
-                    stack[ssize] = (c, last, depth, limit);
-                    ssize += 1;
-                    stack[ssize] = (first, a, depth, limit);
-                    ssize += 1;
-                    first = b;
-                    last = c;
-                    depth += 1;
-                    limit = ss_ilg(c - b);
-                }
-            } else if a - first <= c - b {
-                stack[ssize] = (b, c, depth + 1, ss_ilg(c - b));
-                ssize += 1;
-                stack[ssize] = (first, a, depth, limit);
-                ssize += 1;
-                first = c;
-            } else if last - c <= c - b {
-                stack[ssize] = (first, a, depth, limit);
-                ssize += 1;
-                stack[ssize] = (b, c, depth + 1, ss_ilg(c - b));
-                ssize += 1;
-                first = c;
-            } else {
-                stack[ssize] = (first, a, depth, limit);
-                ssize += 1;
-                stack[ssize] = (c, last, depth, limit);
-                ssize += 1;
-                first = b;
-                last = c;
-                depth += 1;
-                limit = ss_ilg(c - b);
-            }
-        } else {
-            limit += 1;
-            if ss_key_pred(t, sa, td, pa, first) < v {
-                first = ss_partition(sa, pa, first, last, depth);
-                limit = ss_ilg(last - first);
-            }
-            depth += 1;
-        }
-    }
-}
-
-/* --------------------------------------------------------------------- */
-
-#[inline]
-fn ss_blockswap(sa: &mut [i32], a: isize, b: isize, n: isize) {
-    let mut a = a;
-    let mut b = b;
-    let mut n = n;
-    while 0 < n {
-        sa.swap(a as usize, b as usize);
-        n -= 1;
-        a += 1;
-        b += 1;
-    }
-}
-
-#[inline]
-fn ss_rotate(sa: &mut [i32], first: isize, middle: isize, last: isize) {
-    let mut first = first;
-    let mut last = last;
-    let mut l = middle - first;
-    let mut r = last - middle;
-    while 0 < l && 0 < r {
-        if l == r {
-            ss_blockswap(sa, first, middle, l);
-            break;
-        }
-        if l < r {
-            let mut a = last - 1;
-            let mut b = middle - 1;
-            let mut t0 = sa[a as usize];
-            loop {
-                sa[a as usize] = sa[b as usize];
-                a -= 1;
-                sa[b as usize] = sa[a as usize];
-                b -= 1;
-                if b < first {
-                    sa[a as usize] = t0;
-                    last = a;
-                    r -= l + 1;
-                    if r <= l {
-                        break;
-                    }
-                    a -= 1;
-                    b = middle - 1;
-                    t0 = sa[a as usize];
-                }
-            }
-        } else {
-            let mut a = first;
-            let mut b = middle;
-            let mut t0 = sa[a as usize];
-            loop {
-                sa[a as usize] = sa[b as usize];
-                a += 1;
-                sa[b as usize] = sa[a as usize];
-                b += 1;
-                if last <= b {
-                    sa[a as usize] = t0;
-                    first = a + 1;
-                    l -= r + 1;
-                    if l <= r {
-                        break;
-                    }
-                    a += 1;
-                    b = middle;
-                    t0 = sa[a as usize];
-                }
-            }
-        }
-    }
-}
-
-/* --------------------------------------------------------------------- */
-
-fn ss_inplacemerge(
-    t: &[u8],
-    sa: &mut [i32],
-    pa: isize,
-    first: isize,
-    middle: isize,
-    last: isize,
-    depth: i32,
-) {
-    let mut middle = middle;
-    let mut last = last;
-    loop {
-        let x: i32;
-        let p: isize;
-        if sa[(last - 1) as usize] < 0 {
-            x = 1;
-            p = pa + (!sa[(last - 1) as usize]) as isize;
-        } else {
-            x = 0;
-            p = pa + sa[(last - 1) as usize] as isize;
-        }
-        let mut a = first;
-        let mut len = middle - first;
-        let mut half = len >> 1;
-        let mut r: i32 = -1;
-        while 0 < len {
-            let b = a + half;
-            let bv = sa[b as usize];
-            let q = ss_compare_pa(
-                t,
-                sa,
-                pa + (if 0 <= bv { bv } else { !bv }) as isize,
-                p,
-                depth,
-            );
-            if q < 0 {
-                a = b + 1;
-                half -= (len & 1) ^ 1;
-            } else {
-                r = q;
-            }
-            len = half;
-            half >>= 1;
-        }
-        if a < middle {
-            if r == 0 {
-                sa[a as usize] = !sa[a as usize];
-            }
-            ss_rotate(sa, a, middle, last);
-            last -= middle - a;
-            middle = a;
-            if first == middle {
-                break;
-            }
-        }
-        last -= 1;
-        if x != 0 {
-            loop {
-                last -= 1;
-                if !(sa[last as usize] < 0) {
-                    break;
-                }
-            }
-        }
-        if middle == last {
-            break;
-        }
-    }
-}
-
-/* --------------------------------------------------------------------- */
-
-/* Merge-forward with internal buffer. */
-fn ss_mergeforward(
-    t: &[u8],
-    sa: &mut [i32],
-    pa: isize,
-    first: isize,
-    middle: isize,
-    last: isize,
-    buf: isize,
-    depth: i32,
-) {
-    let bufend = buf + (middle - first) - 1;
-    ss_blockswap(sa, buf, first, middle - first);
-
-    let mut a = first;
-    let t0 = sa[a as usize];
-    let mut b = buf;
-    let mut c = middle;
-    loop {
-        let r = ss_compare_pa(
-            t,
-            sa,
-            pa + sa[b as usize] as isize,
-            pa + sa[c as usize] as isize,
-            depth,
-        );
-        if r < 0 {
-            loop {
-                sa[a as usize] = sa[b as usize];
-                a += 1;
-                if bufend <= b {
-                    sa[bufend as usize] = t0;
-                    return;
-                }
-                sa[b as usize] = sa[a as usize];
-                b += 1;
-                if !(sa[b as usize] < 0) {
-                    break;
-                }
-            }
-        } else if r > 0 {
-            loop {
-                sa[a as usize] = sa[c as usize];
-                a += 1;
-                sa[c as usize] = sa[a as usize];
-                c += 1;
-                if last <= c {
-                    while b < bufend {
-                        sa[a as usize] = sa[b as usize];
-                        a += 1;
-                        sa[b as usize] = sa[a as usize];
-                        b += 1;
-                    }
-                    sa[a as usize] = sa[b as usize];
-                    sa[b as usize] = t0;
-                    return;
-                }
-                if !(sa[c as usize] < 0) {
-                    break;
-                }
-            }
-        } else {
-            sa[c as usize] = !sa[c as usize];
-            loop {
-                sa[a as usize] = sa[b as usize];
-                a += 1;
-                if bufend <= b {
-                    sa[bufend as usize] = t0;
-                    return;
-                }
-                sa[b as usize] = sa[a as usize];
-                b += 1;
-                if !(sa[b as usize] < 0) {
-                    break;
-                }
-            }
-            loop {
-                sa[a as usize] = sa[c as usize];
-                a += 1;
-                sa[c as usize] = sa[a as usize];
-                c += 1;
-                if last <= c {
-                    while b < bufend {
-                        sa[a as usize] = sa[b as usize];
-                        a += 1;
-                        sa[b as usize] = sa[a as usize];
-                        b += 1;
-                    }
-                    sa[a as usize] = sa[b as usize];
-                    sa[b as usize] = t0;
-                    return;
-                }
-                if !(sa[c as usize] < 0) {
-                    break;
-                }
-            }
-        }
-    }
-}
-
-/* Merge-backward with internal buffer. */
-fn ss_mergebackward(
-    t: &[u8],
-    sa: &mut [i32],
-    pa: isize,
-    first: isize,
-    middle: isize,
-    last: isize,
-    buf: isize,
-    depth: i32,
-) {
-    let bufend = buf + (last - middle) - 1;
-    ss_blockswap(sa, buf, middle, last - middle);
-
-    let mut x = 0i32;
-    let mut p1: isize;
-    let mut p2: isize;
-    if sa[bufend as usize] < 0 {
-        p1 = pa + (!sa[bufend as usize]) as isize;
-        x |= 1;
-    } else {
-        p1 = pa + sa[bufend as usize] as isize;
-    }
-    if sa[(middle - 1) as usize] < 0 {
-        p2 = pa + (!sa[(middle - 1) as usize]) as isize;
-        x |= 2;
-    } else {
-        p2 = pa + sa[(middle - 1) as usize] as isize;
-    }
-    let mut a = last - 1;
-    let t0 = sa[a as usize];
-    let mut b = bufend;
-    let mut c = middle - 1;
-    loop {
-        let r = ss_compare_pa(t, sa, p1, p2, depth);
-        if 0 < r {
-            if x & 1 != 0 {
-                loop {
-                    sa[a as usize] = sa[b as usize];
-                    a -= 1;
-                    sa[b as usize] = sa[a as usize];
-                    b -= 1;
-                    if !(sa[b as usize] < 0) {
-                        break;
-                    }
-                }
-                x ^= 1;
-            }
-            sa[a as usize] = sa[b as usize];
-            a -= 1;
-            if b <= buf {
-                sa[buf as usize] = t0;
-                break;
-            }
-            sa[b as usize] = sa[a as usize];
-            b -= 1;
-            if sa[b as usize] < 0 {
-                p1 = pa + (!sa[b as usize]) as isize;
-                x |= 1;
-            } else {
-                p1 = pa + sa[b as usize] as isize;
-            }
-        } else if r < 0 {
-            if x & 2 != 0 {
-                loop {
-                    sa[a as usize] = sa[c as usize];
-                    a -= 1;
-                    sa[c as usize] = sa[a as usize];
-                    c -= 1;
-                    if !(sa[c as usize] < 0) {
-                        break;
-                    }
-                }
-                x ^= 2;
-            }
-            sa[a as usize] = sa[c as usize];
-            a -= 1;
-            sa[c as usize] = sa[a as usize];
-            c -= 1;
-            if c < first {
-                while buf < b {
-                    sa[a as usize] = sa[b as usize];
-                    a -= 1;
-                    sa[b as usize] = sa[a as usize];
-                    b -= 1;
-                }
-                sa[a as usize] = sa[b as usize];
-                sa[b as usize] = t0;
-                break;
-            }
-            if sa[c as usize] < 0 {
-                p2 = pa + (!sa[c as usize]) as isize;
-                x |= 2;
-            } else {
-                p2 = pa + sa[c as usize] as isize;
-            }
-        } else {
-            if x & 1 != 0 {
-                loop {
-                    sa[a as usize] = sa[b as usize];
-                    a -= 1;
-                    sa[b as usize] = sa[a as usize];
-                    b -= 1;
-                    if !(sa[b as usize] < 0) {
-                        break;
-                    }
-                }
-                x ^= 1;
-            }
-            sa[a as usize] = !sa[b as usize];
-            a -= 1;
-            if b <= buf {
-                sa[buf as usize] = t0;
-                break;
-            }
-            sa[b as usize] = sa[a as usize];
-            b -= 1;
-            if x & 2 != 0 {
-                loop {
-                    sa[a as usize] = sa[c as usize];
-                    a -= 1;
-                    sa[c as usize] = sa[a as usize];
-                    c -= 1;
-                    if !(sa[c as usize] < 0) {
-                        break;
-                    }
-                }
-                x ^= 2;
-            }
-            sa[a as usize] = sa[c as usize];
-            a -= 1;
-            sa[c as usize] = sa[a as usize];
-            c -= 1;
-            if c < first {
-                while buf < b {
-                    sa[a as usize] = sa[b as usize];
-                    a -= 1;
-                    sa[b as usize] = sa[a as usize];
-                    b -= 1;
-                }
-                sa[a as usize] = sa[b as usize];
-                sa[b as usize] = t0;
-                break;
-            }
-            if sa[b as usize] < 0 {
-                p1 = pa + (!sa[b as usize]) as isize;
-                x |= 1;
-            } else {
-                p1 = pa + sa[b as usize] as isize;
-            }
-            if sa[c as usize] < 0 {
-                p2 = pa + (!sa[c as usize]) as isize;
-                x |= 2;
-            } else {
-                p2 = pa + sa[c as usize] as isize;
-            }
-        }
-    }
-}
-
-/// `GETIDX` — undoes the "already merged" complement marking.
-#[inline(always)]
-fn getidx(a: i32) -> i32 {
-    if 0 <= a {
-        a
-    } else {
-        !a
-    }
-}
-
-/// `MERGE_CHECK` — restores or sets the complement marks after a merge.
-#[inline]
-fn ss_merge_check(t: &[u8], sa: &mut [i32], pa: isize, a: isize, b: isize, c: i32, depth: i32) {
-    if (c & 1) != 0
-        || ((c & 2) != 0
-            && ss_compare_pa(
-                t,
-                sa,
-                pa + getidx(sa[(a - 1) as usize]) as isize,
-                pa + sa[a as usize] as isize,
-                depth,
-            ) == 0)
-    {
-        sa[a as usize] = !sa[a as usize];
-    }
-    if (c & 4) != 0
-        && ss_compare_pa(
-            t,
-            sa,
-            pa + getidx(sa[(b - 1) as usize]) as isize,
-            pa + sa[b as usize] as isize,
-            depth,
-        ) == 0
-    {
-        sa[b as usize] = !sa[b as usize];
-    }
-}
-
-/* D&C based merge. */
-fn ss_swapmerge(
-    t: &[u8],
-    sa: &mut [i32],
-    pa: isize,
-    first: isize,
-    middle: isize,
-    last: isize,
-    buf: isize,
-    bufsize: isize,
-    depth: i32,
-) {
-    let mut stack = [(0isize, 0isize, 0isize, 0i32); SS_SMERGE_STACKSIZE];
-    let mut ssize = 0usize;
-    let mut first = first;
-    let mut middle = middle;
-    let mut last = last;
-    let mut check = 0i32;
-
-    loop {
-        if last - middle <= bufsize {
-            if first < middle && middle < last {
-                ss_mergebackward(t, sa, pa, first, middle, last, buf, depth);
-            }
-            ss_merge_check(t, sa, pa, first, last, check, depth);
-            if ssize == 0 {
-                return;
-            }
-            ssize -= 1;
-            (first, middle, last, check) = stack[ssize];
-            continue;
-        }
-
-        if middle - first <= bufsize {
-            if first < middle {
-                ss_mergeforward(t, sa, pa, first, middle, last, buf, depth);
-            }
-            ss_merge_check(t, sa, pa, first, last, check, depth);
-            if ssize == 0 {
-                return;
-            }
-            ssize -= 1;
-            (first, middle, last, check) = stack[ssize];
-            continue;
-        }
-
-        let mut m: isize = 0;
-        let mut len = std::cmp::min(middle - first, last - middle);
-        let mut half = len >> 1;
-        while 0 < len {
-            if ss_compare_pa(
-                t,
-                sa,
-                pa + getidx(sa[(middle + m + half) as usize]) as isize,
-                pa + getidx(sa[(middle - m - half - 1) as usize]) as isize,
-                depth,
-            ) < 0
-            {
-                m += half + 1;
-                half -= (len & 1) ^ 1;
-            }
-            len = half;
-            half >>= 1;
-        }
-
-        if 0 < m {
-            let lm = middle - m;
-            let rm = middle + m;
-            ss_blockswap(sa, lm, middle, m);
-            let mut l = middle;
-            let mut r = middle;
-            let mut next = 0i32;
-            if rm < last {
-                if sa[rm as usize] < 0 {
-                    sa[rm as usize] = !sa[rm as usize];
-                    if first < lm {
-                        loop {
-                            l -= 1;
-                            if !(sa[l as usize] < 0) {
-                                break;
-                            }
-                        }
-                        next |= 4;
-                    }
-                    next |= 1;
-                } else if first < lm {
-                    while sa[r as usize] < 0 {
-                        r += 1;
-                    }
-                    next |= 2;
-                }
-            }
-
-            if l - first <= last - r {
-                stack[ssize] = (r, rm, last, (next & 3) | (check & 4));
-                ssize += 1;
-                middle = lm;
-                last = l;
-                check = (check & 3) | (next & 4);
-            } else {
-                if (next & 2) != 0 && r == middle {
-                    next ^= 6;
-                }
-                stack[ssize] = (first, lm, l, (check & 3) | (next & 4));
-                ssize += 1;
-                first = r;
-                middle = rm;
-                check = (next & 3) | (check & 4);
-            }
-        } else {
-            if ss_compare_pa(
-                t,
-                sa,
-                pa + getidx(sa[(middle - 1) as usize]) as isize,
-                pa + sa[middle as usize] as isize,
-                depth,
-            ) == 0
-            {
-                sa[middle as usize] = !sa[middle as usize];
-            }
-            ss_merge_check(t, sa, pa, first, last, check, depth);
-            if ssize == 0 {
-                return;
-            }
-            ssize -= 1;
-            (first, middle, last, check) = stack[ssize];
-        }
-    }
-}
-
-/* --------------------------------------------------------------------- */
-
-/* Substring sort */
-fn sssort(
-    t: &[u8],
-    sa: &mut [i32],
-    pa: isize,
-    first: isize,
-    last: isize,
-    buf: isize,
-    bufsize: isize,
-    depth: i32,
-    n: isize,
-    lastsuffix: bool,
-) {
-    let mut first = first;
-    let mut buf = buf;
-    let mut bufsize = bufsize;
-
-    if lastsuffix {
-        first += 1;
-    }
-
-    let mut limit: isize = 0;
-    let mut middle = last;
-    if bufsize < SS_BLOCKSIZE && bufsize < last - first {
-        limit = ss_isqrt(last - first);
-        if bufsize < limit {
-            if SS_BLOCKSIZE < limit {
-                limit = SS_BLOCKSIZE;
-            }
-            middle = last - limit;
-            buf = middle;
-            bufsize = limit;
-        } else {
-            limit = 0;
-        }
-    }
-    let mut a = first;
-    let mut i: isize = 0;
-    while SS_BLOCKSIZE < middle - a {
-        ss_mintrosort(t, sa, pa, a, a + SS_BLOCKSIZE, depth);
-        let mut curbufsize = last - (a + SS_BLOCKSIZE);
-        let mut curbuf = a + SS_BLOCKSIZE;
-        if curbufsize <= bufsize {
-            curbufsize = bufsize;
-            curbuf = buf;
-        }
-        let mut b = a;
-        let mut k = SS_BLOCKSIZE;
-        let mut j = i;
-        while j & 1 != 0 {
-            ss_swapmerge(t, sa, pa, b - k, b, b + k, curbuf, curbufsize, depth);
-            b -= k;
-            k <<= 1;
-            j >>= 1;
-        }
-        a += SS_BLOCKSIZE;
-        i += 1;
-    }
-    ss_mintrosort(t, sa, pa, a, middle, depth);
-    let mut k = SS_BLOCKSIZE;
-    while i != 0 {
-        if i & 1 != 0 {
-            ss_swapmerge(t, sa, pa, a - k, a, middle, buf, bufsize, depth);
-            a -= k;
-        }
-        k <<= 1;
-        i >>= 1;
-    }
-    if limit != 0 {
-        ss_mintrosort(t, sa, pa, middle, last, depth);
-        ss_inplacemerge(t, sa, pa, first, middle, last, depth);
-    }
-
-    if lastsuffix {
-        /* Insert last type B* suffix. */
-        let pai0 = sa[(pa + sa[(first - 1) as usize] as isize) as usize];
-        let pai1 = (n - 2) as i32;
-        let i0 = sa[(first - 1) as usize];
-        let mut a = first;
-        while a < last {
-            let av = sa[a as usize];
-            if !(av < 0
-                || 0 < ss_compare(
-                    t,
-                    pai0,
-                    pai1,
-                    sa[(pa + av as isize) as usize],
-                    sa[(pa + av as isize + 1) as usize],
-                    depth,
-                ))
-            {
-                break;
-            }
-            sa[(a - 1) as usize] = av;
-            a += 1;
-        }
-        sa[(a - 1) as usize] = i0;
-    }
-}
-
-/* --------------------------------------------------------------------- */
-
-#[inline]
-fn tr_ilg(n: isize) -> i32 {
-    let n = n as i32;
-    if (n as u32) & 0xffff_0000 != 0 {
-        if (n as u32) & 0xff00_0000 != 0 {
-            24 + LG_TABLE[((n >> 24) & 0xff) as usize]
-        } else {
-            16 + LG_TABLE[((n >> 16) & 0xff) as usize]
-        }
-    } else if n & 0xff00 != 0 {
-        8 + LG_TABLE[((n >> 8) & 0xff) as usize]
-    } else {
-        LG_TABLE[(n & 0xff) as usize]
-    }
-}
-
-/* --------------------------------------------------------------------- */
-
-/// `ISAd[SA[p]]` — the depth-offset rank of the suffix stored at `p`.
-#[inline(always)]
-fn tr_key(sa: &[i32], isad: isize, p: isize) -> i32 {
-    sa[(isad + sa[p as usize] as isize) as usize]
-}
-
-/* Simple insertionsort for small size groups. */
-fn tr_insertionsort(sa: &mut [i32], isad: isize, first: isize, last: isize) {
-    let mut a = first + 1;
-    while a < last {
-        let t0 = sa[a as usize];
-        let mut b = a - 1;
-        let mut r;
-        loop {
-            r = sa[(isad + t0 as isize) as usize] - tr_key(sa, isad, b);
-            if !(0 > r) {
-                break;
-            }
-            loop {
-                sa[(b + 1) as usize] = sa[b as usize];
-                b -= 1;
-                if !(first <= b && sa[b as usize] < 0) {
-                    break;
-                }
-            }
-            if b < first {
-                break;
-            }
-        }
-        if r == 0 {
-            sa[b as usize] = !sa[b as usize];
-        }
-        sa[(b + 1) as usize] = t0;
-        a += 1;
-    }
-}
-
-/* --------------------------------------------------------------------- */
-
-fn tr_fixdown(sa: &mut [i32], isad: isize, base: isize, i: isize, size: isize) {
-    let mut i = i;
-    let v = sa[(base + i) as usize];
-    let c = sa[(isad + v as isize) as usize];
-    loop {
-        let mut j = 2 * i + 1;
-        if j >= size {
-            break;
-        }
-        let mut k = j;
-        j += 1;
-        let mut d = tr_key(sa, isad, base + k);
-        let e = tr_key(sa, isad, base + j);
-        if d < e {
-            k = j;
-            d = e;
-        }
-        if d <= c {
-            break;
-        }
-        sa[(base + i) as usize] = sa[(base + k) as usize];
-        i = k;
-    }
-    sa[(base + i) as usize] = v;
-}
-
-/* Simple top-down heapsort. */
-fn tr_heapsort(sa: &mut [i32], isad: isize, base: isize, size: isize) {
-    let mut m = size;
-    if size % 2 == 0 {
-        m -= 1;
-        if tr_key(sa, isad, base + m / 2) < tr_key(sa, isad, base + m) {
-            sa.swap((base + m) as usize, (base + m / 2) as usize);
-        }
-    }
-
-    let mut i = m / 2 - 1;
-    while 0 <= i {
-        tr_fixdown(sa, isad, base, i, m);
-        i -= 1;
-    }
-    if size % 2 == 0 {
-        sa.swap(base as usize, (base + m) as usize);
-        tr_fixdown(sa, isad, base, 0, m);
-    }
-    let mut i = m - 1;
-    while 0 < i {
-        let t0 = sa[base as usize];
-        sa[base as usize] = sa[(base + i) as usize];
-        tr_fixdown(sa, isad, base, 0, i);
-        sa[(base + i) as usize] = t0;
-        i -= 1;
-    }
-}
-
-/* --------------------------------------------------------------------- */
-
-/* Returns the median of three elements. */
-#[inline]
-fn tr_median3(sa: &[i32], isad: isize, v1: isize, v2: isize, v3: isize) -> isize {
-    let mut v1 = v1;
-    let mut v2 = v2;
-    if tr_key(sa, isad, v1) > tr_key(sa, isad, v2) {
-        std::mem::swap(&mut v1, &mut v2);
-    }
-    if tr_key(sa, isad, v2) > tr_key(sa, isad, v3) {
-        if tr_key(sa, isad, v1) > tr_key(sa, isad, v3) {
-            return v1;
-        }
-        return v3;
-    }
-    v2
-}
-
-/* Returns the median of five elements. */
-#[inline]
-fn tr_median5(
-    sa: &[i32],
-    isad: isize,
-    v1: isize,
-    v2: isize,
-    v3: isize,
-    v4: isize,
-    v5: isize,
-) -> isize {
-    let mut v1 = v1;
-    let mut v2 = v2;
-    let mut v3 = v3;
-    let mut v4 = v4;
-    let mut v5 = v5;
-    if tr_key(sa, isad, v2) > tr_key(sa, isad, v3) {
-        std::mem::swap(&mut v2, &mut v3);
-    }
-    if tr_key(sa, isad, v4) > tr_key(sa, isad, v5) {
-        std::mem::swap(&mut v4, &mut v5);
-    }
-    if tr_key(sa, isad, v2) > tr_key(sa, isad, v4) {
-        std::mem::swap(&mut v2, &mut v4);
-        std::mem::swap(&mut v3, &mut v5);
-    }
-    if tr_key(sa, isad, v1) > tr_key(sa, isad, v3) {
-        std::mem::swap(&mut v1, &mut v3);
-    }
-    if tr_key(sa, isad, v1) > tr_key(sa, isad, v4) {
-        std::mem::swap(&mut v1, &mut v4);
-        std::mem::swap(&mut v3, &mut v5);
-    }
-    if tr_key(sa, isad, v3) > tr_key(sa, isad, v4) {
-        return v4;
-    }
-    v3
-}
-
-/* Returns the pivot element. */
-#[inline]
-fn tr_pivot(sa: &[i32], isad: isize, first: isize, last: isize) -> isize {
-    let mut t0 = last - first;
-    let middle = first + t0 / 2;
-
-    if t0 <= 512 {
-        if t0 <= 32 {
-            return tr_median3(sa, isad, first, middle, last - 1);
-        }
-        t0 >>= 2;
-        return tr_median5(sa, isad, first, first + t0, middle, last - 1 - t0, last - 1);
-    }
-    t0 >>= 3;
-    let first = tr_median3(sa, isad, first, first + t0, first + (t0 << 1));
-    let middle = tr_median3(sa, isad, middle - t0, middle, middle + t0);
-    let last = tr_median3(sa, isad, last - 1 - (t0 << 1), last - 1 - t0, last - 1);
-    tr_median3(sa, isad, first, middle, last)
-}
-
-/* --------------------------------------------------------------------- */
-
-struct TrBudget {
-    chance: i32,
-    remain: i32,
-    incval: i32,
-    count: i32,
-}
-
-impl TrBudget {
-    fn new(chance: i32, incval: i32) -> Self {
-        TrBudget {
-            chance,
-            remain: incval,
-            incval,
-            count: 0,
-        }
-    }
-
-    fn check(&mut self, size: isize) -> bool {
-        let size = size as i32;
-        if size <= self.remain {
-            self.remain -= size;
-            return true;
-        }
-        if self.chance == 0 {
-            self.count += size;
-            return false;
-        }
-        self.remain += self.incval - size;
-        self.chance -= 1;
-        true
-    }
-}
-
-/* --------------------------------------------------------------------- */
-
-fn tr_partition(
-    sa: &mut [i32],
-    isad: isize,
-    first: isize,
-    middle: isize,
-    last: isize,
-    v: i32,
-) -> (isize, isize) {
-    let mut first = first;
-    let mut last = last;
-    let mut x: i32 = 0;
-
-    let mut b = middle - 1;
-    loop {
-        b += 1;
-        if !(b < last) {
-            break;
-        }
-        x = tr_key(sa, isad, b);
-        if x != v {
-            break;
-        }
-    }
-    let mut a = b;
-    if a < last && x < v {
-        loop {
-            b += 1;
-            if !(b < last) {
-                break;
-            }
-            x = tr_key(sa, isad, b);
-            if !(x <= v) {
-                break;
-            }
-            if x == v {
-                sa.swap(b as usize, a as usize);
-                a += 1;
-            }
-        }
-    }
-    let mut c = last;
-    loop {
-        c -= 1;
-        if !(b < c) {
-            break;
-        }
-        x = tr_key(sa, isad, c);
-        if x != v {
-            break;
-        }
-    }
-    let mut d = c;
-    if b < d && x > v {
-        loop {
-            c -= 1;
-            if !(b < c) {
-                break;
-            }
-            x = tr_key(sa, isad, c);
-            if !(x >= v) {
-                break;
-            }
-            if x == v {
-                sa.swap(c as usize, d as usize);
-                d -= 1;
-            }
-        }
-    }
-    while b < c {
-        sa.swap(b as usize, c as usize);
-        loop {
-            b += 1;
-            if !(b < c) {
-                break;
-            }
-            x = tr_key(sa, isad, b);
-            if !(x <= v) {
-                break;
-            }
-            if x == v {
-                sa.swap(b as usize, a as usize);
-                a += 1;
-            }
-        }
-        loop {
-            c -= 1;
-            if !(b < c) {
-                break;
-            }
-            x = tr_key(sa, isad, c);
-            if !(x >= v) {
-                break;
-            }
-            if x == v {
-                sa.swap(c as usize, d as usize);
-                d -= 1;
-            }
-        }
-    }
-
-    if a <= d {
-        c = b - 1;
-        let mut s = a - first;
-        let t0 = b - a;
-        if s > t0 {
-            s = t0;
-        }
-        let mut e = first;
-        let mut f = b - s;
-        while 0 < s {
-            sa.swap(e as usize, f as usize);
-            s -= 1;
-            e += 1;
-            f += 1;
-        }
-        let mut s = d - c;
-        let t0 = last - d - 1;
-        if s > t0 {
-            s = t0;
-        }
-        let mut e = b;
-        let mut f = last - s;
-        while 0 < s {
-            sa.swap(e as usize, f as usize);
-            s -= 1;
-            e += 1;
-            f += 1;
-        }
-        first += b - a;
-        last -= d - c;
-    }
-    (first, last)
-}
-
-/* sort suffixes of middle partition by using sorted order of suffixes of
- * left and right partition. */
-fn tr_copy(
-    sa: &mut [i32],
-    isa: isize,
-    first: isize,
-    a: isize,
-    b: isize,
-    last: isize,
-    depth: isize,
-) {
-    /* All cursor arithmetic is relative to the slice start, which is the C
-     * routine's `SA` pointer, so `x - SA` becomes plain `x`. */
-    let v = (b - 1) as i32;
-
-    let mut c = first;
-    let mut d = a - 1;
-    while c <= d {
-        let s = sa[c as usize] - depth as i32;
-        if 0 <= s && sa[(isa + s as isize) as usize] == v {
-            d += 1;
-            sa[d as usize] = s;
-            sa[(isa + s as isize) as usize] = d as i32;
-        }
-        c += 1;
-    }
-    let mut c = last - 1;
-    let e = d + 1;
-    let mut d = b;
-    while e < d {
-        let s = sa[c as usize] - depth as i32;
-        if 0 <= s && sa[(isa + s as isize) as usize] == v {
-            d -= 1;
-            sa[d as usize] = s;
-            sa[(isa + s as isize) as usize] = d as i32;
-        }
-        c -= 1;
-    }
-}
-
-fn tr_partialcopy(
-    sa: &mut [i32],
-    isa: isize,
-    first: isize,
-    a: isize,
-    b: isize,
-    last: isize,
-    depth: isize,
-) {
-    let v = (b - 1) as i32;
-    let mut newrank: i32 = -1;
-
-    let mut lastrank: i32 = -1;
-    let mut c = first;
-    let mut d = a - 1;
-    while c <= d {
-        let s = sa[c as usize] - depth as i32;
-        if 0 <= s && sa[(isa + s as isize) as usize] == v {
-            d += 1;
-            sa[d as usize] = s;
-            let rank = sa[(isa + s as isize + depth) as usize];
-            if lastrank != rank {
-                lastrank = rank;
-                newrank = d as i32;
-            }
-            sa[(isa + s as isize) as usize] = newrank;
-        }
-        c += 1;
-    }
-
-    let mut lastrank: i32 = -1;
-    let mut e = d;
-    while first <= e {
-        let rank = sa[(isa + sa[e as usize] as isize) as usize];
-        if lastrank != rank {
-            lastrank = rank;
-            newrank = e as i32;
-        }
-        if newrank != rank {
-            sa[(isa + sa[e as usize] as isize) as usize] = newrank;
-        }
-        e -= 1;
-    }
-
-    let mut lastrank: i32 = -1;
-    let mut c = last - 1;
-    let e = d + 1;
-    let mut d = b;
-    while e < d {
-        let s = sa[c as usize] - depth as i32;
-        if 0 <= s && sa[(isa + s as isize) as usize] == v {
-            d -= 1;
-            sa[d as usize] = s;
-            let rank = sa[(isa + s as isize + depth) as usize];
-            if lastrank != rank {
-                lastrank = rank;
-                newrank = d as i32;
-            }
-            sa[(isa + s as isize) as usize] = newrank;
-        }
-        c -= 1;
-    }
-}
-
-fn tr_introsort(
-    sa: &mut [i32],
-    isa: isize,
-    isad: isize,
-    first: isize,
-    last: isize,
-    budget: &mut TrBudget,
-) {
-    /* Stack frames are (ISAd, first, last, limit, trlink); the tandem-repeat
-     * copy frame stores its `(a, b)` pair in the pointer fields with a zero
-     * placeholder where C pushes a NULL ISAd. */
-    let mut stack = [(0isize, 0isize, 0isize, 0i32, 0i32); TR_STACKSIZE];
-    let mut ssize = 0usize;
-    let mut trlink: i32 = -1;
-    let mut isad = isad;
-    let mut first = first;
-    let mut last = last;
-    let incr = isad - isa;
-    let mut limit = tr_ilg(last - first);
-
-    loop {
-        if limit < 0 {
-            if limit == -1 {
-                /* tandem repeat partition */
-                let (a, b) = tr_partition(sa, isad - incr, first, first, last, (last - 1) as i32);
-
-                /* update ranks */
-                if a < last {
-                    let v = (a - 1) as i32;
-                    let mut c = first;
-                    while c < a {
-                        sa[(isa + sa[c as usize] as isize) as usize] = v;
-                        c += 1;
-                    }
-                }
-                if b < last {
-                    let v = (b - 1) as i32;
-                    let mut c = a;
-                    while c < b {
-                        sa[(isa + sa[c as usize] as isize) as usize] = v;
-                        c += 1;
-                    }
-                }
-
-                /* push */
-                if 1 < b - a {
-                    stack[ssize] = (0, a, b, 0, 0);
-                    ssize += 1;
-                    stack[ssize] = (isad - incr, first, last, -2, trlink);
-                    ssize += 1;
-                    trlink = ssize as i32 - 2;
-                }
-                if a - first <= last - b {
-                    if 1 < a - first {
-                        stack[ssize] = (isad, b, last, tr_ilg(last - b), trlink);
-                        ssize += 1;
-                        last = a;
-                        limit = tr_ilg(a - first);
-                    } else if 1 < last - b {
-                        first = b;
-                        limit = tr_ilg(last - b);
-                    } else {
-                        if ssize == 0 {
-                            return;
-                        }
-                        ssize -= 1;
-                        (isad, first, last, limit, trlink) = stack[ssize];
-                    }
-                } else if 1 < last - b {
-                    stack[ssize] = (isad, first, a, tr_ilg(a - first), trlink);
-                    ssize += 1;
-                    first = b;
-                    limit = tr_ilg(last - b);
-                } else if 1 < a - first {
-                    last = a;
-                    limit = tr_ilg(a - first);
-                } else {
-                    if ssize == 0 {
-                        return;
-                    }
-                    ssize -= 1;
-                    (isad, first, last, limit, trlink) = stack[ssize];
-                }
-            } else if limit == -2 {
-                /* tandem repeat copy */
-                ssize -= 1;
-                let a = stack[ssize].1;
-                let b = stack[ssize].2;
-                if stack[ssize].3 == 0 {
-                    tr_copy(sa, isa, first, a, b, last, isad - isa);
-                } else {
-                    if 0 <= trlink {
-                        stack[trlink as usize].3 = -1;
-                    }
-                    tr_partialcopy(sa, isa, first, a, b, last, isad - isa);
-                }
-                if ssize == 0 {
-                    return;
-                }
-                ssize -= 1;
-                (isad, first, last, limit, trlink) = stack[ssize];
-            } else {
-                /* sorted partition */
-                if 0 <= sa[first as usize] {
-                    let mut a = first;
-                    loop {
-                        sa[(isa + sa[a as usize] as isize) as usize] = a as i32;
-                        a += 1;
-                        if !(a < last && 0 <= sa[a as usize]) {
-                            break;
-                        }
-                    }
-                    first = a;
-                }
-                if first < last {
-                    let mut a = first;
-                    loop {
-                        sa[a as usize] = !sa[a as usize];
-                        a += 1;
-                        if !(sa[a as usize] < 0) {
-                            break;
-                        }
-                    }
-                    let next =
-                        if sa[(isa + sa[a as usize] as isize) as usize] != tr_key(sa, isad, a) {
-                            tr_ilg(a - first + 1)
-                        } else {
-                            -1
-                        };
-                    a += 1;
-                    if a < last {
-                        let v = (a - 1) as i32;
-                        let mut b = first;
-                        while b < a {
-                            sa[(isa + sa[b as usize] as isize) as usize] = v;
-                            b += 1;
-                        }
-                    }
-
-                    /* push */
-                    if budget.check(a - first) {
-                        if a - first <= last - a {
-                            stack[ssize] = (isad, a, last, -3, trlink);
-                            ssize += 1;
-                            isad += incr;
-                            last = a;
-                            limit = next;
-                        } else if 1 < last - a {
-                            stack[ssize] = (isad + incr, first, a, next, trlink);
-                            ssize += 1;
-                            first = a;
-                            limit = -3;
-                        } else {
-                            isad += incr;
-                            last = a;
-                            limit = next;
-                        }
-                    } else {
-                        if 0 <= trlink {
-                            stack[trlink as usize].3 = -1;
-                        }
-                        if 1 < last - a {
-                            first = a;
-                            limit = -3;
-                        } else {
-                            if ssize == 0 {
-                                return;
-                            }
-                            ssize -= 1;
-                            (isad, first, last, limit, trlink) = stack[ssize];
-                        }
-                    }
-                } else {
-                    if ssize == 0 {
-                        return;
-                    }
-                    ssize -= 1;
-                    (isad, first, last, limit, trlink) = stack[ssize];
-                }
-            }
-            continue;
-        }
-
-        if last - first <= TR_INSERTIONSORT_THRESHOLD {
-            tr_insertionsort(sa, isad, first, last);
-            limit = -3;
-            continue;
-        }
-
-        /* C decrements `limit` here (`limit-- == 0`); the decrement is
-         * observable only on the not-taken path because the taken path
-         * overwrites `limit` with -3. */
-        if limit == 0 {
-            tr_heapsort(sa, isad, first, last - first);
-            let mut a = last - 1;
-            while first < a {
-                let x = tr_key(sa, isad, a);
-                let mut b = a - 1;
-                while first <= b && tr_key(sa, isad, b) == x {
-                    sa[b as usize] = !sa[b as usize];
-                    b -= 1;
-                }
-                a = b;
-            }
-            limit = -3;
-            continue;
-        }
-        limit -= 1;
-
-        /* choose pivot */
-        let a = tr_pivot(sa, isad, first, last);
-        sa.swap(first as usize, a as usize);
-        let v = tr_key(sa, isad, first);
-
-        /* partition */
-        let (a, b) = tr_partition(sa, isad, first, first + 1, last, v);
-        if last - first != b - a {
-            let next = if sa[(isa + sa[a as usize] as isize) as usize] != v {
-                tr_ilg(b - a)
-            } else {
-                -1
-            };
-
-            /* update ranks */
-            {
-                let vv = (a - 1) as i32;
-                let mut c = first;
-                while c < a {
-                    sa[(isa + sa[c as usize] as isize) as usize] = vv;
-                    c += 1;
-                }
-            }
-            if b < last {
-                let vv = (b - 1) as i32;
-                let mut c = a;
-                while c < b {
-                    sa[(isa + sa[c as usize] as isize) as usize] = vv;
-                    c += 1;
-                }
-            }
-
-            /* push */
-            if 1 < b - a && budget.check(b - a) {
-                if a - first <= last - b {
-                    if last - b <= b - a {
-                        if 1 < a - first {
-                            stack[ssize] = (isad + incr, a, b, next, trlink);
-                            ssize += 1;
-                            stack[ssize] = (isad, b, last, limit, trlink);
-                            ssize += 1;
-                            last = a;
-                        } else if 1 < last - b {
-                            stack[ssize] = (isad + incr, a, b, next, trlink);
-                            ssize += 1;
-                            first = b;
-                        } else {
-                            isad += incr;
-                            first = a;
-                            last = b;
-                            limit = next;
-                        }
-                    } else if a - first <= b - a {
-                        if 1 < a - first {
-                            stack[ssize] = (isad, b, last, limit, trlink);
-                            ssize += 1;
-                            stack[ssize] = (isad + incr, a, b, next, trlink);
-                            ssize += 1;
-                            last = a;
-                        } else {
-                            stack[ssize] = (isad, b, last, limit, trlink);
-                            ssize += 1;
-                            isad += incr;
-                            first = a;
-                            last = b;
-                            limit = next;
-                        }
-                    } else {
-                        stack[ssize] = (isad, b, last, limit, trlink);
-                        ssize += 1;
-                        stack[ssize] = (isad, first, a, limit, trlink);
-                        ssize += 1;
-                        isad += incr;
-                        first = a;
-                        last = b;
-                        limit = next;
-                    }
-                } else if a - first <= b - a {
-                    if 1 < last - b {
-                        stack[ssize] = (isad + incr, a, b, next, trlink);
-                        ssize += 1;
-                        stack[ssize] = (isad, first, a, limit, trlink);
-                        ssize += 1;
-                        first = b;
-                    } else if 1 < a - first {
-                        stack[ssize] = (isad + incr, a, b, next, trlink);
-                        ssize += 1;
-                        last = a;
-                    } else {
-                        isad += incr;
-                        first = a;
-                        last = b;
-                        limit = next;
-                    }
-                } else if last - b <= b - a {
-                    if 1 < last - b {
-                        stack[ssize] = (isad, first, a, limit, trlink);
-                        ssize += 1;
-                        stack[ssize] = (isad + incr, a, b, next, trlink);
-                        ssize += 1;
-                        first = b;
-                    } else {
-                        stack[ssize] = (isad, first, a, limit, trlink);
-                        ssize += 1;
-                        isad += incr;
-                        first = a;
-                        last = b;
-                        limit = next;
-                    }
-                } else {
-                    stack[ssize] = (isad, first, a, limit, trlink);
-                    ssize += 1;
-                    stack[ssize] = (isad, b, last, limit, trlink);
-                    ssize += 1;
-                    isad += incr;
-                    first = a;
-                    last = b;
-                    limit = next;
-                }
-            } else {
-                if 1 < b - a && 0 <= trlink {
-                    stack[trlink as usize].3 = -1;
-                }
-                if a - first <= last - b {
-                    if 1 < a - first {
-                        stack[ssize] = (isad, b, last, limit, trlink);
-                        ssize += 1;
-                        last = a;
-                    } else if 1 < last - b {
-                        first = b;
-                    } else {
-                        if ssize == 0 {
-                            return;
-                        }
-                        ssize -= 1;
-                        (isad, first, last, limit, trlink) = stack[ssize];
-                    }
-                } else if 1 < last - b {
-                    stack[ssize] = (isad, first, a, limit, trlink);
-                    ssize += 1;
-                    first = b;
-                } else if 1 < a - first {
-                    last = a;
-                } else {
-                    if ssize == 0 {
-                        return;
-                    }
-                    ssize -= 1;
-                    (isad, first, last, limit, trlink) = stack[ssize];
-                }
-            }
-        } else if budget.check(last - first) {
-            limit = tr_ilg(last - first);
-            isad += incr;
-        } else {
-            if 0 <= trlink {
-                stack[trlink as usize].3 = -1;
-            }
-            if ssize == 0 {
-                return;
-            }
-            ssize -= 1;
-            (isad, first, last, limit, trlink) = stack[ssize];
-        }
-    }
-}
-
-/* --------------------------------------------------------------------- */
-
-/* Tandem repeat sort */
-fn trsort(sa: &mut [i32], isa: isize, n: isize, depth: isize) {
-    let mut budget = TrBudget::new(tr_ilg(n) * 2 / 3, n as i32);
-    /* trbudget_init(&budget, tr_ilg(n) * 3 / 4, n); */
-    let mut isad = isa + depth;
-    while -(n as i32) < sa[0] {
-        let mut first: isize = 0;
-        let mut skip: isize = 0;
-        let mut unsorted: i32 = 0;
-        loop {
-            let t0 = sa[first as usize];
-            if t0 < 0 {
-                first -= t0 as isize;
-                skip += t0 as isize;
-            } else {
-                if skip != 0 {
-                    sa[(first + skip) as usize] = skip as i32;
-                    skip = 0;
-                }
-                let last = sa[(isa + t0 as isize) as usize] as isize + 1;
-                if 1 < last - first {
-                    budget.count = 0;
-                    tr_introsort(sa, isa, isad, first, last, &mut budget);
-                    if budget.count != 0 {
-                        unsorted += budget.count;
-                    } else {
-                        skip = first - last;
-                    }
-                } else if last - first == 1 {
-                    skip = -1;
-                }
-                first = last;
-            }
-            if !(first < n) {
-                break;
-            }
-        }
-        if skip != 0 {
-            sa[(first + skip) as usize] = skip as i32;
-        }
-        if unsorted == 0 {
-            break;
-        }
-        isad += isad - isa;
-    }
-}
-
-/* --------------------------------------------------------------------- */
-
-/// `BUCKET_B(c0, c1)` for the 256-symbol alphabet.
-#[inline(always)]
-fn bb(c0: i32, c1: i32) -> usize {
-    (((c1 as u32) << 8) | c0 as u32) as usize
-}
-
-/// `BUCKET_BSTAR(c0, c1)` for the 256-symbol alphabet.
-#[inline(always)]
-fn bstar(c0: i32, c1: i32) -> usize {
-    (((c0 as u32) << 8) | c1 as u32) as usize
-}
-
-/* Sorts suffixes of type B*. */
-fn sort_type_bstar(
-    t: &[u8],
-    sa: &mut [i32],
-    bucket_a: &mut [i32],
-    bucket_b: &mut [i32],
-    n: isize,
-) -> isize {
-    /* Initialize bucket arrays. */
-    for slot in bucket_a.iter_mut() {
-        *slot = 0;
-    }
-    for slot in bucket_b.iter_mut() {
-        *slot = 0;
-    }
-
-    /* Count the number of occurrences of the first one or two characters of
-    each type A, B and B* suffix. Moreover, store the beginning position of
-    all type B* suffixes into the array SA. */
-    let mut i = n - 1;
-    let mut m = n;
-    let mut c0 = t[(n - 1) as usize] as i32;
-    let mut c1;
-    while 0 <= i {
-        /* type A suffix. */
-        loop {
-            c1 = c0;
-            bucket_a[c1 as usize] += 1;
-            i -= 1;
-            if 0 <= i {
-                c0 = t[i as usize] as i32;
-                if c0 >= c1 {
-                    continue;
-                }
-            }
-            break;
-        }
-        if 0 <= i {
-            /* type B* suffix. */
-            bucket_b[bstar(c0, c1)] += 1;
-            m -= 1;
-            sa[m as usize] = i as i32;
-            /* type B suffix. */
-            i -= 1;
-            c1 = c0;
-            while 0 <= i {
-                c0 = t[i as usize] as i32;
-                if !(c0 <= c1) {
-                    break;
-                }
-                bucket_b[bb(c0, c1)] += 1;
-                i -= 1;
-                c1 = c0;
-            }
-        }
-    }
-    let m = n - m;
-    /*
-    note:
-      A type B* suffix is lexicographically smaller than a type B suffix that
-      begins with the same first two characters.
-    */
-
-    /* Calculate the index of start/end point of each bucket. */
-    {
-        let mut i: i32 = 0;
-        let mut j: i32 = 0;
-        for c0 in 0..ALPHABET_SIZE {
-            let t0 = i + bucket_a[c0 as usize];
-            bucket_a[c0 as usize] = i + j; /* start point */
-            i = t0 + bucket_b[bb(c0, c0)];
-            for c1 in (c0 + 1)..ALPHABET_SIZE {
-                j += bucket_b[bstar(c0, c1)];
-                bucket_b[bstar(c0, c1)] = j; /* end point */
-                i += bucket_b[bb(c0, c1)];
-            }
-        }
-    }
-
-    if 0 < m {
-        /* Sort the type B* suffixes by their first two characters. */
-        let pab = n - m;
-        let isab = m;
-        let mut i = m - 2;
-        while 0 <= i {
-            let t0 = sa[(pab + i) as usize];
-            let c0 = t[t0 as usize] as i32;
-            let c1 = t[(t0 + 1) as usize] as i32;
-            bucket_b[bstar(c0, c1)] -= 1;
-            sa[bucket_b[bstar(c0, c1)] as usize] = i as i32;
-            i -= 1;
-        }
-        {
-            let t0 = sa[(pab + m - 1) as usize];
-            let c0 = t[t0 as usize] as i32;
-            let c1 = t[(t0 + 1) as usize] as i32;
-            bucket_b[bstar(c0, c1)] -= 1;
-            sa[bucket_b[bstar(c0, c1)] as usize] = (m - 1) as i32;
-        }
-
-        /* Sort the type B* substrings using sssort. */
-        let buf = m;
-        let bufsize = n - 2 * m;
-        let mut c0 = ALPHABET_SIZE - 2;
-        let mut j = m;
-        while 0 < j {
-            let mut c1 = ALPHABET_SIZE - 1;
-            while c0 < c1 {
-                let i = bucket_b[bstar(c0, c1)] as isize;
-                if 1 < j - i {
-                    sssort(
-                        t,
-                        sa,
-                        pab,
-                        i,
-                        j,
-                        buf,
-                        bufsize,
-                        2,
-                        n,
-                        sa[i as usize] == (m - 1) as i32,
-                    );
-                }
-                j = i;
-                c1 -= 1;
-            }
-            c0 -= 1;
-        }
-
-        /* Compute ranks of type B* substrings. */
-        let mut i = m - 1;
-        while 0 <= i {
-            if 0 <= sa[i as usize] {
-                let j = i;
-                loop {
-                    sa[(isab + sa[i as usize] as isize) as usize] = i as i32;
-                    i -= 1;
-                    if !(0 <= i && 0 <= sa[i as usize]) {
-                        break;
-                    }
-                }
-                sa[(i + 1) as usize] = (i - j) as i32;
-                if i <= 0 {
-                    break;
-                }
-            }
-            let j = i;
-            loop {
-                sa[i as usize] = !sa[i as usize];
-                sa[(isab + sa[i as usize] as isize) as usize] = j as i32;
-                i -= 1;
-                if !(sa[i as usize] < 0) {
-                    break;
-                }
-            }
-            sa[(isab + sa[i as usize] as isize) as usize] = j as i32;
-            i -= 1;
-        }
-
-        /* Construct the inverse suffix array of type B* suffixes using
-        trsort. */
-        trsort(sa, isab, m, 1);
-
-        /* Set the sorted order of type B* suffixes. */
-        let mut i = n - 1;
-        let mut j = m;
-        let mut c0 = t[(n - 1) as usize] as i32;
-        while 0 <= i {
-            i -= 1;
-            let mut c1 = c0;
-            while 0 <= i {
-                c0 = t[i as usize] as i32;
-                if !(c0 >= c1) {
-                    break;
-                }
-                i -= 1;
-                c1 = c0;
-            }
-            if 0 <= i {
-                let t0 = i;
-                i -= 1;
-                c1 = c0;
-                while 0 <= i {
-                    c0 = t[i as usize] as i32;
-                    if !(c0 <= c1) {
-                        break;
-                    }
-                    i -= 1;
-                    c1 = c0;
-                }
-                j -= 1;
-                sa[sa[(isab + j) as usize] as usize] = if t0 == 0 || 1 < t0 - i {
-                    t0 as i32
-                } else {
-                    !(t0 as i32)
-                };
-            }
-        }
-
-        /* Calculate the index of start/end point of each bucket. */
-        bucket_b[bb(ALPHABET_SIZE - 1, ALPHABET_SIZE - 1)] = n as i32; /* end point */
-        let mut k = m - 1;
-        let mut c0 = ALPHABET_SIZE - 2;
-        while 0 <= c0 {
-            let mut i = bucket_a[(c0 + 1) as usize] as isize - 1;
-            let mut c1 = ALPHABET_SIZE - 1;
-            while c0 < c1 {
-                let t0 = i - bucket_b[bb(c0, c1)] as isize;
-                bucket_b[bb(c0, c1)] = i as i32; /* end point */
-
-                /* Move all type B* suffixes to the correct position. */
-                i = t0;
-                let j = bucket_b[bstar(c0, c1)] as isize;
-                while j <= k {
-                    sa[i as usize] = sa[k as usize];
-                    i -= 1;
-                    k -= 1;
-                }
-                c1 -= 1;
-            }
-            bucket_b[bstar(c0, c0 + 1)] = (i - bucket_b[bb(c0, c0)] as isize + 1) as i32; /* start point */
-            bucket_b[bb(c0, c0)] = i as i32; /* end point */
-            c0 -= 1;
-        }
-    }
-
-    m
-}
-
-/* Constructs the suffix array by using the sorted order of type B*
- * suffixes. */
-fn construct_sa(
-    t: &[u8],
-    sa: &mut [i32],
-    bucket_a: &mut [i32],
-    bucket_b: &mut [i32],
-    n: isize,
-    m: isize,
-) {
-    if 0 < m {
-        /* Construct the sorted order of type B suffixes by using
-        the sorted order of type B* suffixes. */
-        let mut c1 = ALPHABET_SIZE - 2;
-        while 0 <= c1 {
-            /* Scan the suffix array from right to left. */
-            let i = bucket_b[bstar(c1, c1 + 1)] as isize;
-            let mut j = bucket_a[(c1 + 1) as usize] as isize - 1;
-            let mut k: isize = 0;
-            let mut c2: i32 = -1;
-            while i <= j {
-                let mut s = sa[j as usize];
-                if 0 < s {
-                    debug_assert_eq!(t[s as usize] as i32, c1);
-                    debug_assert!((s as isize + 1) < n && t[s as usize] <= t[(s + 1) as usize]);
-                    debug_assert!(t[(s - 1) as usize] <= t[s as usize]);
-                    sa[j as usize] = !s;
-                    s -= 1;
-                    let c0 = t[s as usize] as i32;
-                    if 0 < s && (t[(s - 1) as usize] as i32) > c0 {
-                        s = !s;
-                    }
-                    if c0 != c2 {
-                        if 0 <= c2 {
-                            bucket_b[bb(c2, c1)] = k as i32;
-                        }
-                        c2 = c0;
-                        k = bucket_b[bb(c2, c1)] as isize;
-                    }
-                    debug_assert!(k < j);
-                    sa[k as usize] = s;
-                    k -= 1;
-                } else {
-                    debug_assert!((s == 0 && t[s as usize] as i32 == c1) || s < 0);
-                    sa[j as usize] = !s;
-                }
-                j -= 1;
-            }
-            c1 -= 1;
-        }
-    }
-
-    /* Construct the suffix array by using the sorted order of type B
-    suffixes. */
-    let mut c2 = t[(n - 1) as usize] as i32;
-    let mut k = bucket_a[c2 as usize] as isize;
-    sa[k as usize] = if (t[(n - 2) as usize] as i32) < c2 {
-        !((n - 1) as i32)
-    } else {
-        (n - 1) as i32
-    };
-    k += 1;
-    /* Scan the suffix array from left to right. */
-    let mut i: isize = 0;
-    let j = n;
-    while i < j {
-        let mut s = sa[i as usize];
-        if 0 < s {
-            debug_assert!(t[(s - 1) as usize] >= t[s as usize]);
-            s -= 1;
-            let c0 = t[s as usize] as i32;
-            if s == 0 || (t[(s - 1) as usize] as i32) < c0 {
-                s = !s;
-            }
-            if c0 != c2 {
-                bucket_a[c2 as usize] = k as i32;
-                c2 = c0;
-                k = bucket_a[c2 as usize] as isize;
-            }
-            debug_assert!(i < k);
-            sa[k as usize] = s;
-            k += 1;
-        } else {
-            debug_assert!(s < 0);
-            sa[i as usize] = !s;
-        }
-        i += 1;
-    }
-}
-
-/* --------------------------------------------------------------------- */
-
-/// Rust implementation of the `divsufsort()` entry point used by
-/// `ZDICT_trainFromBuffer_legacy()`.
-///
-/// Integration removes the C function body, so this direct export provides
-/// the existing library symbol without a wrapper.  The `open_mp` parameter is
-/// accepted for signature compatibility only: zstd never defines
-/// `LIBBSC_OPENMP`, so the C implementation ignored it as well.
-///
-/// Returns 0 on success, -1 for invalid arguments, and -2 when the bucket
-/// work arrays cannot be allocated, exactly like the C routine.
-#[no_mangle]
-pub unsafe extern "C" fn divsufsort(
-    t: *const u8,
-    sa: *mut c_int,
-    n: c_int,
-    open_mp: c_int,
-) -> c_int {
-    let _ = open_mp;
-
-    /* Check arguments. */
-    if t.is_null() || sa.is_null() || n < 0 {
-        return -1;
-    }
-    if n == 0 {
-        return 0;
-    }
-
-    let text = unsafe { slice::from_raw_parts(t, n as usize) };
-    let suffix = unsafe { slice::from_raw_parts_mut(sa, n as usize) };
-    if n == 1 {
-        suffix[0] = 0;
-        return 0;
-    }
-    if n == 2 {
-        let m = usize::from(text[0] < text[1]);
-        suffix[m ^ 1] = 0;
-        suffix[m] = 1;
-        return 0;
-    }
-
-    let mut bucket_a: Vec<i32> = Vec::new();
-    let mut bucket_b: Vec<i32> = Vec::new();
-    if bucket_a.try_reserve_exact(BUCKET_A_SIZE).is_err()
-        || bucket_b.try_reserve_exact(BUCKET_B_SIZE).is_err()
-    {
-        /* Match the C implementation's -2 result when malloc fails. */
-        return -2;
-    }
-    bucket_a.resize(BUCKET_A_SIZE, 0);
-    bucket_b.resize(BUCKET_B_SIZE, 0);
-
-    /* Suffixsort. */
-    let m = sort_type_bstar(text, suffix, &mut bucket_a, &mut bucket_b, n as isize);
-    construct_sa(text, suffix, &mut bucket_a, &mut bucket_b, n as isize, m);
-    0
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::ptr;
-
-    fn build_sa(text: &[u8]) -> Vec<i32> {
-        let mut sa = vec![0i32; text.len()];
-        let result = unsafe { divsufsort(text.as_ptr(), sa.as_mut_ptr(), text.len() as c_int, 0) };
-        assert_eq!(result, 0);
-        sa
-    }
-
-    /// Trivial O(n^2 log n) reference: sort the suffix start positions by the
-    /// suffixes themselves.
-    fn reference_sa(text: &[u8]) -> Vec<i32> {
-        let mut sa: Vec<i32> = (0..text.len() as i32).collect();
-        sa.sort_by(|&a, &b| text[a as usize..].cmp(&text[b as usize..]));
-        sa
-    }
-
-    /// Suffix-array invariants: a permutation of `0..n` whose suffixes are in
-    /// strictly increasing lexicographic order.
-    fn assert_valid_sa(text: &[u8], sa: &[i32]) {
-        assert_eq!(sa.len(), text.len());
-        let mut seen = vec![false; text.len()];
-        for &p in sa {
-            let p = usize::try_from(p).expect("suffix index must be non-negative");
-            assert!(p < text.len(), "suffix index {p} out of range");
-            assert!(!seen[p], "duplicate suffix index {p}");
-            seen[p] = true;
-        }
-        for pair in sa.windows(2) {
-            assert!(
-                text[pair[0] as usize..] < text[pair[1] as usize..],
-                "suffixes {} and {} are not in sorted order",
-                pair[0],
-                pair[1]
-            );
-        }
-    }
-
-    /// Fixed-seed numerical-recipes LCG, used to generate reproducible
-    /// pseudo-random sample buffers.
-    fn lcg_bytes(len: usize, seed: u32, alphabet: u32) -> Vec<u8> {
-        let mut state = seed;
-        (0..len)
-            .map(|_| {
-                state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
-                ((state >> 24) % alphabet) as u8
-            })
-            .collect()
-    }
-
-    #[test]
-    fn rejects_invalid_arguments() {
-        let text = [0u8; 1];
-        let mut sa = [0i32; 1];
-        assert_eq!(
-            unsafe { divsufsort(ptr::null(), sa.as_mut_ptr(), 1, 0) },
-            -1
-        );
-        assert_eq!(
-            unsafe { divsufsort(text.as_ptr(), ptr::null_mut(), 1, 0) },
-            -1
-        );
-        assert_eq!(
-            unsafe { divsufsort(text.as_ptr(), sa.as_mut_ptr(), -1, 0) },
-            -1
-        );
-    }
-
-    #[test]
-    fn sorts_trivial_inputs() {
-        /* empty */
-        let text = [0u8; 1];
-        let mut sa = [i32::MIN; 1];
-        assert_eq!(
-            unsafe { divsufsort(text.as_ptr(), sa.as_mut_ptr(), 0, 0) },
-            0
-        );
-        assert_eq!(sa[0], i32::MIN, "n == 0 must not touch the output");
-
-        /* single byte */
-        assert_eq!(build_sa(b"z"), [0]);
-
-        /* two bytes: ascending, descending, and equal */
-        assert_eq!(build_sa(b"ab"), [0, 1]);
-        assert_eq!(build_sa(b"ba"), [1, 0]);
-        assert_eq!(build_sa(b"aa"), [1, 0]);
-    }
-
-    #[test]
-    fn sorts_all_equal_bytes() {
-        let text = vec![b'q'; 10_000];
-        let sa = build_sa(&text);
-        /* For a constant text the shortest suffix sorts first. */
-        let expected: Vec<i32> = (0..text.len() as i32).rev().collect();
-        assert_eq!(sa, expected);
-    }
-
-    #[test]
-    fn sorts_abracadabra_exactly() {
-        /* Hand-computed: a(10) abra(7) abracadabra(0) acadabra(3) adabra(5)
-         * bra(8) bracadabra(1) cadabra(4) dabra(6) ra(9) racadabra(2). */
-        assert_eq!(build_sa(b"abracadabra"), [10, 7, 0, 3, 5, 8, 1, 4, 6, 9, 2]);
-    }
-
-    #[test]
-    fn matches_reference_on_periodic_text() {
-        /* Tandem repeats exercise trsort's repeat partitioning. */
-        let text: Vec<u8> = b"ab".iter().copied().cycle().take(4096).collect();
-        let sa = build_sa(&text);
-        assert_valid_sa(&text, &sa);
-        assert_eq!(sa, reference_sa(&text));
-    }
-
-    #[test]
-    fn matches_reference_on_random_bytes() {
-        let text = lcg_bytes(8192, 0x0BAD_5EED, 256);
-        let sa = build_sa(&text);
-        assert_valid_sa(&text, &sa);
-        assert_eq!(sa, reference_sa(&text));
-    }
-
-    #[test]
-    fn matches_reference_on_low_alphabet_text() {
-        /* A four-symbol alphabet produces the large first-two-character
-         * buckets that reach sssort's block merging and the deeper trsort
-         * paths. */
-        let text = lcg_bytes(16_384, 0xDEAD_BEEF, 4);
-        let sa = build_sa(&text);
-        assert_valid_sa(&text, &sa);
-        assert_eq!(sa, reference_sa(&text));
-    }
-}

rust/src/lib.rs

@@ -5,8 +5,6 @@ pub mod bitstream;
 pub mod common;
 pub mod cpu;
 pub mod debug;
-#[cfg(feature = "dict-builder")]
-pub mod divsufsort;
 pub mod entropy_common;
 pub mod errors;
 #[cfg(feature = "compression")]
@@ -30,8 +28,12 @@ pub mod zstd_compress_frame;
 #[cfg(feature = "compression")]
 pub mod zstd_compress_literals;
 #[cfg(feature = "compression")]
+pub mod zstd_compress_params;
+#[cfg(feature = "compression")]
 pub mod zstd_compress_sequences;
 #[cfg(feature = "compression")]
+pub mod zstd_compress_stats;
+#[cfg(feature = "compression")]
 pub mod zstd_compress_superblock;
 #[cfg(feature = "decompression")]
 pub mod zstd_ddict;

rust/src/zstd_compress_literals.rs

@@ -65,7 +65,7 @@ unsafe fn copy_bytes(dst: *mut u8, src: *const u8, size: usize) {
 }
 
 #[inline]
-unsafe fn copy_huf_tables(dst: *mut ZSTD_hufCTables_t, src: *const ZSTD_hufCTables_t) {
+pub(crate) unsafe fn copy_huf_tables(dst: *mut ZSTD_hufCTables_t, src: *const ZSTD_hufCTables_t) {
     // Copy as bytes, not as a Rust struct: C's memcpy preserves the four tail
     // padding bytes that this layout has on 64-bit targets.  Some C callers
     // copy or compare the complete entropy state, so leaving those bytes from
@@ -192,8 +192,10 @@ fn min_literals_to_compress(strategy: c_int, huf_repeat: c_int) -> usize {
     }
 }
 
+/// C's `ZSTD_minGain()`: minimum compression gain required to emit a
+/// compressed block or compressed literals section.
 #[inline]
-fn min_gain(src_size: usize, strategy: c_int) -> usize {
+pub(crate) fn min_gain(src_size: usize, strategy: c_int) -> usize {
     let min_log = if strategy >= ZSTD_BTULTRA {
         strategy.saturating_sub(1) as u32
     } else {

rust/src/zstd_compress_params.rs

@@ -0,0 +1,1048 @@
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(clippy::missing_safety_doc)]
+#![allow(clippy::too_many_arguments)]
+
+//! Context-free compression-parameter selection and sizing leaves.
+//!
+//! This module deliberately does **not** own the public `ZSTD_*` symbols yet.
+//! `zstd_compress.c` still owns configuration-sensitive policy: excluded block
+//! compressors, private `ZSTD_CCtx_params` layouts, LDM workspace sizing, and
+//! ASAN workspace policy.  The C integration layer can select a raw table
+//! entry here, apply its configured strategy cascade, then use the adjustment
+//! and sizing leaves below.  That keeps the Rust implementation independent of
+//! C preprocessor state while retaining byte-for-byte C policy for reduced
+//! builds.
+
+use crate::errors::{ZstdErrorCode, ERROR};
+use std::mem::size_of;
+use std::os::raw::c_int;
+
+pub const ZSTD_CONTENTSIZE_UNKNOWN: u64 = u64::MAX;
+
+const ZSTD_CLEVEL_DEFAULT: c_int = 3;
+const ZSTD_MAX_CLEVEL: c_int = 22;
+const ZSTD_TARGETLENGTH_MAX: c_int = 1 << 17;
+const ZSTD_BLOCKSIZE_MAX: usize = 1 << 17;
+
+const ZSTD_WINDOWLOG_MIN: c_int = 10;
+#[cfg(target_pointer_width = "32")]
+const ZSTD_WINDOWLOG_MAX: c_int = 30;
+#[cfg(not(target_pointer_width = "32"))]
+const ZSTD_WINDOWLOG_MAX: c_int = 31;
+const ZSTD_HASHLOG_MIN: c_int = 6;
+const ZSTD_HASHLOG_MAX: c_int = 30;
+const ZSTD_CHAINLOG_MIN: c_int = ZSTD_HASHLOG_MIN;
+#[cfg(target_pointer_width = "32")]
+const ZSTD_CHAINLOG_MAX: c_int = 29;
+#[cfg(not(target_pointer_width = "32"))]
+const ZSTD_CHAINLOG_MAX: c_int = 30;
+const ZSTD_SEARCHLOG_MIN: c_int = 1;
+const ZSTD_SEARCHLOG_MAX: c_int = ZSTD_WINDOWLOG_MAX - 1;
+const ZSTD_MINMATCH_MIN: c_int = 3;
+const ZSTD_MINMATCH_MAX: c_int = 7;
+const ZSTD_TARGETLENGTH_MIN: c_int = 0;
+
+const ZSTD_FAST: c_int = 1;
+const ZSTD_DFAST: c_int = 2;
+const ZSTD_GREEDY: c_int = 3;
+const ZSTD_LAZY: c_int = 4;
+const ZSTD_LAZY2: c_int = 5;
+const ZSTD_BTLAZY2: c_int = 6;
+const ZSTD_BTOPT: c_int = 7;
+const ZSTD_BTULTRA: c_int = 8;
+const ZSTD_BTULTRA2: c_int = 9;
+
+const ZSTD_C_COMPRESSION_LEVEL: c_int = 100;
+const ZSTD_C_WINDOW_LOG: c_int = 101;
+const ZSTD_C_HASH_LOG: c_int = 102;
+const ZSTD_C_CHAIN_LOG: c_int = 103;
+const ZSTD_C_SEARCH_LOG: c_int = 104;
+const ZSTD_C_MIN_MATCH: c_int = 105;
+const ZSTD_C_TARGET_LENGTH: c_int = 106;
+const ZSTD_C_STRATEGY: c_int = 107;
+
+/// Private compression-parameter modes from `zstd_compress_internal.h`.
+///
+/// They are ABI-compatible with `ZSTD_CParamMode_e` and intentionally kept as
+/// integer constants because that enum remains private C API for now.
+pub const ZSTD_RUST_CPM_NO_ATTACH_DICT: c_int = 0;
+pub const ZSTD_RUST_CPM_ATTACH_DICT: c_int = 1;
+pub const ZSTD_RUST_CPM_CREATE_CDICT: c_int = 2;
+pub const ZSTD_RUST_CPM_UNKNOWN: c_int = 3;
+
+/// `ZSTD_ParamSwitch_e` values used by the adjustment and sizing leaves.
+pub const ZSTD_RUST_PS_AUTO: c_int = 0;
+pub const ZSTD_RUST_PS_ENABLE: c_int = 1;
+pub const ZSTD_RUST_PS_DISABLE: c_int = 2;
+
+/// ABI-compatible `ZSTD_compressionParameters` from `zstd.h`.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ZSTD_compressionParameters {
+    pub windowLog: u32,
+    pub chainLog: u32,
+    pub hashLog: u32,
+    pub searchLog: u32,
+    pub minMatch: u32,
+    pub targetLength: u32,
+    pub strategy: c_int,
+}
+
+/// ABI-compatible `ZSTD_frameParameters` from `zstd.h`.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ZSTD_frameParameters {
+    pub contentSizeFlag: c_int,
+    pub checksumFlag: c_int,
+    pub noDictIDFlag: c_int,
+}
+
+/// ABI-compatible `ZSTD_parameters` from `zstd.h`.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ZSTD_parameters {
+    pub cParams: ZSTD_compressionParameters,
+    pub fParams: ZSTD_frameParameters,
+}
+
+/// ABI-compatible `ZSTD_bounds` from `zstd.h`.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ZSTD_bounds {
+    pub error: usize,
+    pub lowerBound: c_int,
+    pub upperBound: c_int,
+}
+
+/* `clevels.h`, represented as raw fields so the table stays compact and easy
+ * to compare mechanically against its C source.  Field order is W, C, H, S,
+ * L, TL, strategy. */
+const DEFAULT_CPARAMS: [[[u32; 7]; 23]; 4] = [
+    [
+        [19, 12, 13, 1, 6, 1, ZSTD_FAST as u32],
+        [19, 13, 14, 1, 7, 0, ZSTD_FAST as u32],
+        [20, 15, 16, 1, 6, 0, ZSTD_FAST as u32],
+        [21, 16, 17, 1, 5, 0, ZSTD_DFAST as u32],
+        [21, 18, 18, 1, 5, 0, ZSTD_DFAST as u32],
+        [21, 18, 19, 3, 5, 2, ZSTD_GREEDY as u32],
+        [21, 18, 19, 3, 5, 4, ZSTD_LAZY as u32],
+        [21, 19, 20, 4, 5, 8, ZSTD_LAZY as u32],
+        [21, 19, 20, 4, 5, 16, ZSTD_LAZY2 as u32],
+        [22, 20, 21, 4, 5, 16, ZSTD_LAZY2 as u32],
+        [22, 21, 22, 5, 5, 16, ZSTD_LAZY2 as u32],
+        [22, 21, 22, 6, 5, 16, ZSTD_LAZY2 as u32],
+        [22, 22, 23, 6, 5, 32, ZSTD_LAZY2 as u32],
+        [22, 22, 22, 4, 5, 32, ZSTD_BTLAZY2 as u32],
+        [22, 22, 23, 5, 5, 32, ZSTD_BTLAZY2 as u32],
+        [22, 23, 23, 6, 5, 32, ZSTD_BTLAZY2 as u32],
+        [22, 22, 22, 5, 5, 48, ZSTD_BTOPT as u32],
+        [23, 23, 22, 5, 4, 64, ZSTD_BTOPT as u32],
+        [23, 23, 22, 6, 3, 64, ZSTD_BTULTRA as u32],
+        [23, 24, 22, 7, 3, 256, ZSTD_BTULTRA2 as u32],
+        [25, 25, 23, 7, 3, 256, ZSTD_BTULTRA2 as u32],
+        [26, 26, 24, 7, 3, 512, ZSTD_BTULTRA2 as u32],
+        [27, 27, 25, 9, 3, 999, ZSTD_BTULTRA2 as u32],
+    ],
+    [
+        [18, 12, 13, 1, 5, 1, ZSTD_FAST as u32],
+        [18, 13, 14, 1, 6, 0, ZSTD_FAST as u32],
+        [18, 14, 14, 1, 5, 0, ZSTD_DFAST as u32],
+        [18, 16, 16, 1, 4, 0, ZSTD_DFAST as u32],
+        [18, 16, 17, 3, 5, 2, ZSTD_GREEDY as u32],
+        [18, 17, 18, 5, 5, 2, ZSTD_GREEDY as u32],
+        [18, 18, 19, 3, 5, 4, ZSTD_LAZY as u32],
+        [18, 18, 19, 4, 4, 4, ZSTD_LAZY as u32],
+        [18, 18, 19, 4, 4, 8, ZSTD_LAZY2 as u32],
+        [18, 18, 19, 5, 4, 8, ZSTD_LAZY2 as u32],
+        [18, 18, 19, 6, 4, 8, ZSTD_LAZY2 as u32],
+        [18, 18, 19, 5, 4, 12, ZSTD_BTLAZY2 as u32],
+        [18, 19, 19, 7, 4, 12, ZSTD_BTLAZY2 as u32],
+        [18, 18, 19, 4, 4, 16, ZSTD_BTOPT as u32],
+        [18, 18, 19, 4, 3, 32, ZSTD_BTOPT as u32],
+        [18, 18, 19, 6, 3, 128, ZSTD_BTOPT as u32],
+        [18, 19, 19, 6, 3, 128, ZSTD_BTULTRA as u32],
+        [18, 19, 19, 8, 3, 256, ZSTD_BTULTRA as u32],
+        [18, 19, 19, 6, 3, 128, ZSTD_BTULTRA2 as u32],
+        [18, 19, 19, 8, 3, 256, ZSTD_BTULTRA2 as u32],
+        [18, 19, 19, 10, 3, 512, ZSTD_BTULTRA2 as u32],
+        [18, 19, 19, 12, 3, 512, ZSTD_BTULTRA2 as u32],
+        [18, 19, 19, 13, 3, 999, ZSTD_BTULTRA2 as u32],
+    ],
+    [
+        [17, 12, 12, 1, 5, 1, ZSTD_FAST as u32],
+        [17, 12, 13, 1, 6, 0, ZSTD_FAST as u32],
+        [17, 13, 15, 1, 5, 0, ZSTD_FAST as u32],
+        [17, 15, 16, 2, 5, 0, ZSTD_DFAST as u32],
+        [17, 17, 17, 2, 4, 0, ZSTD_DFAST as u32],
+        [17, 16, 17, 3, 4, 2, ZSTD_GREEDY as u32],
+        [17, 16, 17, 3, 4, 4, ZSTD_LAZY as u32],
+        [17, 16, 17, 3, 4, 8, ZSTD_LAZY2 as u32],
+        [17, 16, 17, 4, 4, 8, ZSTD_LAZY2 as u32],
+        [17, 16, 17, 5, 4, 8, ZSTD_LAZY2 as u32],
+        [17, 16, 17, 6, 4, 8, ZSTD_LAZY2 as u32],
+        [17, 17, 17, 5, 4, 8, ZSTD_BTLAZY2 as u32],
+        [17, 18, 17, 7, 4, 12, ZSTD_BTLAZY2 as u32],
+        [17, 18, 17, 3, 4, 12, ZSTD_BTOPT as u32],
+        [17, 18, 17, 4, 3, 32, ZSTD_BTOPT as u32],
+        [17, 18, 17, 6, 3, 256, ZSTD_BTOPT as u32],
+        [17, 18, 17, 6, 3, 128, ZSTD_BTULTRA as u32],
+        [17, 18, 17, 8, 3, 256, ZSTD_BTULTRA as u32],
+        [17, 18, 17, 10, 3, 512, ZSTD_BTULTRA as u32],
+        [17, 18, 17, 5, 3, 256, ZSTD_BTULTRA2 as u32],
+        [17, 18, 17, 7, 3, 512, ZSTD_BTULTRA2 as u32],
+        [17, 18, 17, 9, 3, 512, ZSTD_BTULTRA2 as u32],
+        [17, 18, 17, 11, 3, 999, ZSTD_BTULTRA2 as u32],
+    ],
+    [
+        [14, 12, 13, 1, 5, 1, ZSTD_FAST as u32],
+        [14, 14, 15, 1, 5, 0, ZSTD_FAST as u32],
+        [14, 14, 15, 1, 4, 0, ZSTD_FAST as u32],
+        [14, 14, 15, 2, 4, 0, ZSTD_DFAST as u32],
+        [14, 14, 14, 4, 4, 2, ZSTD_GREEDY as u32],
+        [14, 14, 14, 3, 4, 4, ZSTD_LAZY as u32],
+        [14, 14, 14, 4, 4, 8, ZSTD_LAZY2 as u32],
+        [14, 14, 14, 6, 4, 8, ZSTD_LAZY2 as u32],
+        [14, 14, 14, 8, 4, 8, ZSTD_LAZY2 as u32],
+        [14, 15, 14, 5, 4, 8, ZSTD_BTLAZY2 as u32],
+        [14, 15, 14, 9, 4, 8, ZSTD_BTLAZY2 as u32],
+        [14, 15, 14, 3, 4, 12, ZSTD_BTOPT as u32],
+        [14, 15, 14, 4, 3, 24, ZSTD_BTOPT as u32],
+        [14, 15, 14, 5, 3, 32, ZSTD_BTULTRA as u32],
+        [14, 15, 15, 6, 3, 64, ZSTD_BTULTRA as u32],
+        [14, 15, 15, 7, 3, 256, ZSTD_BTULTRA as u32],
+        [14, 15, 15, 5, 3, 48, ZSTD_BTULTRA2 as u32],
+        [14, 15, 15, 6, 3, 128, ZSTD_BTULTRA2 as u32],
+        [14, 15, 15, 7, 3, 256, ZSTD_BTULTRA2 as u32],
+        [14, 15, 15, 8, 3, 256, ZSTD_BTULTRA2 as u32],
+        [14, 15, 15, 8, 3, 512, ZSTD_BTULTRA2 as u32],
+        [14, 15, 15, 9, 3, 512, ZSTD_BTULTRA2 as u32],
+        [14, 15, 15, 10, 3, 999, ZSTD_BTULTRA2 as u32],
+    ],
+];
+
+#[inline]
+fn cparams_from_row(row: [u32; 7]) -> ZSTD_compressionParameters {
+    ZSTD_compressionParameters {
+        windowLog: row[0],
+        chainLog: row[1],
+        hashLog: row[2],
+        searchLog: row[3],
+        minMatch: row[4],
+        targetLength: row[5],
+        strategy: row[6] as c_int,
+    }
+}
+
+#[inline]
+fn bounds(param: c_int) -> ZSTD_bounds {
+    let (lowerBound, upperBound) = match param {
+        ZSTD_C_COMPRESSION_LEVEL => (ZSTD_rust_params_minCLevel(), ZSTD_rust_params_maxCLevel()),
+        ZSTD_C_WINDOW_LOG => (ZSTD_WINDOWLOG_MIN, ZSTD_WINDOWLOG_MAX),
+        ZSTD_C_HASH_LOG => (ZSTD_HASHLOG_MIN, ZSTD_HASHLOG_MAX),
+        ZSTD_C_CHAIN_LOG => (ZSTD_CHAINLOG_MIN, ZSTD_CHAINLOG_MAX),
+        ZSTD_C_SEARCH_LOG => (ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX),
+        ZSTD_C_MIN_MATCH => (ZSTD_MINMATCH_MIN, ZSTD_MINMATCH_MAX),
+        ZSTD_C_TARGET_LENGTH => (ZSTD_TARGETLENGTH_MIN, ZSTD_TARGETLENGTH_MAX),
+        ZSTD_C_STRATEGY => (ZSTD_FAST, ZSTD_BTULTRA2),
+        _ => {
+            return ZSTD_bounds {
+                error: ERROR(ZstdErrorCode::ParameterUnsupported),
+                lowerBound: 0,
+                upperBound: 0,
+            }
+        }
+    };
+    ZSTD_bounds {
+        error: 0,
+        lowerBound,
+        upperBound,
+    }
+}
+
+#[inline]
+fn within_bounds(param: c_int, value: c_int) -> bool {
+    let bounds = bounds(param);
+    bounds.error == 0 && value >= bounds.lowerBound && value <= bounds.upperBound
+}
+
+#[inline]
+fn clamp_unsigned(value: u32, param: c_int) -> u32 {
+    let bounds = bounds(param);
+    debug_assert_eq!(bounds.error, 0);
+    let signed = value as c_int;
+    if signed < bounds.lowerBound {
+        bounds.lowerBound as u32
+    } else if signed > bounds.upperBound {
+        bounds.upperBound as u32
+    } else {
+        value
+    }
+}
+
+#[inline]
+fn clamp_cparams(mut cparams: ZSTD_compressionParameters) -> ZSTD_compressionParameters {
+    cparams.windowLog = clamp_unsigned(cparams.windowLog, ZSTD_C_WINDOW_LOG);
+    cparams.chainLog = clamp_unsigned(cparams.chainLog, ZSTD_C_CHAIN_LOG);
+    cparams.hashLog = clamp_unsigned(cparams.hashLog, ZSTD_C_HASH_LOG);
+    cparams.searchLog = clamp_unsigned(cparams.searchLog, ZSTD_C_SEARCH_LOG);
+    cparams.minMatch = clamp_unsigned(cparams.minMatch, ZSTD_C_MIN_MATCH);
+    cparams.targetLength = clamp_unsigned(cparams.targetLength, ZSTD_C_TARGET_LENGTH);
+    let strategy_bounds = bounds(ZSTD_C_STRATEGY);
+    if cparams.strategy < strategy_bounds.lowerBound {
+        cparams.strategy = strategy_bounds.lowerBound;
+    } else if cparams.strategy > strategy_bounds.upperBound {
+        cparams.strategy = strategy_bounds.upperBound;
+    }
+    cparams
+}
+
+#[inline]
+fn highbit32(value: u32) -> u32 {
+    debug_assert_ne!(value, 0);
+    u32::BITS - 1 - value.leading_zeros()
+}
+
+#[inline]
+fn cycle_log(hash_log: u32, strategy: c_int) -> u32 {
+    hash_log.wrapping_sub((strategy >= ZSTD_BTLAZY2) as u32)
+}
+
+#[inline]
+fn strategy_supports_row_match_finder(strategy: c_int) -> bool {
+    (ZSTD_GREEDY..=ZSTD_LAZY2).contains(&strategy)
+}
+
+#[inline]
+fn row_match_finder_used(strategy: c_int, mode: c_int) -> bool {
+    debug_assert_ne!(mode, ZSTD_RUST_PS_AUTO);
+    strategy_supports_row_match_finder(strategy) && mode == ZSTD_RUST_PS_ENABLE
+}
+
+#[inline]
+fn resolve_row_match_finder(mode: c_int, cparams: ZSTD_compressionParameters) -> c_int {
+    if mode != ZSTD_RUST_PS_AUTO {
+        return mode;
+    }
+    if strategy_supports_row_match_finder(cparams.strategy) && cparams.windowLog > 14 {
+        ZSTD_RUST_PS_ENABLE
+    } else {
+        ZSTD_RUST_PS_DISABLE
+    }
+}
+
+#[inline]
+fn dict_and_window_log(window_log: u32, src_size: u64, dict_size: u64) -> u32 {
+    /* 1ULL << ZSTD_WINDOWLOG_MAX, which is smaller for 32-bit builds. */
+    const MAX_WINDOW_SIZE: u64 = 1u64 << ZSTD_WINDOWLOG_MAX;
+    if dict_size == 0 {
+        return window_log;
+    }
+    debug_assert!(window_log <= ZSTD_WINDOWLOG_MAX as u32);
+    debug_assert_ne!(src_size, ZSTD_CONTENTSIZE_UNKNOWN);
+    let window_size = 1u64 << window_log;
+    if window_size >= dict_size.wrapping_add(src_size) {
+        window_log
+    } else {
+        let dict_and_window_size = dict_size.wrapping_add(window_size);
+        if dict_and_window_size >= MAX_WINDOW_SIZE {
+            ZSTD_WINDOWLOG_MAX as u32
+        } else {
+            highbit32((dict_and_window_size as u32).wrapping_sub(1)) + 1
+        }
+    }
+}
+
+/// Adjusts a *validated, configuration-resolved* parameter set.
+///
+/// This is the direct Rust leaf for `ZSTD_adjustCParams_internal()` after the
+/// C wrapper has applied its `ZSTD_EXCLUDE_*_BLOCK_COMPRESSOR` cascade.  In
+/// particular, it does not select a fallback strategy itself. `srcSize == 0`
+/// means a known empty input here, just as it does in the C internal helper;
+/// the public C wrapper must translate zero to `ZSTD_CONTENTSIZE_UNKNOWN`.
+fn adjust_cparams(
+    mut cparams: ZSTD_compressionParameters,
+    mut src_size: u64,
+    mut dict_size: usize,
+    mode: c_int,
+    mut use_row_match_finder: c_int,
+) -> ZSTD_compressionParameters {
+    debug_assert_eq!(check_cparams(cparams), 0);
+
+    const MIN_SRC_SIZE: u64 = 513;
+    /* 1ULL << (ZSTD_WINDOWLOG_MAX - 1), which is smaller for 32-bit builds. */
+    const MAX_WINDOW_RESIZE: u64 = 1u64 << (ZSTD_WINDOWLOG_MAX - 1);
+
+    match mode {
+        ZSTD_RUST_CPM_UNKNOWN | ZSTD_RUST_CPM_NO_ATTACH_DICT => {}
+        ZSTD_RUST_CPM_CREATE_CDICT => {
+            if dict_size != 0 && src_size == ZSTD_CONTENTSIZE_UNKNOWN {
+                src_size = MIN_SRC_SIZE;
+            }
+        }
+        ZSTD_RUST_CPM_ATTACH_DICT => dict_size = 0,
+        _ => debug_assert!(false, "invalid ZSTD_CParamMode_e"),
+    }
+
+    if src_size <= MAX_WINDOW_RESIZE && (dict_size as u64) <= MAX_WINDOW_RESIZE {
+        let total_size = src_size.wrapping_add(dict_size as u64) as u32;
+        let hash_size_min = 1u32 << ZSTD_HASHLOG_MIN;
+        let src_log = if total_size < hash_size_min {
+            ZSTD_HASHLOG_MIN as u32
+        } else {
+            highbit32(total_size.wrapping_sub(1)) + 1
+        };
+        cparams.windowLog = cparams.windowLog.min(src_log);
+    }
+
+    if src_size != ZSTD_CONTENTSIZE_UNKNOWN {
+        let dict_and_window_log =
+            dict_and_window_log(cparams.windowLog, src_size, dict_size as u64);
+        let cycle_log = cycle_log(cparams.chainLog, cparams.strategy);
+        cparams.hashLog = cparams.hashLog.min(dict_and_window_log + 1);
+        if cycle_log > dict_and_window_log {
+            cparams.chainLog = cparams
+                .chainLog
+                .wrapping_sub(cycle_log - dict_and_window_log);
+        }
+    }
+
+    cparams.windowLog = cparams.windowLog.max(ZSTD_WINDOWLOG_MIN as u32);
+
+    /* The short-cache tags used for fast and dfast CDicts consume eight bits
+     * of each 32-bit index.  This is a fixed private-header constant today;
+     * if it becomes configurable, the C shim must pass it as an explicit
+     * adjustment input rather than silently changing this leaf. */
+    if mode == ZSTD_RUST_CPM_CREATE_CDICT
+        && (cparams.strategy == ZSTD_FAST || cparams.strategy == ZSTD_DFAST)
+    {
+        const SHORT_CACHE_TAG_BITS: u32 = 8;
+        let max_short_cache_hash_log = 32 - SHORT_CACHE_TAG_BITS;
+        cparams.hashLog = cparams.hashLog.min(max_short_cache_hash_log);
+        cparams.chainLog = cparams.chainLog.min(max_short_cache_hash_log);
+    }
+
+    if use_row_match_finder == ZSTD_RUST_PS_AUTO {
+        use_row_match_finder = ZSTD_RUST_PS_ENABLE;
+    }
+    if row_match_finder_used(cparams.strategy, use_row_match_finder) {
+        const ROW_HASH_TAG_BITS: u32 = 8;
+        let row_log = cparams.searchLog.clamp(4, 6);
+        let max_hash_log = (32 - ROW_HASH_TAG_BITS) + row_log;
+        debug_assert!(cparams.hashLog >= row_log);
+        cparams.hashLog = cparams.hashLog.min(max_hash_log);
+    }
+
+    cparams
+}
+
+#[inline]
+fn get_cparam_row_size(src_size_hint: u64, dict_size: usize, mode: c_int) -> u64 {
+    let mut dict_size = dict_size as u64;
+    match mode {
+        ZSTD_RUST_CPM_UNKNOWN | ZSTD_RUST_CPM_NO_ATTACH_DICT | ZSTD_RUST_CPM_CREATE_CDICT => {}
+        ZSTD_RUST_CPM_ATTACH_DICT => dict_size = 0,
+        _ => debug_assert!(false, "invalid ZSTD_CParamMode_e"),
+    }
+    let unknown = src_size_hint == ZSTD_CONTENTSIZE_UNKNOWN;
+    let added_size = if unknown && dict_size > 0 { 500 } else { 0 };
+    if unknown && dict_size == 0 {
+        ZSTD_CONTENTSIZE_UNKNOWN
+    } else {
+        src_size_hint
+            .wrapping_add(dict_size)
+            .wrapping_add(added_size)
+    }
+}
+
+/// Selects a raw compression-level-table entry, without strategy cascading or
+/// source/dictionary adjustment.
+///
+/// A C wrapper must apply its active excluded-compressor cascade to the
+/// returned strategy before calling [`ZSTD_rust_params_adjustCParams`].
+fn select_cparams(
+    compression_level: c_int,
+    src_size_hint: u64,
+    dict_size: usize,
+    mode: c_int,
+) -> ZSTD_compressionParameters {
+    let row_size = get_cparam_row_size(src_size_hint, dict_size, mode);
+    let table_id = usize::from(row_size <= 256 * 1024)
+        + usize::from(row_size <= 128 * 1024)
+        + usize::from(row_size <= 16 * 1024);
+    let row = if compression_level == 0 {
+        ZSTD_CLEVEL_DEFAULT
+    } else if compression_level < 0 {
+        0
+    } else {
+        compression_level.min(ZSTD_MAX_CLEVEL)
+    } as usize;
+
+    let mut cparams = cparams_from_row(DEFAULT_CPARAMS[table_id][row]);
+    if compression_level < 0 {
+        let clamped = compression_level.max(ZSTD_rust_params_minCLevel());
+        cparams.targetLength = (-clamped) as u32;
+    }
+    cparams
+}
+
+#[inline]
+fn make_params(cparams: ZSTD_compressionParameters) -> ZSTD_parameters {
+    ZSTD_parameters {
+        cParams: cparams,
+        fParams: ZSTD_frameParameters {
+            contentSizeFlag: 1,
+            checksumFlag: 0,
+            noDictIDFlag: 0,
+        },
+    }
+}
+
+#[inline]
+fn check_cparams(cparams: ZSTD_compressionParameters) -> usize {
+    if !within_bounds(ZSTD_C_WINDOW_LOG, cparams.windowLog as c_int)
+        || !within_bounds(ZSTD_C_CHAIN_LOG, cparams.chainLog as c_int)
+        || !within_bounds(ZSTD_C_HASH_LOG, cparams.hashLog as c_int)
+        || !within_bounds(ZSTD_C_SEARCH_LOG, cparams.searchLog as c_int)
+        || !within_bounds(ZSTD_C_MIN_MATCH, cparams.minMatch as c_int)
+        || !within_bounds(ZSTD_C_TARGET_LENGTH, cparams.targetLength as c_int)
+        || !within_bounds(ZSTD_C_STRATEGY, cparams.strategy)
+    {
+        ERROR(ZstdErrorCode::ParameterOutOfBound)
+    } else {
+        0
+    }
+}
+
+/// Returns the highest table-backed compression level (`ZSTD_MAX_CLEVEL`).
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_maxCLevel() -> c_int {
+    ZSTD_MAX_CLEVEL
+}
+
+/// Returns the lowest public fast level (`-ZSTD_TARGETLENGTH_MAX`).
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_minCLevel() -> c_int {
+    -ZSTD_TARGETLENGTH_MAX
+}
+
+/// Returns the default compression level from `zstd.h`.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_defaultCLevel() -> c_int {
+    ZSTD_CLEVEL_DEFAULT
+}
+
+/// Returns bounds for the seven core compression parameters and compression
+/// level.  Other `ZSTD_cParameter` cases remain C-owned.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_getBounds(param: c_int) -> ZSTD_bounds {
+    bounds(param)
+}
+
+/// Checks the seven fields of `ZSTD_compressionParameters`.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_checkCParams(cparams: ZSTD_compressionParameters) -> usize {
+    check_cparams(cparams)
+}
+
+/// Clamps the seven fields of `ZSTD_compressionParameters` to public bounds.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_clampCParams(
+    cparams: ZSTD_compressionParameters,
+) -> ZSTD_compressionParameters {
+    clamp_cparams(cparams)
+}
+
+/// C ABI for `ZSTD_cycleLog()`.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_cycleLog(hashLog: u32, strategy: c_int) -> u32 {
+    cycle_log(hashLog, strategy)
+}
+
+/// C ABI for private `ZSTD_getCParamRowSize()`.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_getCParamRowSize(
+    srcSizeHint: u64,
+    dictSize: usize,
+    mode: c_int,
+) -> u64 {
+    get_cparam_row_size(srcSizeHint, dictSize, mode)
+}
+
+/// Returns the unadjusted compression-level-table entry.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_selectCParams(
+    compressionLevel: c_int,
+    srcSizeHint: u64,
+    dictSize: usize,
+    mode: c_int,
+) -> ZSTD_compressionParameters {
+    select_cparams(compressionLevel, srcSizeHint, dictSize, mode)
+}
+
+/// Adjusts a validated, strategy-resolved C parameter set.
+///
+/// See [`adjust_cparams`] for the required C-side policy step.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_adjustCParams(
+    cparams: ZSTD_compressionParameters,
+    srcSize: u64,
+    dictSize: usize,
+    mode: c_int,
+    useRowMatchFinder: c_int,
+) -> ZSTD_compressionParameters {
+    adjust_cparams(cparams, srcSize, dictSize, mode, useRowMatchFinder)
+}
+
+/// Builds `ZSTD_parameters` with the public default frame parameters.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_makeParams(
+    cparams: ZSTD_compressionParameters,
+) -> ZSTD_parameters {
+    make_params(cparams)
+}
+
+/// Runtime sizes needed to reproduce `ZSTD_sizeof_matchState()` without
+/// exposing private C structures to Rust.
+///
+/// `asanRedzoneSize` is `ZSTD_CWKSP_ASAN_REDZONE_SIZE` when workspace
+/// poisoning is enabled and zero otherwise. `matchTSize` and `optimalTSize`
+/// must be `sizeof(ZSTD_match_t)` and `sizeof(ZSTD_optimal_t)` respectively.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default)]
+pub struct ZSTD_rustMatchStateSizing {
+    pub hashLog3Max: u32,
+    pub matchTSize: usize,
+    pub optimalTSize: usize,
+    pub asanRedzoneSize: usize,
+}
+
+/// C-only layout inputs for `ZSTD_estimateCDictSize_advanced()`.
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Default)]
+pub struct ZSTD_rustCDictSizing {
+    pub cdictSize: usize,
+    pub hufWorkspaceSize: usize,
+    pub hashLog3Max: u32,
+    pub matchTSize: usize,
+    pub optimalTSize: usize,
+    pub asanRedzoneSize: usize,
+}
+
+#[inline]
+fn cwksp_alloc_size(size: usize, asan_redzone_size: usize) -> usize {
+    if size == 0 {
+        0
+    } else {
+        size.wrapping_add(asan_redzone_size.wrapping_mul(2))
+    }
+}
+
+#[inline]
+fn cwksp_align(size: usize, alignment: usize) -> usize {
+    debug_assert!(alignment.is_power_of_two());
+    size.wrapping_add(alignment - 1) & !(alignment - 1)
+}
+
+#[inline]
+fn cwksp_aligned64_alloc_size(size: usize, asan_redzone_size: usize) -> usize {
+    cwksp_alloc_size(cwksp_align(size, 64), asan_redzone_size)
+}
+
+#[inline]
+fn shift_size(log: u32) -> usize {
+    debug_assert!(log < usize::BITS);
+    1usize << log
+}
+
+#[inline]
+fn allocate_chain_table(strategy: c_int, use_row_match_finder: c_int, for_dds_dict: bool) -> bool {
+    for_dds_dict
+        || (strategy != ZSTD_FAST && !row_match_finder_used(strategy, use_row_match_finder))
+}
+
+fn estimate_match_state_size(
+    cparams: ZSTD_compressionParameters,
+    use_row_match_finder: c_int,
+    enable_dedicated_dict_search: bool,
+    for_cctx: bool,
+    sizing: ZSTD_rustMatchStateSizing,
+) -> usize {
+    if check_cparams(cparams) != 0 || use_row_match_finder == ZSTD_RUST_PS_AUTO {
+        return 0;
+    }
+
+    let chain_size = if allocate_chain_table(
+        cparams.strategy,
+        use_row_match_finder,
+        enable_dedicated_dict_search && !for_cctx,
+    ) {
+        shift_size(cparams.chainLog)
+    } else {
+        0
+    };
+    let hash_size = shift_size(cparams.hashLog);
+    let hash_log_3 = if for_cctx && cparams.minMatch == 3 {
+        cparams.windowLog.min(sizing.hashLog3Max)
+    } else {
+        0
+    };
+    let hash3_size = if hash_log_3 == 0 {
+        0
+    } else {
+        shift_size(hash_log_3)
+    };
+    let table_space = chain_size
+        .wrapping_mul(size_of::<u32>())
+        .wrapping_add(hash_size.wrapping_mul(size_of::<u32>()))
+        .wrapping_add(hash3_size.wrapping_mul(size_of::<u32>()));
+
+    let redzone = sizing.asanRedzoneSize;
+    let opt_potential_space = cwksp_aligned64_alloc_size((52 + 1) * size_of::<u32>(), redzone)
+        .wrapping_add(cwksp_aligned64_alloc_size(
+            (35 + 1) * size_of::<u32>(),
+            redzone,
+        ))
+        .wrapping_add(cwksp_aligned64_alloc_size(
+            (31 + 1) * size_of::<u32>(),
+            redzone,
+        ))
+        .wrapping_add(cwksp_aligned64_alloc_size(
+            (1 << 8) * size_of::<u32>(),
+            redzone,
+        ))
+        .wrapping_add(cwksp_aligned64_alloc_size(
+            4099usize.wrapping_mul(sizing.matchTSize),
+            redzone,
+        ))
+        .wrapping_add(cwksp_aligned64_alloc_size(
+            4099usize.wrapping_mul(sizing.optimalTSize),
+            redzone,
+        ));
+    let lazy_additional_space = if row_match_finder_used(cparams.strategy, use_row_match_finder) {
+        cwksp_aligned64_alloc_size(hash_size, redzone)
+    } else {
+        0
+    };
+    let opt_space = if for_cctx && cparams.strategy >= ZSTD_BTOPT {
+        opt_potential_space
+    } else {
+        0
+    };
+    let slack_space = 2 * 64;
+
+    table_space
+        .wrapping_add(opt_space)
+        .wrapping_add(slack_space)
+        .wrapping_add(lazy_additional_space)
+}
+
+/// Pure leaf for private `ZSTD_sizeof_matchState()`.
+///
+/// `useRowMatchFinder` must already be resolved to enable or disable.  A NULL
+/// `sizing` pointer or invalid C parameters returns zero; C never supplies
+/// either in a valid estimator call.
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_rust_params_estimateMatchStateSize(
+    cparams: ZSTD_compressionParameters,
+    useRowMatchFinder: c_int,
+    enableDedicatedDictSearch: c_int,
+    forCCtx: u32,
+    sizing: *const ZSTD_rustMatchStateSizing,
+) -> usize {
+    if sizing.is_null() {
+        return 0;
+    }
+    let sizing = unsafe { *sizing };
+    estimate_match_state_size(
+        cparams,
+        useRowMatchFinder,
+        enableDedicatedDictSearch != 0,
+        forCCtx != 0,
+        sizing,
+    )
+}
+
+#[inline]
+fn max_nb_seq(block_size: usize, min_match: u32, use_sequence_producer: bool) -> usize {
+    let divider = if min_match == 3 || use_sequence_producer {
+        3
+    } else {
+        4
+    };
+    block_size / divider
+}
+
+/// Pure leaf for private `ZSTD_maxNbSeq()`.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_maxNbSeq(
+    blockSize: usize,
+    minMatch: u32,
+    useSequenceProducer: c_int,
+) -> usize {
+    max_nb_seq(blockSize, minMatch, useSequenceProducer != 0)
+}
+
+/// Pure leaf for private `ZSTD_resolveMaxBlockSize()`.
+#[no_mangle]
+pub extern "C" fn ZSTD_rust_params_resolveMaxBlockSize(maxBlockSize: usize) -> usize {
+    if maxBlockSize == 0 {
+        ZSTD_BLOCKSIZE_MAX
+    } else {
+        maxBlockSize
+    }
+}
+
+fn estimate_cdict_size_from_cparams(
+    dict_size: usize,
+    cparams: ZSTD_compressionParameters,
+    dict_load_method: c_int,
+    sizing: ZSTD_rustCDictSizing,
+) -> usize {
+    if check_cparams(cparams) != 0 {
+        return 0;
+    }
+    let match_state_sizing = ZSTD_rustMatchStateSizing {
+        hashLog3Max: sizing.hashLog3Max,
+        matchTSize: sizing.matchTSize,
+        optimalTSize: sizing.optimalTSize,
+        asanRedzoneSize: sizing.asanRedzoneSize,
+    };
+    let row_match_finder = resolve_row_match_finder(ZSTD_RUST_PS_AUTO, cparams);
+    let copied_dict_space = if dict_load_method == 1 {
+        0
+    } else {
+        cwksp_alloc_size(
+            cwksp_align(dict_size, size_of::<usize>()),
+            sizing.asanRedzoneSize,
+        )
+    };
+    cwksp_alloc_size(sizing.cdictSize, sizing.asanRedzoneSize)
+        .wrapping_add(cwksp_alloc_size(
+            sizing.hufWorkspaceSize,
+            sizing.asanRedzoneSize,
+        ))
+        .wrapping_add(estimate_match_state_size(
+            cparams,
+            row_match_finder,
+            true,
+            false,
+            match_state_sizing,
+        ))
+        .wrapping_add(copied_dict_space)
+}
+
+/// Parameter-only leaf for `ZSTD_estimateCDictSize_advanced()`.
+///
+/// C retains ownership of `sizeof(ZSTD_CDict)`, HUF workspace configuration,
+/// and sanitizer workspace policy, then passes them in `sizing`. A NULL sizing
+/// pointer returns zero.
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_rust_params_estimateCDictSizeFromCParams(
+    dictSize: usize,
+    cparams: ZSTD_compressionParameters,
+    dictLoadMethod: c_int,
+    sizing: *const ZSTD_rustCDictSizing,
+) -> usize {
+    if sizing.is_null() {
+        return 0;
+    }
+    estimate_cdict_size_from_cparams(dictSize, cparams, dictLoadMethod, unsafe { *sizing })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::errors::ERR_isError;
+    use std::mem::{align_of, size_of};
+
+    fn adjust_public(
+        cparams: ZSTD_compressionParameters,
+        src_size: u64,
+        dict_size: usize,
+    ) -> ZSTD_compressionParameters {
+        let src_size = if src_size == 0 {
+            ZSTD_CONTENTSIZE_UNKNOWN
+        } else {
+            src_size
+        };
+        adjust_cparams(
+            clamp_cparams(cparams),
+            src_size,
+            dict_size,
+            ZSTD_RUST_CPM_UNKNOWN,
+            ZSTD_RUST_PS_AUTO,
+        )
+    }
+
+    #[test]
+    fn abi_parameter_layouts_match_zstd_h() {
+        assert_eq!(
+            size_of::<ZSTD_compressionParameters>(),
+            7 * size_of::<u32>()
+        );
+        assert_eq!(align_of::<ZSTD_compressionParameters>(), align_of::<u32>());
+        assert_eq!(size_of::<ZSTD_frameParameters>(), 3 * size_of::<c_int>());
+        assert_eq!(size_of::<ZSTD_parameters>(), 10 * size_of::<u32>());
+        assert_eq!(
+            size_of::<ZSTD_bounds>(),
+            size_of::<usize>() + 2 * size_of::<c_int>()
+        );
+    }
+
+    #[test]
+    fn level_tables_match_representative_clevels_entries() {
+        let large = select_cparams(3, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN);
+        assert_eq!(
+            large,
+            ZSTD_compressionParameters {
+                windowLog: 21,
+                chainLog: 16,
+                hashLog: 17,
+                searchLog: 1,
+                minMatch: 5,
+                targetLength: 0,
+                strategy: ZSTD_DFAST,
+            }
+        );
+
+        let small = select_cparams(3, 16 * 1024, 0, ZSTD_RUST_CPM_UNKNOWN);
+        assert_eq!(
+            small,
+            ZSTD_compressionParameters {
+                windowLog: 14,
+                chainLog: 14,
+                hashLog: 15,
+                searchLog: 2,
+                minMatch: 4,
+                targetLength: 0,
+                strategy: ZSTD_DFAST,
+            }
+        );
+
+        let fast = select_cparams(-5, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN);
+        assert_eq!(fast.strategy, ZSTD_FAST);
+        assert_eq!(fast.targetLength, 5);
+        assert_eq!(
+            select_cparams(999, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN),
+            select_cparams(22, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN)
+        );
+    }
+
+    #[test]
+    fn adjustment_clamps_and_downsizes_like_the_c_leaf() {
+        let input = ZSTD_compressionParameters {
+            windowLog: 31,
+            chainLog: 30,
+            hashLog: 30,
+            searchLog: 1,
+            minMatch: 3,
+            targetLength: 0,
+            strategy: ZSTD_BTOPT,
+        };
+        let adjusted = adjust_public(input, 1, 0);
+        assert_eq!(adjusted.windowLog, 10);
+        /* C applies WINDOWLOG_ABSOLUTEMIN only after it has used the smaller
+         * temporary window to downsize the hash and chain logs. */
+        assert_eq!(adjusted.hashLog, 7);
+        assert_eq!(adjusted.chainLog, 7);
+        assert_eq!(ZSTD_rust_params_checkCParams(adjusted), 0);
+
+        let clamped = ZSTD_rust_params_clampCParams(ZSTD_compressionParameters {
+            windowLog: u32::MAX,
+            chainLog: 0,
+            hashLog: 0,
+            searchLog: 0,
+            minMatch: 0,
+            targetLength: u32::MAX,
+            strategy: 99,
+        });
+        assert_eq!(clamped.windowLog, ZSTD_WINDOWLOG_MIN as u32);
+        assert_eq!(clamped.chainLog, ZSTD_CHAINLOG_MIN as u32);
+        assert_eq!(clamped.hashLog, ZSTD_HASHLOG_MIN as u32);
+        assert_eq!(clamped.searchLog, ZSTD_SEARCHLOG_MIN as u32);
+        assert_eq!(clamped.minMatch, ZSTD_MINMATCH_MIN as u32);
+        assert_eq!(clamped.targetLength, ZSTD_TARGETLENGTH_MIN as u32);
+        assert_eq!(clamped.strategy, ZSTD_BTULTRA2);
+    }
+
+    #[test]
+    fn checking_and_bounds_preserve_the_public_error_contract() {
+        let valid = select_cparams(1, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN);
+        assert_eq!(check_cparams(valid), 0);
+        let mut invalid = valid;
+        invalid.minMatch = 2;
+        assert!(ERR_isError(check_cparams(invalid)));
+        let bounds = ZSTD_rust_params_getBounds(ZSTD_C_HASH_LOG);
+        assert_eq!(bounds.error, 0);
+        assert_eq!(bounds.lowerBound, 6);
+        assert_eq!(bounds.upperBound, 30);
+        assert!(ERR_isError(ZSTD_rust_params_getBounds(-1).error));
+    }
+
+    #[test]
+    fn params_default_frame_flags_match_c() {
+        let cparams = select_cparams(5, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN);
+        let params = ZSTD_rust_params_makeParams(cparams);
+        assert_eq!(params.cParams, cparams);
+        assert_eq!(params.fParams.contentSizeFlag, 1);
+        assert_eq!(params.fParams.checksumFlag, 0);
+        assert_eq!(params.fParams.noDictIDFlag, 0);
+    }
+
+    #[test]
+    fn row_size_preserves_unknown_dictionary_overflow_semantics() {
+        assert_eq!(
+            get_cparam_row_size(ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_RUST_CPM_UNKNOWN),
+            ZSTD_CONTENTSIZE_UNKNOWN
+        );
+        assert_eq!(
+            get_cparam_row_size(ZSTD_CONTENTSIZE_UNKNOWN, 1, ZSTD_RUST_CPM_UNKNOWN),
+            500
+        );
+        assert_eq!(
+            get_cparam_row_size(128 * 1024, 1, ZSTD_RUST_CPM_ATTACH_DICT),
+            128 * 1024
+        );
+    }
+
+    #[test]
+    fn match_state_sizing_reproduces_table_and_row_rules() {
+        let sizing = ZSTD_rustMatchStateSizing {
+            hashLog3Max: 17,
+            matchTSize: 16,
+            optimalTSize: 32,
+            asanRedzoneSize: 0,
+        };
+        let fast = ZSTD_compressionParameters {
+            windowLog: 10,
+            chainLog: 10,
+            hashLog: 10,
+            searchLog: 1,
+            minMatch: 4,
+            targetLength: 0,
+            strategy: ZSTD_FAST,
+        };
+        assert_eq!(
+            estimate_match_state_size(fast, ZSTD_RUST_PS_DISABLE, false, true, sizing),
+            4096 + 128
+        );
+
+        let row = ZSTD_compressionParameters {
+            windowLog: 15,
+            chainLog: 10,
+            hashLog: 10,
+            searchLog: 4,
+            minMatch: 4,
+            targetLength: 0,
+            strategy: ZSTD_GREEDY,
+        };
+        assert_eq!(
+            estimate_match_state_size(row, ZSTD_RUST_PS_ENABLE, false, true, sizing),
+            4096 + 1024 + 128
+        );
+        assert_eq!(ZSTD_rust_params_maxNbSeq(100, 3, 0), 33);
+        assert_eq!(ZSTD_rust_params_maxNbSeq(100, 4, 0), 25);
+        assert_eq!(ZSTD_rust_params_resolveMaxBlockSize(0), 128 * 1024);
+    }
+}

rust/src/zstd_compress_stats.rs

@@ -0,0 +1,1549 @@
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+
+//! Sequence statistics and seqStore entropy compression.
+//!
+//! This module translates the block entropy-statistics layer of
+//! `zstd_compress.c`: `ZSTD_seqToCodes()`, `ZSTD_buildSequencesStatistics()`,
+//! `ZSTD_entropyCompressSeqStore*()`, `ZSTD_buildBlockEntropyStats*()`, and
+//! `ZSTD_copyBlockSequences()`.  The `ZSTD_CCtx` and `ZSTD_CCtx_params`
+//! layouts stay private to C: the C shims extract the sequence store, the
+//! entropy-table leaves, and the two parameter scalars these paths read
+//! (the compression strategy and the literals-compression switch).  Block
+//! dispatch, block splitting, and the block-size estimation heuristics also
+//! remain in C for a later slice.
+
+use crate::bits::ZSTD_highbit32;
+use crate::common::{
+    DEFAULT_MAX_OFF, LL_DEFAULT_NORM, LL_DEFAULT_NORM_LOG, LL_FSE_LOG, LONGNBSEQ, MAX_LL, MAX_ML,
+    MAX_OFF, MAX_SEQ, MINMATCH, ML_DEFAULT_NORM, ML_DEFAULT_NORM_LOG, ML_FSE_LOG, OFF_FSE_LOG,
+    OF_DEFAULT_NORM, OF_DEFAULT_NORM_LOG, ZSTD_MAX_FSE_HEADERS_SIZE, ZSTD_MAX_HUF_HEADER_SIZE,
+    ZSTD_REP_NUM,
+};
+use crate::errors::{ERR_isError, ZstdErrorCode, ERROR};
+use crate::hist::{HIST_countFast_wksp, HIST_count_wksp};
+use crate::huf_compress::{
+    HUF_buildCTable_wksp, HUF_estimateCompressedSize, HUF_optimalTableLog, HUF_validateCTable,
+    HUF_writeCTable_wksp,
+};
+use crate::mem::{MEM_32bits, MEM_writeLE16};
+use crate::zstd_compress_literals::{
+    copy_huf_tables, min_gain, ZSTD_compressLiterals, ZSTD_hufCTables_t,
+};
+use crate::zstd_compress_sequences::{
+    SeqDef, ZSTD_buildCTable, ZSTD_encodeSequences, ZSTD_selectEncodingType,
+};
+use std::ffi::c_void;
+use std::mem::{size_of, size_of_val};
+use std::os::raw::{c_int, c_uint};
+use std::ptr;
+
+const SET_BASIC: c_int = 0;
+const SET_RLE: c_int = 1;
+const SET_COMPRESSED: c_int = 2;
+const SET_REPEAT: c_int = 3;
+
+const FSE_REPEAT_NONE: c_int = 0;
+
+const HUF_REPEAT_NONE: c_int = 0;
+const HUF_REPEAT_CHECK: c_int = 1;
+const HUF_REPEAT_VALID: c_int = 2;
+
+const HUF_FLAGS_OPTIMAL_DEPTH: c_int = 1 << 1;
+const HUF_OPTIMAL_DEPTH_THRESHOLD: c_int = 8; /* ZSTD_btultra */
+
+const ZSTD_DEFAULT_DISALLOWED: c_int = 0;
+const ZSTD_DEFAULT_ALLOWED: c_int = 1;
+
+const HUF_SYMBOLVALUE_MAX: c_uint = 255;
+const LIT_HUF_LOG: c_uint = 11;
+const COMPRESS_LITERALS_SIZE_MIN: usize = 63;
+const SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO: usize = 20;
+
+const STREAM_ACCUMULATOR_MIN_32: u32 = 25;
+const STREAM_ACCUMULATOR_MIN_64: u32 = 57;
+
+const LL_DELTA_CODE: u32 = 19;
+const ML_DELTA_CODE: u32 = 36;
+
+pub(crate) const ZSTD_LLT_LITERAL_LENGTH: c_int = 1;
+pub(crate) const ZSTD_LLT_MATCH_LENGTH: c_int = 2;
+
+/// `FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)` from the C headers.
+pub const OFF_CTABLE_SIZE: usize = 1 + (1 << (OFF_FSE_LOG - 1)) + ((MAX_OFF + 1) * 2);
+/// `FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)` from the C headers.
+pub const ML_CTABLE_SIZE: usize = 1 + (1 << (ML_FSE_LOG - 1)) + ((MAX_ML + 1) * 2);
+/// `FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)` from the C headers.
+pub const LL_CTABLE_SIZE: usize = 1 + (1 << (LL_FSE_LOG - 1)) + ((MAX_LL + 1) * 2);
+
+/// ABI-compatible `SeqStore_t` leaf layout from `zstd_compress_internal.h`.
+///
+/// The C context itself remains opaque; its shims pass the `seqStore` member
+/// directly, so this small, stable hot-path structure is the only sequence
+/// storage representation crossing into Rust.
+#[repr(C)]
+pub struct SeqStore_t {
+    pub sequencesStart: *mut SeqDef,
+    pub sequences: *mut SeqDef,
+    pub litStart: *mut u8,
+    pub lit: *mut u8,
+    pub llCode: *mut u8,
+    pub mlCode: *mut u8,
+    pub ofCode: *mut u8,
+    pub maxNbSeq: usize,
+    pub maxNbLit: usize,
+    pub longLengthType: c_int,
+    pub longLengthPos: u32,
+}
+
+/// C's `ZSTD_fseCTables_t`.  The table element type is `FSE_CTable`, an
+/// `unsigned`, and the table lengths are the header macros expanded above.
+#[repr(C)]
+pub struct ZSTD_fseCTables_t {
+    pub offcodeCTable: [u32; OFF_CTABLE_SIZE],
+    pub matchlengthCTable: [u32; ML_CTABLE_SIZE],
+    pub litlengthCTable: [u32; LL_CTABLE_SIZE],
+    pub offcode_repeatMode: c_int,
+    pub matchlength_repeatMode: c_int,
+    pub litlength_repeatMode: c_int,
+}
+
+/// C's `ZSTD_entropyCTables_t`.
+#[repr(C)]
+pub struct ZSTD_entropyCTables_t {
+    pub huf: ZSTD_hufCTables_t,
+    pub fse: ZSTD_fseCTables_t,
+}
+
+/// C's `ZSTD_compressedBlockState_t`.
+#[repr(C)]
+pub struct ZSTD_compressedBlockState_t {
+    pub entropy: ZSTD_entropyCTables_t,
+    pub rep: [u32; ZSTD_REP_NUM],
+}
+
+/// C's `ZSTD_hufCTablesMetadata_t`.
+#[repr(C)]
+pub struct ZSTD_hufCTablesMetadata_t {
+    pub hType: c_int,
+    pub hufDesBuffer: [u8; ZSTD_MAX_HUF_HEADER_SIZE],
+    pub hufDesSize: usize,
+}
+
+/// C's `ZSTD_fseCTablesMetadata_t`.
+#[repr(C)]
+pub struct ZSTD_fseCTablesMetadata_t {
+    pub llType: c_int,
+    pub ofType: c_int,
+    pub mlType: c_int,
+    pub fseTablesBuffer: [u8; ZSTD_MAX_FSE_HEADERS_SIZE],
+    pub fseTablesSize: usize,
+    pub lastCountSize: usize,
+}
+
+/// C's `ZSTD_entropyCTablesMetadata_t`.
+#[repr(C)]
+pub struct ZSTD_entropyCTablesMetadata_t {
+    pub hufMetadata: ZSTD_hufCTablesMetadata_t,
+    pub fseMetadata: ZSTD_fseCTablesMetadata_t,
+}
+
+/// Public `ZSTD_Sequence` from `zstd.h`.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct ZSTD_Sequence {
+    pub offset: u32,
+    pub litLength: u32,
+    pub matchLength: u32,
+    pub rep: u32,
+}
+
+/// C's `SeqCollector` leaf from `zstd_compress_internal.h`.
+#[repr(C)]
+pub struct SeqCollector {
+    pub collectSequences: c_int,
+    pub seqStart: *mut ZSTD_Sequence,
+    pub seqIndex: usize,
+    pub maxSequences: usize,
+}
+
+/// Result of `build_sequences_statistics()`; mirrors C's
+/// `ZSTD_symbolEncodingTypeStats_t`, which no longer crosses the boundary.
+pub(crate) struct SymbolEncodingTypeStats {
+    pub ll_type: u32,
+    pub off_type: u32,
+    pub ml_type: u32,
+    pub size: usize,
+    /// Accounts for a bug in zstd 1.3.4; see
+    /// `entropy_compress_seq_store_internal()`.
+    pub last_count_size: usize,
+    pub long_offsets: c_int,
+}
+
+/// C's `ZSTD_updateRep()` repeat-offset history update.
+#[inline]
+pub(crate) fn update_rep(reps: &mut [u32; 3], off_base: u32, literal_length_is_zero: bool) {
+    if off_base > 3 {
+        reps[2] = reps[1];
+        reps[1] = reps[0];
+        reps[0] = off_base - 3;
+        return;
+    }
+    let rep_code = off_base - 1 + u32::from(literal_length_is_zero);
+    if rep_code == 0 {
+        return;
+    }
+    let current_offset = if rep_code == 3 {
+        reps[0].wrapping_sub(1)
+    } else {
+        reps[rep_code as usize]
+    };
+    reps[2] = if rep_code >= 2 { reps[1] } else { reps[2] };
+    reps[1] = reps[0];
+    reps[0] = current_offset;
+}
+
+#[inline]
+fn ll_code(lit_length: u32) -> u32 {
+    const LL_CODE: [u8; 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,
+    ];
+    if lit_length > 63 {
+        ZSTD_highbit32(lit_length) + LL_DELTA_CODE
+    } else {
+        LL_CODE[lit_length as usize] as u32
+    }
+}
+
+#[inline]
+fn ml_code(ml_base: u32) -> u32 {
+    const ML_CODE: [u8; 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,
+    ];
+    if ml_base > 127 {
+        ZSTD_highbit32(ml_base) + ML_DELTA_CODE
+    } else {
+        ML_CODE[ml_base as usize] as u32
+    }
+}
+
+#[inline]
+unsafe fn copy_fse_tables(dst: *mut ZSTD_fseCTables_t, src: *const ZSTD_fseCTables_t) {
+    unsafe {
+        ptr::copy_nonoverlapping(
+            src.cast::<u8>(),
+            dst.cast::<u8>(),
+            size_of::<ZSTD_fseCTables_t>(),
+        )
+    };
+}
+
+/// Converts the stored lengths and distances into symbol codes.
+///
+/// Retains its original exported name: the C dictionary builder and the
+/// decodecorpus test tool link against it directly.
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_seqToCodes(seq_store: *const SeqStore_t) -> c_int {
+    let store = unsafe { &*seq_store };
+    let sequences = store.sequencesStart;
+    let nb_seq = unsafe { store.sequences.offset_from(sequences) } as usize;
+    let mut long_offsets = 0;
+    debug_assert!(nb_seq <= store.maxNbSeq);
+
+    for index in 0..nb_seq {
+        let sequence = unsafe { sequences.add(index).read() };
+        let of_code = ZSTD_highbit32(sequence.offBase);
+        unsafe {
+            *store.llCode.add(index) = ll_code(sequence.litLength as u32) as u8;
+            *store.ofCode.add(index) = of_code as u8;
+            *store.mlCode.add(index) = ml_code(sequence.mlBase as u32) as u8;
+        }
+        debug_assert!(MEM_32bits() || of_code < STREAM_ACCUMULATOR_MIN_64);
+        if MEM_32bits() && of_code >= STREAM_ACCUMULATOR_MIN_32 {
+            long_offsets = 1;
+        }
+    }
+    if store.longLengthType == ZSTD_LLT_LITERAL_LENGTH {
+        unsafe { *store.llCode.add(store.longLengthPos as usize) = MAX_LL as u8 };
+    }
+    if store.longLengthType == ZSTD_LLT_MATCH_LENGTH {
+        unsafe { *store.mlCode.add(store.longLengthPos as usize) = MAX_ML as u8 };
+    }
+    long_offsets
+}
+
+/// C's `ZSTD_buildSequencesStatistics()`.
+///
+/// Returns the statistics with a zstd error code in the `size` field on
+/// failure, and updates `next_entropy` as a side effect.  `nb_seq` must be
+/// greater than zero, and the entropy workspace must hold at least
+/// `ENTROPY_WORKSPACE_SIZE - (MaxSeq + 1) * sizeof(U32)` bytes.
+#[allow(clippy::too_many_arguments)]
+pub(crate) unsafe fn build_sequences_statistics(
+    seq_store: *const SeqStore_t,
+    nb_seq: usize,
+    prev_entropy: *const ZSTD_fseCTables_t,
+    next_entropy: *mut ZSTD_fseCTables_t,
+    dst: *mut u8,
+    dst_capacity: usize,
+    strategy: c_int,
+    count_workspace: *mut c_uint,
+    entropy_workspace: *mut c_void,
+    entropy_wksp_size: usize,
+) -> SymbolEncodingTypeStats {
+    let store = unsafe { &*seq_store };
+    let mut stats = SymbolEncodingTypeStats {
+        ll_type: 0,
+        off_type: 0,
+        ml_type: 0,
+        size: 0,
+        last_count_size: 0,
+        long_offsets: 0,
+    };
+    let mut written = 0usize;
+
+    /* convert length/distances into codes */
+    stats.long_offsets = unsafe { ZSTD_seqToCodes(seq_store) };
+    debug_assert!(nb_seq != 0); /* ZSTD_selectEncodingType() divides by nb_seq */
+
+    /* build CTable for Literal Lengths */
+    {
+        let mut max = MAX_LL as c_uint;
+        let most_frequent = unsafe {
+            HIST_countFast_wksp(
+                count_workspace,
+                &mut max,
+                store.llCode.cast::<c_void>(),
+                nb_seq,
+                entropy_workspace,
+                entropy_wksp_size,
+            )
+        }; /* can't fail */
+        unsafe { (*next_entropy).litlength_repeatMode = (*prev_entropy).litlength_repeatMode };
+        stats.ll_type = unsafe {
+            ZSTD_selectEncodingType(
+                ptr::addr_of_mut!((*next_entropy).litlength_repeatMode),
+                count_workspace,
+                max,
+                most_frequent,
+                nb_seq,
+                LL_FSE_LOG as c_uint,
+                ptr::addr_of!((*prev_entropy).litlengthCTable).cast::<u32>(),
+                LL_DEFAULT_NORM.as_ptr(),
+                LL_DEFAULT_NORM_LOG,
+                ZSTD_DEFAULT_ALLOWED,
+                strategy,
+            )
+        } as u32;
+        let count_size = unsafe {
+            ZSTD_buildCTable(
+                dst.add(written).cast::<c_void>(),
+                dst_capacity - written,
+                ptr::addr_of_mut!((*next_entropy).litlengthCTable).cast::<u32>(),
+                LL_FSE_LOG as u32,
+                stats.ll_type as c_int,
+                count_workspace,
+                max,
+                store.llCode,
+                nb_seq,
+                LL_DEFAULT_NORM.as_ptr(),
+                LL_DEFAULT_NORM_LOG,
+                MAX_LL as u32,
+                ptr::addr_of!((*prev_entropy).litlengthCTable).cast::<u32>(),
+                size_of::<[u32; LL_CTABLE_SIZE]>(),
+                entropy_workspace,
+                entropy_wksp_size,
+            )
+        };
+        if ERR_isError(count_size) {
+            stats.size = count_size;
+            return stats;
+        }
+        if stats.ll_type == SET_COMPRESSED as u32 {
+            stats.last_count_size = count_size;
+        }
+        written += count_size;
+    }
+    /* build CTable for Offsets */
+    {
+        let mut max = MAX_OFF as c_uint;
+        let most_frequent = unsafe {
+            HIST_countFast_wksp(
+                count_workspace,
+                &mut max,
+                store.ofCode.cast::<c_void>(),
+                nb_seq,
+                entropy_workspace,
+                entropy_wksp_size,
+            )
+        }; /* can't fail */
+        /* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */
+        let default_policy = if max <= DEFAULT_MAX_OFF as c_uint {
+            ZSTD_DEFAULT_ALLOWED
+        } else {
+            ZSTD_DEFAULT_DISALLOWED
+        };
+        unsafe { (*next_entropy).offcode_repeatMode = (*prev_entropy).offcode_repeatMode };
+        stats.off_type = unsafe {
+            ZSTD_selectEncodingType(
+                ptr::addr_of_mut!((*next_entropy).offcode_repeatMode),
+                count_workspace,
+                max,
+                most_frequent,
+                nb_seq,
+                OFF_FSE_LOG as c_uint,
+                ptr::addr_of!((*prev_entropy).offcodeCTable).cast::<u32>(),
+                OF_DEFAULT_NORM.as_ptr(),
+                OF_DEFAULT_NORM_LOG,
+                default_policy,
+                strategy,
+            )
+        } as u32;
+        let count_size = unsafe {
+            ZSTD_buildCTable(
+                dst.add(written).cast::<c_void>(),
+                dst_capacity - written,
+                ptr::addr_of_mut!((*next_entropy).offcodeCTable).cast::<u32>(),
+                OFF_FSE_LOG as u32,
+                stats.off_type as c_int,
+                count_workspace,
+                max,
+                store.ofCode,
+                nb_seq,
+                OF_DEFAULT_NORM.as_ptr(),
+                OF_DEFAULT_NORM_LOG,
+                DEFAULT_MAX_OFF as u32,
+                ptr::addr_of!((*prev_entropy).offcodeCTable).cast::<u32>(),
+                size_of::<[u32; OFF_CTABLE_SIZE]>(),
+                entropy_workspace,
+                entropy_wksp_size,
+            )
+        };
+        if ERR_isError(count_size) {
+            stats.size = count_size;
+            return stats;
+        }
+        if stats.off_type == SET_COMPRESSED as u32 {
+            stats.last_count_size = count_size;
+        }
+        written += count_size;
+    }
+    /* build CTable for MatchLengths */
+    {
+        let mut max = MAX_ML as c_uint;
+        let most_frequent = unsafe {
+            HIST_countFast_wksp(
+                count_workspace,
+                &mut max,
+                store.mlCode.cast::<c_void>(),
+                nb_seq,
+                entropy_workspace,
+                entropy_wksp_size,
+            )
+        }; /* can't fail */
+        unsafe { (*next_entropy).matchlength_repeatMode = (*prev_entropy).matchlength_repeatMode };
+        stats.ml_type = unsafe {
+            ZSTD_selectEncodingType(
+                ptr::addr_of_mut!((*next_entropy).matchlength_repeatMode),
+                count_workspace,
+                max,
+                most_frequent,
+                nb_seq,
+                ML_FSE_LOG as c_uint,
+                ptr::addr_of!((*prev_entropy).matchlengthCTable).cast::<u32>(),
+                ML_DEFAULT_NORM.as_ptr(),
+                ML_DEFAULT_NORM_LOG,
+                ZSTD_DEFAULT_ALLOWED,
+                strategy,
+            )
+        } as u32;
+        let count_size = unsafe {
+            ZSTD_buildCTable(
+                dst.add(written).cast::<c_void>(),
+                dst_capacity - written,
+                ptr::addr_of_mut!((*next_entropy).matchlengthCTable).cast::<u32>(),
+                ML_FSE_LOG as u32,
+                stats.ml_type as c_int,
+                count_workspace,
+                max,
+                store.mlCode,
+                nb_seq,
+                ML_DEFAULT_NORM.as_ptr(),
+                ML_DEFAULT_NORM_LOG,
+                MAX_ML as u32,
+                ptr::addr_of!((*prev_entropy).matchlengthCTable).cast::<u32>(),
+                size_of::<[u32; ML_CTABLE_SIZE]>(),
+                entropy_workspace,
+                entropy_wksp_size,
+            )
+        };
+        if ERR_isError(count_size) {
+            stats.size = count_size;
+            return stats;
+        }
+        if stats.ml_type == SET_COMPRESSED as u32 {
+            stats.last_count_size = count_size;
+        }
+        written += count_size;
+    }
+    stats.size = written;
+    stats
+}
+
+/// C's `ZSTD_entropyCompressSeqStore_internal()`: compresses literals and
+/// sequences into one compressed-block body.
+#[allow(clippy::too_many_arguments)]
+unsafe fn entropy_compress_seq_store_internal(
+    dst: *mut c_void,
+    dst_capacity: usize,
+    literals: *const c_void,
+    lit_size: usize,
+    seq_store: *const SeqStore_t,
+    prev_entropy: *const ZSTD_entropyCTables_t,
+    next_entropy: *mut ZSTD_entropyCTables_t,
+    strategy: c_int,
+    disable_literal_compression: c_int,
+    entropy_workspace: *mut c_void,
+    entropy_wksp_size: usize,
+    bmi2: c_int,
+) -> usize {
+    let count = entropy_workspace.cast::<c_uint>();
+    let entropy_workspace = unsafe { count.add(MAX_SEQ + 1) }.cast::<c_void>();
+    let entropy_wksp_size = entropy_wksp_size.wrapping_sub((MAX_SEQ + 1) * size_of::<c_uint>());
+    let store = unsafe { &*seq_store };
+    let sequences = store.sequencesStart;
+    let nb_seq = unsafe { store.sequences.offset_from(sequences) } as usize;
+    let ostart = dst.cast::<u8>();
+    let mut written = 0usize;
+    let last_count_size;
+    let long_offsets;
+
+    /* Compress literals */
+    {
+        /* Base suspicion of uncompressibility on ratio of literals to sequences */
+        let suspect_uncompressible =
+            c_int::from(nb_seq == 0 || lit_size / nb_seq >= SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO);
+        let c_size = unsafe {
+            ZSTD_compressLiterals(
+                dst,
+                dst_capacity,
+                literals,
+                lit_size,
+                entropy_workspace,
+                entropy_wksp_size,
+                ptr::addr_of!((*prev_entropy).huf),
+                ptr::addr_of_mut!((*next_entropy).huf),
+                strategy,
+                disable_literal_compression,
+                suspect_uncompressible,
+                bmi2,
+            )
+        };
+        if ERR_isError(c_size) {
+            return c_size;
+        }
+        debug_assert!(c_size <= dst_capacity);
+        written += c_size;
+    }
+
+    /* Sequences Header */
+    if (dst_capacity as isize).wrapping_sub(written as isize) < 3 /* max nbSeq Size */ + 1
+    /* seqHead */
+    {
+        return ERROR(ZstdErrorCode::DstSizeTooSmall);
+    }
+    unsafe {
+        if nb_seq < 128 {
+            *ostart.add(written) = nb_seq as u8;
+            written += 1;
+        } else if nb_seq < LONGNBSEQ as usize {
+            *ostart.add(written) = ((nb_seq >> 8) + 0x80) as u8;
+            *ostart.add(written + 1) = nb_seq as u8;
+            written += 2;
+        } else {
+            *ostart.add(written) = 0xFF;
+            MEM_writeLE16(
+                ostart.add(written + 1).cast::<c_void>(),
+                (nb_seq - LONGNBSEQ as usize) as u16,
+            );
+            written += 3;
+        }
+    }
+    if nb_seq == 0 {
+        /* Copy the old tables over as if we repeated them */
+        unsafe {
+            copy_fse_tables(
+                ptr::addr_of_mut!((*next_entropy).fse),
+                ptr::addr_of!((*prev_entropy).fse),
+            )
+        };
+        return written;
+    }
+    {
+        let seq_head = written;
+        written += 1;
+        /* build stats for sequences */
+        let stats = unsafe {
+            build_sequences_statistics(
+                seq_store,
+                nb_seq,
+                ptr::addr_of!((*prev_entropy).fse),
+                ptr::addr_of_mut!((*next_entropy).fse),
+                ostart.add(written),
+                dst_capacity - written,
+                strategy,
+                count,
+                entropy_workspace,
+                entropy_wksp_size,
+            )
+        };
+        if ERR_isError(stats.size) {
+            return stats.size;
+        }
+        unsafe {
+            *ostart.add(seq_head) =
+                ((stats.ll_type << 6) + (stats.off_type << 4) + (stats.ml_type << 2)) as u8;
+        }
+        last_count_size = stats.last_count_size;
+        written += stats.size;
+        long_offsets = stats.long_offsets;
+    }
+
+    {
+        let bitstream_size = unsafe {
+            ZSTD_encodeSequences(
+                ostart.add(written).cast::<c_void>(),
+                dst_capacity - written,
+                ptr::addr_of!((*next_entropy).fse.matchlengthCTable).cast::<u32>(),
+                store.mlCode,
+                ptr::addr_of!((*next_entropy).fse.offcodeCTable).cast::<u32>(),
+                store.ofCode,
+                ptr::addr_of!((*next_entropy).fse.litlengthCTable).cast::<u32>(),
+                store.llCode,
+                sequences,
+                nb_seq,
+                long_offsets,
+                bmi2,
+            )
+        };
+        if ERR_isError(bitstream_size) {
+            return bitstream_size;
+        }
+        written += bitstream_size;
+        /* zstd versions <= 1.3.4 mistakenly report corruption when
+         * FSE_readNCount() receives a buffer < 4 bytes.
+         * Fixed by https://github.com/facebook/zstd/pull/1146.
+         * This can happen when the last set_compressed table present is 2
+         * bytes and the bitstream is only one byte.
+         * In this exceedingly rare case, we will simply emit an uncompressed
+         * block, since it isn't worth optimizing.
+         */
+        if last_count_size != 0 && last_count_size + bitstream_size < 4 {
+            /* last_count_size >= 2 && bitstream_size > 0 ==> last_count_size == 3 */
+            debug_assert!(last_count_size + bitstream_size == 3);
+            return 0;
+        }
+    }
+
+    written
+}
+
+/// C's `ZSTD_entropyCompressSeqStore_wExtLitBuffer()`: adds the
+/// incompressibility fallbacks around the internal entropy pass.
+#[allow(clippy::too_many_arguments)]
+unsafe fn entropy_compress_seq_store_w_ext_lit_buffer(
+    dst: *mut c_void,
+    dst_capacity: usize,
+    literals: *const c_void,
+    lit_size: usize,
+    block_size: usize,
+    seq_store: *const SeqStore_t,
+    prev_entropy: *const ZSTD_entropyCTables_t,
+    next_entropy: *mut ZSTD_entropyCTables_t,
+    strategy: c_int,
+    disable_literal_compression: c_int,
+    entropy_workspace: *mut c_void,
+    entropy_wksp_size: usize,
+    bmi2: c_int,
+) -> usize {
+    let c_size = unsafe {
+        entropy_compress_seq_store_internal(
+            dst,
+            dst_capacity,
+            literals,
+            lit_size,
+            seq_store,
+            prev_entropy,
+            next_entropy,
+            strategy,
+            disable_literal_compression,
+            entropy_workspace,
+            entropy_wksp_size,
+            bmi2,
+        )
+    };
+    if c_size == 0 {
+        return 0;
+    }
+    /* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block.
+     * Since we ran out of space, block must be not compressible, so fall back to raw uncompressed block.
+     */
+    if c_size == ERROR(ZstdErrorCode::DstSizeTooSmall) && block_size <= dst_capacity {
+        return 0; /* block not compressed */
+    }
+    if ERR_isError(c_size) {
+        return c_size;
+    }
+
+    /* Check compressibility */
+    let max_c_size = block_size.wrapping_sub(min_gain(block_size, strategy));
+    if c_size >= max_c_size {
+        return 0; /* block not compressed */
+    }
+    c_size
+}
+
+/// C ABI wrapper for the external-literal-buffer entropy pass; the C shim
+/// keeps the `ZSTD_entropyCompressSeqStore_internal()` name and extracts the
+/// two `ZSTD_CCtx_params` scalars.
+#[allow(clippy::too_many_arguments)]
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_rust_entropyCompressSeqStore_internal(
+    dst: *mut c_void,
+    dst_capacity: usize,
+    literals: *const c_void,
+    lit_size: usize,
+    seq_store: *const SeqStore_t,
+    prev_entropy: *const ZSTD_entropyCTables_t,
+    next_entropy: *mut ZSTD_entropyCTables_t,
+    strategy: c_int,
+    disable_literal_compression: c_int,
+    entropy_workspace: *mut c_void,
+    entropy_wksp_size: usize,
+    bmi2: c_int,
+) -> usize {
+    unsafe {
+        entropy_compress_seq_store_internal(
+            dst,
+            dst_capacity,
+            literals,
+            lit_size,
+            seq_store,
+            prev_entropy,
+            next_entropy,
+            strategy,
+            disable_literal_compression,
+            entropy_workspace,
+            entropy_wksp_size,
+            bmi2,
+        )
+    }
+}
+
+/// C ABI implementation behind the `ZSTD_entropyCompressSeqStore()` shim.
+#[allow(clippy::too_many_arguments)]
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_rust_entropyCompressSeqStore(
+    seq_store: *const SeqStore_t,
+    prev_entropy: *const ZSTD_entropyCTables_t,
+    next_entropy: *mut ZSTD_entropyCTables_t,
+    strategy: c_int,
+    disable_literal_compression: c_int,
+    dst: *mut c_void,
+    dst_capacity: usize,
+    src_size: usize,
+    entropy_workspace: *mut c_void,
+    entropy_wksp_size: usize,
+    bmi2: c_int,
+) -> usize {
+    let store = unsafe { &*seq_store };
+    let lit_size = unsafe { store.lit.offset_from(store.litStart) } as usize;
+    unsafe {
+        entropy_compress_seq_store_w_ext_lit_buffer(
+            dst,
+            dst_capacity,
+            store.litStart.cast::<c_void>(),
+            lit_size,
+            src_size,
+            seq_store,
+            prev_entropy,
+            next_entropy,
+            strategy,
+            disable_literal_compression,
+            entropy_workspace,
+            entropy_wksp_size,
+            bmi2,
+        )
+    }
+}
+
+/// C's `ZSTD_buildBlockEntropyStats_literals()`.
+///
+/// Stores the literals block type and Huffman description table into
+/// `huf_metadata` and returns the description size, or an error code.
+#[allow(clippy::too_many_arguments)]
+unsafe fn build_block_entropy_stats_literals(
+    src: *const c_void,
+    src_size: usize,
+    prev_huf: *const ZSTD_hufCTables_t,
+    next_huf: *mut ZSTD_hufCTables_t,
+    huf_metadata: *mut ZSTD_hufCTablesMetadata_t,
+    literals_compression_is_disabled: c_int,
+    workspace: *mut c_void,
+    wksp_size: usize,
+    huf_flags: c_int,
+) -> usize {
+    let count_wksp = workspace.cast::<c_uint>();
+    let count_wksp_size = (HUF_SYMBOLVALUE_MAX as usize + 1) * size_of::<c_uint>();
+    let node_wksp = unsafe { workspace.cast::<u8>().add(count_wksp_size) }.cast::<c_void>();
+    let node_wksp_size = wksp_size.wrapping_sub(count_wksp_size);
+    let mut max_symbol_value = HUF_SYMBOLVALUE_MAX;
+    let mut huff_log = LIT_HUF_LOG;
+    let mut repeat = unsafe { (*prev_huf).repeatMode };
+
+    /* Prepare nextEntropy assuming reusing the existing table */
+    unsafe { copy_huf_tables(next_huf, prev_huf) };
+
+    if literals_compression_is_disabled != 0 {
+        unsafe { (*huf_metadata).hType = SET_BASIC };
+        return 0;
+    }
+
+    /* small ? don't even attempt compression (speed opt) */
+    {
+        let min_lit_size = if repeat == HUF_REPEAT_VALID {
+            6
+        } else {
+            COMPRESS_LITERALS_SIZE_MIN
+        };
+        if src_size <= min_lit_size {
+            unsafe { (*huf_metadata).hType = SET_BASIC };
+            return 0;
+        }
+    }
+
+    /* Scan input and build symbol stats */
+    {
+        let largest = unsafe {
+            HIST_count_wksp(
+                count_wksp,
+                &mut max_symbol_value,
+                src,
+                src_size,
+                workspace,
+                wksp_size,
+            )
+        };
+        if ERR_isError(largest) {
+            return largest;
+        }
+        if largest == src_size {
+            /* only one literal symbol */
+            unsafe { (*huf_metadata).hType = SET_RLE };
+            return 0;
+        }
+        if largest <= (src_size >> 7) + 4 {
+            /* heuristic: likely not compressible */
+            unsafe { (*huf_metadata).hType = SET_BASIC };
+            return 0;
+        }
+    }
+
+    /* Validate the previous Huffman table */
+    if repeat == HUF_REPEAT_CHECK
+        && unsafe {
+            HUF_validateCTable(
+                ptr::addr_of!((*prev_huf).CTable).cast::<usize>(),
+                count_wksp,
+                max_symbol_value,
+            )
+        } == 0
+    {
+        repeat = HUF_REPEAT_NONE;
+    }
+
+    /* Build Huffman Tree */
+    unsafe {
+        ptr::write_bytes(
+            ptr::addr_of_mut!((*next_huf).CTable).cast::<u8>(),
+            0,
+            size_of_val(&(*next_huf).CTable),
+        );
+    }
+    huff_log = unsafe {
+        HUF_optimalTableLog(
+            huff_log,
+            src_size,
+            max_symbol_value,
+            node_wksp,
+            node_wksp_size,
+            ptr::addr_of_mut!((*next_huf).CTable).cast::<usize>(),
+            count_wksp,
+            huf_flags,
+        )
+    };
+    debug_assert!(huff_log <= LIT_HUF_LOG);
+    {
+        let max_bits = unsafe {
+            HUF_buildCTable_wksp(
+                ptr::addr_of_mut!((*next_huf).CTable).cast::<usize>(),
+                count_wksp,
+                max_symbol_value,
+                huff_log,
+                node_wksp,
+                node_wksp_size,
+            )
+        };
+        if ERR_isError(max_bits) {
+            return max_bits;
+        }
+        huff_log = max_bits as c_uint;
+    }
+    {
+        /* Build and write the CTable */
+        let new_c_size = unsafe {
+            HUF_estimateCompressedSize(
+                ptr::addr_of!((*next_huf).CTable).cast::<usize>(),
+                count_wksp,
+                max_symbol_value,
+            )
+        };
+        let h_size = unsafe {
+            HUF_writeCTable_wksp(
+                ptr::addr_of_mut!((*huf_metadata).hufDesBuffer).cast::<c_void>(),
+                size_of::<[u8; ZSTD_MAX_HUF_HEADER_SIZE]>(),
+                ptr::addr_of!((*next_huf).CTable).cast::<usize>(),
+                max_symbol_value,
+                huff_log,
+                node_wksp,
+                node_wksp_size,
+            )
+        };
+        /* Check against repeating the previous CTable */
+        if repeat != HUF_REPEAT_NONE {
+            let old_c_size = unsafe {
+                HUF_estimateCompressedSize(
+                    ptr::addr_of!((*prev_huf).CTable).cast::<usize>(),
+                    count_wksp,
+                    max_symbol_value,
+                )
+            };
+            if old_c_size < src_size
+                && (old_c_size <= h_size.wrapping_add(new_c_size)
+                    || h_size.wrapping_add(12) >= src_size)
+            {
+                unsafe {
+                    copy_huf_tables(next_huf, prev_huf);
+                    (*huf_metadata).hType = SET_REPEAT;
+                }
+                return 0;
+            }
+        }
+        if new_c_size.wrapping_add(h_size) >= src_size {
+            unsafe {
+                copy_huf_tables(next_huf, prev_huf);
+                (*huf_metadata).hType = SET_BASIC;
+            }
+            return 0;
+        }
+        unsafe {
+            (*huf_metadata).hType = SET_COMPRESSED;
+            (*next_huf).repeatMode = HUF_REPEAT_CHECK;
+        }
+        h_size
+    }
+}
+
+/// C's `ZSTD_buildDummySequencesStatistics()`: marks every encoding type as
+/// basic and resets the FSE repeat modes.
+unsafe fn build_dummy_sequences_statistics(
+    next_entropy: *mut ZSTD_fseCTables_t,
+) -> SymbolEncodingTypeStats {
+    unsafe {
+        (*next_entropy).litlength_repeatMode = FSE_REPEAT_NONE;
+        (*next_entropy).offcode_repeatMode = FSE_REPEAT_NONE;
+        (*next_entropy).matchlength_repeatMode = FSE_REPEAT_NONE;
+    }
+    SymbolEncodingTypeStats {
+        ll_type: SET_BASIC as u32,
+        off_type: SET_BASIC as u32,
+        ml_type: SET_BASIC as u32,
+        size: 0,
+        last_count_size: 0,
+        long_offsets: 0,
+    }
+}
+
+/// C's `ZSTD_buildBlockEntropyStats_sequences()`.
+#[allow(clippy::too_many_arguments)]
+unsafe fn build_block_entropy_stats_sequences(
+    seq_store: *const SeqStore_t,
+    prev_entropy: *const ZSTD_fseCTables_t,
+    next_entropy: *mut ZSTD_fseCTables_t,
+    strategy: c_int,
+    fse_metadata: *mut ZSTD_fseCTablesMetadata_t,
+    workspace: *mut c_void,
+    wksp_size: usize,
+) -> usize {
+    let store = unsafe { &*seq_store };
+    let nb_seq = unsafe { store.sequences.offset_from(store.sequencesStart) } as usize;
+    let count_workspace = workspace.cast::<c_uint>();
+    let entropy_workspace = unsafe { count_workspace.add(MAX_SEQ + 1) }.cast::<c_void>();
+    let entropy_workspace_size = wksp_size.wrapping_sub((MAX_SEQ + 1) * size_of::<c_uint>());
+
+    let stats = if nb_seq != 0 {
+        unsafe {
+            build_sequences_statistics(
+                seq_store,
+                nb_seq,
+                prev_entropy,
+                next_entropy,
+                ptr::addr_of_mut!((*fse_metadata).fseTablesBuffer).cast::<u8>(),
+                ZSTD_MAX_FSE_HEADERS_SIZE,
+                strategy,
+                count_workspace,
+                entropy_workspace,
+                entropy_workspace_size,
+            )
+        }
+    } else {
+        unsafe { build_dummy_sequences_statistics(next_entropy) }
+    };
+    if ERR_isError(stats.size) {
+        return stats.size;
+    }
+    unsafe {
+        (*fse_metadata).llType = stats.ll_type as c_int;
+        (*fse_metadata).ofType = stats.off_type as c_int;
+        (*fse_metadata).mlType = stats.ml_type as c_int;
+        (*fse_metadata).lastCountSize = stats.last_count_size;
+    }
+    stats.size
+}
+
+/// C's `ZSTD_buildBlockEntropyStats()`: builds entropy statistics for one
+/// block.  Requires an `ENTROPY_WORKSPACE_SIZE` workspace.
+#[allow(clippy::too_many_arguments)]
+pub(crate) unsafe fn build_block_entropy_stats(
+    seq_store: *const SeqStore_t,
+    prev_entropy: *const ZSTD_entropyCTables_t,
+    next_entropy: *mut ZSTD_entropyCTables_t,
+    strategy: c_int,
+    disable_literal_compression: c_int,
+    entropy_metadata: *mut ZSTD_entropyCTablesMetadata_t,
+    workspace: *mut c_void,
+    wksp_size: usize,
+) -> usize {
+    let store = unsafe { &*seq_store };
+    let lit_size = unsafe { store.lit.offset_from(store.litStart) } as usize;
+    let huf_flags = if strategy >= HUF_OPTIMAL_DEPTH_THRESHOLD {
+        HUF_FLAGS_OPTIMAL_DEPTH
+    } else {
+        0
+    };
+
+    let huf_des_size = unsafe {
+        build_block_entropy_stats_literals(
+            store.litStart.cast::<c_void>(),
+            lit_size,
+            ptr::addr_of!((*prev_entropy).huf),
+            ptr::addr_of_mut!((*next_entropy).huf),
+            ptr::addr_of_mut!((*entropy_metadata).hufMetadata),
+            disable_literal_compression,
+            workspace,
+            wksp_size,
+            huf_flags,
+        )
+    };
+    unsafe { (*entropy_metadata).hufMetadata.hufDesSize = huf_des_size };
+    if ERR_isError(huf_des_size) {
+        return huf_des_size;
+    }
+
+    let fse_tables_size = unsafe {
+        build_block_entropy_stats_sequences(
+            seq_store,
+            ptr::addr_of!((*prev_entropy).fse),
+            ptr::addr_of_mut!((*next_entropy).fse),
+            strategy,
+            ptr::addr_of_mut!((*entropy_metadata).fseMetadata),
+            workspace,
+            wksp_size,
+        )
+    };
+    unsafe { (*entropy_metadata).fseMetadata.fseTablesSize = fse_tables_size };
+    if ERR_isError(fse_tables_size) {
+        return fse_tables_size;
+    }
+    0
+}
+
+/// C ABI wrapper behind the `ZSTD_buildBlockEntropyStats()` shim, which is
+/// still exported from C for the block splitter's size estimation.
+#[allow(clippy::too_many_arguments)]
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_rust_buildBlockEntropyStats(
+    seq_store: *const SeqStore_t,
+    prev_entropy: *const ZSTD_entropyCTables_t,
+    next_entropy: *mut ZSTD_entropyCTables_t,
+    strategy: c_int,
+    disable_literal_compression: c_int,
+    entropy_metadata: *mut ZSTD_entropyCTablesMetadata_t,
+    workspace: *mut c_void,
+    wksp_size: usize,
+) -> usize {
+    unsafe {
+        build_block_entropy_stats(
+            seq_store,
+            prev_entropy,
+            next_entropy,
+            strategy,
+            disable_literal_compression,
+            entropy_metadata,
+            workspace,
+            wksp_size,
+        )
+    }
+}
+
+/// C's `ZSTD_copyBlockSequences()`: exports a block's sequences in the public
+/// `ZSTD_Sequence` format, appending the last-literals block delimiter.
+#[no_mangle]
+pub unsafe extern "C" fn ZSTD_rust_copyBlockSequences(
+    seq_collector: *mut SeqCollector,
+    seq_store: *const SeqStore_t,
+    prev_repcodes: *const u32,
+) -> usize {
+    let collector = unsafe { &mut *seq_collector };
+    let store = unsafe { &*seq_store };
+    let in_seqs = store.sequencesStart;
+    let nb_in_sequences = unsafe { store.sequences.offset_from(in_seqs) } as usize;
+    let nb_in_literals = unsafe { store.lit.offset_from(store.litStart) } as usize;
+    let out_seqs = if collector.seqIndex == 0 {
+        collector.seqStart
+    } else {
+        unsafe { collector.seqStart.add(collector.seqIndex) }
+    };
+    let nb_out_sequences = nb_in_sequences + 1;
+    let mut nb_out_literals = 0usize;
+
+    /* Bounds check that we have enough space for every input sequence
+     * and the block delimiter
+     */
+    debug_assert!(collector.seqIndex <= collector.maxSequences);
+    if nb_out_sequences > collector.maxSequences.wrapping_sub(collector.seqIndex) {
+        return ERROR(ZstdErrorCode::DstSizeTooSmall);
+    }
+
+    let mut repcodes = [0u32; ZSTD_REP_NUM];
+    unsafe { ptr::copy_nonoverlapping(prev_repcodes, repcodes.as_mut_ptr(), ZSTD_REP_NUM) };
+    for index in 0..nb_in_sequences {
+        let in_seq = unsafe { in_seqs.add(index).read() };
+        let out = unsafe { out_seqs.add(index) };
+        let mut lit_length = in_seq.litLength as u32;
+        let mut match_length = in_seq.mlBase as u32 + MINMATCH as u32;
+        let mut rep = 0u32;
+
+        /* Handle the possible single length >= 64K
+         * There can only be one because we add MINMATCH to every match length,
+         * and blocks are at most 128K.
+         */
+        if index == store.longLengthPos as usize {
+            if store.longLengthType == ZSTD_LLT_LITERAL_LENGTH {
+                lit_length += 0x10000;
+            } else if store.longLengthType == ZSTD_LLT_MATCH_LENGTH {
+                match_length += 0x10000;
+            }
+        }
+
+        /* Determine the raw offset given the offBase, which may be a repcode. */
+        let raw_offset = if (1..=ZSTD_REP_NUM as u32).contains(&in_seq.offBase) {
+            let repcode = in_seq.offBase;
+            debug_assert!(repcode > 0);
+            rep = repcode;
+            if lit_length != 0 {
+                repcodes[repcode as usize - 1]
+            } else if repcode == 3 {
+                debug_assert!(repcodes[0] > 1);
+                repcodes[0].wrapping_sub(1)
+            } else {
+                repcodes[repcode as usize]
+            }
+        } else {
+            in_seq.offBase.wrapping_sub(ZSTD_REP_NUM as u32)
+        };
+        unsafe {
+            (*out).litLength = lit_length;
+            (*out).matchLength = match_length;
+            (*out).offset = raw_offset;
+            (*out).rep = rep;
+        }
+
+        /* Update repcode history for the sequence */
+        update_rep(&mut repcodes, in_seq.offBase, in_seq.litLength == 0);
+
+        nb_out_literals += lit_length as usize;
+    }
+    /* Insert last literals (if any exist) in the block as a sequence with ml == off == 0.
+     * If there are no last literals, then we'll emit (of: 0, ml: 0, ll: 0), which is a marker
+     * for the block boundary, according to the API.
+     */
+    debug_assert!(nb_in_literals >= nb_out_literals);
+    {
+        let last_ll_size = nb_in_literals.wrapping_sub(nb_out_literals);
+        unsafe {
+            let last = out_seqs.add(nb_in_sequences);
+            (*last).litLength = last_ll_size as u32;
+            (*last).matchLength = 0;
+            (*last).offset = 0;
+        }
+    }
+    collector.seqIndex += nb_out_sequences;
+    debug_assert!(collector.seqIndex <= collector.maxSequences);
+
+    0
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::mem::{align_of, offset_of};
+
+    const HUF_CTABLE_SIZE_ST: usize = HUF_SYMBOLVALUE_MAX as usize + 2;
+    const ENTROPY_WORKSPACE_SIZE: usize = (8 << 10) + 512 + (MAX_SEQ + 2) * size_of::<u32>();
+
+    fn empty_huf_tables(repeat: c_int) -> ZSTD_hufCTables_t {
+        ZSTD_hufCTables_t {
+            CTable: [0; HUF_CTABLE_SIZE_ST],
+            repeatMode: repeat,
+        }
+    }
+
+    fn empty_fse_tables(repeat: c_int) -> ZSTD_fseCTables_t {
+        ZSTD_fseCTables_t {
+            offcodeCTable: [0; OFF_CTABLE_SIZE],
+            matchlengthCTable: [0; ML_CTABLE_SIZE],
+            litlengthCTable: [0; LL_CTABLE_SIZE],
+            offcode_repeatMode: repeat,
+            matchlength_repeatMode: repeat,
+            litlength_repeatMode: repeat,
+        }
+    }
+
+    struct TestSeqStore {
+        sequences: Vec<SeqDef>,
+        literals: Vec<u8>,
+        ll_codes: Vec<u8>,
+        ml_codes: Vec<u8>,
+        of_codes: Vec<u8>,
+    }
+
+    impl TestSeqStore {
+        fn new(sequences: Vec<SeqDef>, literals: Vec<u8>) -> Self {
+            let nb_seq = sequences.len();
+            TestSeqStore {
+                sequences,
+                literals,
+                ll_codes: vec![0; nb_seq],
+                ml_codes: vec![0; nb_seq],
+                of_codes: vec![0; nb_seq],
+            }
+        }
+
+        fn seq_store(&mut self) -> SeqStore_t {
+            let nb_seq = self.sequences.len();
+            let nb_lit = self.literals.len();
+            SeqStore_t {
+                sequencesStart: self.sequences.as_mut_ptr(),
+                sequences: unsafe { self.sequences.as_mut_ptr().add(nb_seq) },
+                litStart: self.literals.as_mut_ptr(),
+                lit: unsafe { self.literals.as_mut_ptr().add(nb_lit) },
+                llCode: self.ll_codes.as_mut_ptr(),
+                mlCode: self.ml_codes.as_mut_ptr(),
+                ofCode: self.of_codes.as_mut_ptr(),
+                maxNbSeq: nb_seq,
+                maxNbLit: nb_lit,
+                longLengthType: 0,
+                longLengthPos: 0,
+            }
+        }
+    }
+
+    #[test]
+    fn c_leaf_layouts_match_supported_abis() {
+        assert_eq!(size_of::<SeqDef>(), 8);
+        assert_eq!(align_of::<SeqDef>(), align_of::<u32>());
+        assert_eq!(offset_of!(SeqStore_t, sequencesStart), 0);
+        assert_eq!(
+            offset_of!(SeqStore_t, longLengthPos),
+            9 * size_of::<usize>() + 4
+        );
+        assert_eq!(size_of::<SeqStore_t>(), 9 * size_of::<usize>() + 8);
+        assert_eq!(size_of::<ZSTD_fseCTables_t>(), 3552);
+        assert_eq!(offset_of!(ZSTD_compressedBlockState_t, entropy), 0);
+        assert_eq!(
+            offset_of!(ZSTD_compressedBlockState_t, rep),
+            size_of::<ZSTD_entropyCTables_t>()
+        );
+        assert_eq!(size_of::<ZSTD_Sequence>(), 16);
+        assert_eq!(offset_of!(SeqCollector, seqStart), size_of::<usize>());
+        assert_eq!(offset_of!(SeqCollector, seqIndex), 2 * size_of::<usize>());
+        assert_eq!(size_of::<SeqCollector>(), 4 * size_of::<usize>());
+        if size_of::<usize>() == 8 {
+            assert_eq!(size_of::<ZSTD_hufCTablesMetadata_t>(), 144);
+            assert_eq!(size_of::<ZSTD_fseCTablesMetadata_t>(), 168);
+            assert_eq!(size_of::<ZSTD_entropyCTablesMetadata_t>(), 312);
+            assert_eq!(size_of::<ZSTD_entropyCTables_t>(), 5616);
+            assert_eq!(size_of::<ZSTD_compressedBlockState_t>(), 5632);
+        } else {
+            assert_eq!(size_of::<ZSTD_hufCTablesMetadata_t>(), 136);
+            assert_eq!(size_of::<ZSTD_fseCTablesMetadata_t>(), 156);
+            assert_eq!(size_of::<ZSTD_entropyCTablesMetadata_t>(), 292);
+            assert_eq!(size_of::<ZSTD_entropyCTables_t>(), 4584);
+            assert_eq!(size_of::<ZSTD_compressedBlockState_t>(), 4596);
+        }
+    }
+
+    #[test]
+    fn repcode_updates_match_the_c_sum_type_rules() {
+        let mut reps = [1, 4, 8];
+        update_rep(&mut reps, 10, false);
+        assert_eq!(reps, [7, 1, 4]);
+        update_rep(&mut reps, 1, true);
+        assert_eq!(reps, [1, 7, 4]);
+        update_rep(&mut reps, 2, false);
+        assert_eq!(reps, [7, 1, 4]);
+        update_rep(&mut reps, 3, false);
+        assert_eq!(reps, [4, 7, 1]);
+    }
+
+    #[test]
+    fn seq_to_codes_matches_the_reference_tables() {
+        let mut store = TestSeqStore::new(
+            vec![
+                SeqDef {
+                    offBase: 4,
+                    litLength: 0,
+                    mlBase: 0,
+                },
+                SeqDef {
+                    offBase: 1,
+                    litLength: 63,
+                    mlBase: 127,
+                },
+                SeqDef {
+                    offBase: 1 << 20,
+                    litLength: 64,
+                    mlBase: 128,
+                },
+            ],
+            vec![0; 127],
+        );
+        let seq_store = store.seq_store();
+        let long_offsets = unsafe { ZSTD_seqToCodes(&seq_store) };
+        assert_eq!(long_offsets, 0);
+        assert_eq!(store.ll_codes, [0, 24, 25]);
+        assert_eq!(store.ml_codes, [0, 42, 43]);
+        assert_eq!(store.of_codes, [2, 0, 20]);
+    }
+
+    #[test]
+    fn rle_sequences_produce_one_byte_table_headers() {
+        // Five identical sequences select set_rle for all three symbol kinds;
+        // each table header is then exactly the one RLE symbol byte.
+        let mut store = TestSeqStore::new(
+            vec![
+                SeqDef {
+                    offBase: 8,
+                    litLength: 2,
+                    mlBase: 3,
+                };
+                5
+            ],
+            vec![b'x'; 10],
+        );
+        let seq_store = store.seq_store();
+        let prev = empty_fse_tables(FSE_REPEAT_NONE);
+        let mut next = empty_fse_tables(FSE_REPEAT_NONE);
+        let mut metadata =
+            unsafe { std::mem::MaybeUninit::<ZSTD_fseCTablesMetadata_t>::zeroed().assume_init() };
+        let mut workspace = vec![0u64; ENTROPY_WORKSPACE_SIZE / size_of::<u64>()];
+
+        let size = unsafe {
+            build_block_entropy_stats_sequences(
+                &seq_store,
+                &prev,
+                &mut next,
+                1,
+                &mut metadata,
+                workspace.as_mut_ptr().cast::<c_void>(),
+                ENTROPY_WORKSPACE_SIZE,
+            )
+        };
+        assert_eq!(size, 3);
+        assert_eq!(metadata.llType, SET_RLE);
+        assert_eq!(metadata.ofType, SET_RLE);
+        assert_eq!(metadata.mlType, SET_RLE);
+        assert_eq!(metadata.lastCountSize, 0);
+        assert_eq!(&metadata.fseTablesBuffer[..3], &[2, 3, 3]);
+        assert_eq!(next.litlength_repeatMode, FSE_REPEAT_NONE);
+        assert_eq!(next.offcode_repeatMode, FSE_REPEAT_NONE);
+        assert_eq!(next.matchlength_repeatMode, FSE_REPEAT_NONE);
+    }
+
+    #[test]
+    fn empty_seq_store_emits_raw_literals_and_repeats_tables() {
+        let mut store = TestSeqStore::new(Vec::new(), b"hello".to_vec());
+        let seq_store = store.seq_store();
+        let prev = ZSTD_entropyCTables_t {
+            huf: empty_huf_tables(HUF_REPEAT_NONE),
+            fse: empty_fse_tables(2),
+        };
+        let mut next = ZSTD_entropyCTables_t {
+            huf: empty_huf_tables(HUF_REPEAT_NONE),
+            fse: empty_fse_tables(FSE_REPEAT_NONE),
+        };
+        let mut workspace = vec![0u64; ENTROPY_WORKSPACE_SIZE / size_of::<u64>()];
+        let mut output = [0xA5u8; 32];
+
+        let size = unsafe {
+            ZSTD_rust_entropyCompressSeqStore_internal(
+                output.as_mut_ptr().cast::<c_void>(),
+                output.len(),
+                seq_store.litStart.cast::<c_void>(),
+                5,
+                &seq_store,
+                &prev,
+                &mut next,
+                1,
+                0,
+                workspace.as_mut_ptr().cast::<c_void>(),
+                ENTROPY_WORKSPACE_SIZE,
+                0,
+            )
+        };
+        // Raw literals header (5 << 3), five literal bytes, nbSeq == 0.
+        assert_eq!(size, 7);
+        assert_eq!(&output[..7], &[0x28, b'h', b'e', b'l', b'l', b'o', 0x00]);
+        // With no sequences, the previous FSE tables are copied unchanged.
+        assert_eq!(next.fse.offcode_repeatMode, 2);
+        assert_eq!(next.fse.matchlength_repeatMode, 2);
+        assert_eq!(next.fse.litlength_repeatMode, 2);
+    }
+
+    #[test]
+    fn literal_stats_pick_rle_and_compressed_types() {
+        let mut workspace = vec![0u64; ENTROPY_WORKSPACE_SIZE / size_of::<u64>()];
+        let prev = empty_huf_tables(HUF_REPEAT_NONE);
+        let mut next = empty_huf_tables(HUF_REPEAT_NONE);
+        let mut metadata =
+            unsafe { std::mem::MaybeUninit::<ZSTD_hufCTablesMetadata_t>::zeroed().assume_init() };
+
+        let rle = [7u8; 128];
+        let size = unsafe {
+            build_block_entropy_stats_literals(
+                rle.as_ptr().cast::<c_void>(),
+                rle.len(),
+                &prev,
+                &mut next,
+                &mut metadata,
+                0,
+                workspace.as_mut_ptr().cast::<c_void>(),
+                ENTROPY_WORKSPACE_SIZE,
+                0,
+            )
+        };
+        assert_eq!(size, 0);
+        assert_eq!(metadata.hType, SET_RLE);
+
+        let mut compressible = [0u8; 1024];
+        for (index, byte) in compressible.iter_mut().enumerate() {
+            *byte = (index % 4) as u8;
+        }
+        let size = unsafe {
+            build_block_entropy_stats_literals(
+                compressible.as_ptr().cast::<c_void>(),
+                compressible.len(),
+                &prev,
+                &mut next,
+                &mut metadata,
+                0,
+                workspace.as_mut_ptr().cast::<c_void>(),
+                ENTROPY_WORKSPACE_SIZE,
+                0,
+            )
+        };
+        assert!(!ERR_isError(size));
+        assert!(size > 0);
+        assert_eq!(metadata.hType, SET_COMPRESSED);
+        assert_eq!(metadata.hufDesSize, 0); // caller stores the returned size
+        assert_eq!(next.repeatMode, HUF_REPEAT_CHECK);
+    }
+
+    #[test]
+    fn copied_sequences_resolve_repcodes_and_append_the_delimiter() {
+        let mut store = TestSeqStore::new(
+            vec![
+                SeqDef {
+                    offBase: 3 + 100, // raw offset 100
+                    litLength: 4,
+                    mlBase: 5,
+                },
+                SeqDef {
+                    offBase: 1, // repcode 1 with literals: rep[0] == 100
+                    litLength: 2,
+                    mlBase: 7,
+                },
+                SeqDef {
+                    offBase: 3, // repcode 3 without literals: rep[0] - 1 == 99
+                    litLength: 0,
+                    mlBase: 9,
+                },
+            ],
+            vec![0; 10],
+        );
+        let seq_store = store.seq_store();
+        let mut out = [ZSTD_Sequence {
+            offset: 0xAA,
+            litLength: 0xAA,
+            matchLength: 0xAA,
+            rep: 0xAA,
+        }; 8];
+        let mut collector = SeqCollector {
+            collectSequences: 1,
+            seqStart: out.as_mut_ptr(),
+            seqIndex: 1,
+            maxSequences: 8,
+        };
+        let reps = [1u32, 4, 8];
+
+        let result =
+            unsafe { ZSTD_rust_copyBlockSequences(&mut collector, &seq_store, reps.as_ptr()) };
+        assert_eq!(result, 0);
+        assert_eq!(collector.seqIndex, 5);
+        let expect = [
+            (100, 4, 5 + 3, 0),
+            (100, 2, 7 + 3, 1),
+            (99, 0, 9 + 3, 3),
+            (0, 10 - 6, 0, 0xAA), // delimiter: last literals; rep untouched
+        ];
+        for (index, &(offset, lit, matched, rep)) in expect.iter().enumerate() {
+            assert_eq!(out[1 + index].offset, offset, "offset {index}");
+            assert_eq!(out[1 + index].litLength, lit, "litLength {index}");
+            assert_eq!(out[1 + index].matchLength, matched, "matchLength {index}");
+            assert_eq!(out[1 + index].rep, rep, "rep {index}");
+        }
+
+        collector.maxSequences = 5;
+        let result =
+            unsafe { ZSTD_rust_copyBlockSequences(&mut collector, &seq_store, reps.as_ptr()) };
+        assert_eq!(result, ERROR(ZstdErrorCode::DstSizeTooSmall));
+    }
+}

rust/src/zstd_compress_superblock.rs

@@ -6,13 +6,13 @@
 //! This is the Rust implementation of `zstd_compress_superblock.c`.  Its C
 //! entry-point shim only extracts fields from the opaque `ZSTD_CCtx`; all
 //! sequence partitioning, literal and sequence section writing, entropy
-//! fallback, and repcode repair remain here.  The leaf layouts below are
+//! fallback, and repcode repair remain here.  The C-shaped leaf layouts are
-//! intentionally kept C-shaped and checked for both supported pointer widths.
+//! shared with `zstd_compress_stats`, which also owns the block entropy
+//! statistics this module consumes.
 
 use crate::common::{
     LL_BITS, LL_DEFAULT_NORM, LL_DEFAULT_NORM_LOG, MAX_LL, MAX_ML, MAX_OFF, MINMATCH, ML_BITS,
     ML_DEFAULT_NORM, ML_DEFAULT_NORM_LOG, OF_DEFAULT_NORM, OF_DEFAULT_NORM_LOG,
-    ZSTD_MAX_FSE_HEADERS_SIZE, ZSTD_MAX_HUF_HEADER_SIZE,
 };
 use crate::errors::{ERR_isError, ZstdErrorCode, ERROR};
 use crate::hist::{HIST_countFast_wksp, HIST_count_wksp};
@@ -23,9 +23,17 @@ use crate::mem::{MEM_32bits, MEM_writeLE16, MEM_writeLE24, MEM_writeLE32};
 use crate::zstd_compress_literals::{
     ZSTD_compressRleLiteralsBlock, ZSTD_hufCTables_t, ZSTD_noCompressLiterals,
 };
+use crate::zstd_compress_sequences::{
+    SeqDef, ZSTD_crossEntropyCost, ZSTD_encodeSequences, ZSTD_fseBitCost,
+};
+use crate::zstd_compress_stats::{
+    build_block_entropy_stats, update_rep, SeqStore_t, ZSTD_compressedBlockState_t,
+    ZSTD_entropyCTablesMetadata_t, ZSTD_entropyCTables_t, ZSTD_fseCTablesMetadata_t,
+    ZSTD_fseCTables_t, ZSTD_hufCTablesMetadata_t,
+};
 use std::ffi::c_void;
 use std::mem::MaybeUninit;
-use std::os::raw::{c_int, c_short, c_uint};
+use std::os::raw::c_int;
 use std::ptr;
 
 const SET_BASIC: c_int = 0;
@@ -42,121 +50,6 @@ const LONG_NB_SEQ: usize = 0x7f00;
 const DEFAULT_MAX_OFF: u32 = 28;
 const BYTE_SCALE: usize = 256;
 
-const OFF_CTABLE_SIZE: usize = 1 + (1 << 7) + ((MAX_OFF + 1) * 2);
-const ML_CTABLE_SIZE: usize = 1 + (1 << 8) + ((MAX_ML + 1) * 2);
-const LL_CTABLE_SIZE: usize = 1 + (1 << 8) + ((MAX_LL + 1) * 2);
-
-/// ABI-compatible `SeqDef` from `zstd_compress_internal.h`.
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default)]
-struct SeqDef {
-    offBase: u32,
-    litLength: u16,
-    mlBase: u16,
-}
-
-/// ABI-compatible `SeqStore_t` leaf layout.
-///
-/// The C context itself remains opaque.  The C shim passes its `seqStore`
-/// member directly, so this small, stable hot-path structure is the only
-/// sequence storage representation crossing into Rust.
-#[repr(C)]
-struct SeqStore_t {
-    sequencesStart: *mut SeqDef,
-    sequences: *mut SeqDef,
-    litStart: *mut u8,
-    lit: *mut u8,
-    llCode: *mut u8,
-    mlCode: *mut u8,
-    ofCode: *mut u8,
-    maxNbSeq: usize,
-    maxNbLit: usize,
-    longLengthType: c_int,
-    longLengthPos: u32,
-}
-
-/// C's `ZSTD_fseCTables_t`.  The table element type is `FSE_CTable`, an
-/// `unsigned`, and the table lengths are the header macros expanded above.
-#[repr(C)]
-struct ZSTD_fseCTables_t {
-    offcodeCTable: [u32; OFF_CTABLE_SIZE],
-    matchlengthCTable: [u32; ML_CTABLE_SIZE],
-    litlengthCTable: [u32; LL_CTABLE_SIZE],
-    offcode_repeatMode: c_int,
-    matchlength_repeatMode: c_int,
-    litlength_repeatMode: c_int,
-}
-
-#[repr(C)]
-struct ZSTD_entropyCTables_t {
-    huf: ZSTD_hufCTables_t,
-    fse: ZSTD_fseCTables_t,
-}
-
-#[repr(C)]
-struct ZSTD_compressedBlockState_t {
-    entropy: ZSTD_entropyCTables_t,
-    rep: [u32; 3],
-}
-
-#[repr(C)]
-struct ZSTD_hufCTablesMetadata_t {
-    hType: c_int,
-    hufDesBuffer: [u8; ZSTD_MAX_HUF_HEADER_SIZE],
-    hufDesSize: usize,
-}
-
-#[repr(C)]
-struct ZSTD_fseCTablesMetadata_t {
-    llType: c_int,
-    ofType: c_int,
-    mlType: c_int,
-    fseTablesBuffer: [u8; ZSTD_MAX_FSE_HEADERS_SIZE],
-    fseTablesSize: usize,
-    lastCountSize: usize,
-}
-
-#[repr(C)]
-struct ZSTD_entropyCTablesMetadata_t {
-    hufMetadata: ZSTD_hufCTablesMetadata_t,
-    fseMetadata: ZSTD_fseCTablesMetadata_t,
-}
-
-unsafe extern "C" {
-    fn ZSTD_buildBlockEntropyStats(
-        seq_store: *const SeqStore_t,
-        prev_entropy: *const ZSTD_entropyCTables_t,
-        next_entropy: *mut ZSTD_entropyCTables_t,
-        cctx_params: *const c_void,
-        entropy_metadata: *mut ZSTD_entropyCTablesMetadata_t,
-        workspace: *mut c_void,
-        wksp_size: usize,
-    ) -> usize;
-
-    fn ZSTD_encodeSequences(
-        dst: *mut c_void,
-        dst_capacity: usize,
-        ctable_match_length: *const u32,
-        ml_code_table: *const u8,
-        ctable_offset_bits: *const u32,
-        of_code_table: *const u8,
-        ctable_lit_length: *const u32,
-        ll_code_table: *const u8,
-        sequences: *const SeqDef,
-        nb_seq: usize,
-        long_offsets: c_int,
-        bmi2: c_int,
-    ) -> usize;
-
-    fn ZSTD_fseBitCost(ctable: *const u32, count: *const u32, max: c_uint) -> usize;
-    fn ZSTD_crossEntropyCost(
-        norm: *const c_short,
-        accuracy_log: c_uint,
-        count: *const c_uint,
-        max: c_uint,
-    ) -> usize;
-}
-
 #[inline]
 fn remaining_capacity(capacity: usize, written: usize) -> Result<usize, usize> {
     capacity
@@ -838,28 +731,6 @@ unsafe fn size_block_sequences(
     nb_seq
 }
 
-#[inline]
-fn update_rep(reps: &mut [u32; 3], off_base: u32, literal_length_is_zero: bool) {
-    if off_base > 3 {
-        reps[2] = reps[1];
-        reps[1] = reps[0];
-        reps[0] = off_base - 3;
-        return;
-    }
-    let rep_code = off_base - 1 + u32::from(literal_length_is_zero);
-    if rep_code == 0 {
-        return;
-    }
-    let current_offset = if rep_code == 3 {
-        reps[0].wrapping_sub(1)
-    } else {
-        reps[rep_code as usize]
-    };
-    reps[2] = if rep_code >= 2 { reps[1] } else { reps[2] };
-    reps[1] = reps[0];
-    reps[0] = current_offset;
-}
-
 #[allow(clippy::too_many_arguments, clippy::manual_checked_ops)]
 unsafe fn compress_subblock_multi(
     seq_store: *const SeqStore_t,
@@ -1098,16 +969,18 @@ unsafe fn compress_subblock_multi(
 
 /// C ABI implementation called by the declaration-only C superblock shim.
 ///
-/// `cctx_params` deliberately remains opaque: only its two required scalar
+/// `ZSTD_CCtx_params` deliberately remains opaque: the C shim extracts the
-/// fields are read by the shim, while the existing C entropy builder receives
+/// two scalar fields this path reads (the strategy and the
-/// the original pointer unchanged.
+/// literals-compression switch) and the crate-internal entropy statistics
+/// builder receives them directly.
 #[allow(clippy::too_many_arguments)]
 #[no_mangle]
 pub unsafe extern "C" fn ZSTD_rust_compressSuperBlock(
     seq_store: *const c_void,
     prev_cblock: *const c_void,
     next_cblock: *mut c_void,
-    cctx_params: *const c_void,
+    strategy: c_int,
+    disable_literal_compression: c_int,
     workspace: *mut c_void,
     wksp_size: usize,
     bmi2: c_int,
@@ -1122,16 +995,17 @@ pub unsafe extern "C" fn ZSTD_rust_compressSuperBlock(
     let seq_store = seq_store.cast::<SeqStore_t>();
     let prev_cblock = prev_cblock.cast::<ZSTD_compressedBlockState_t>();
     let next_cblock = next_cblock.cast::<ZSTD_compressedBlockState_t>();
-    // C only writes the used prefixes of its two metadata byte buffers. Start
+    // The statistics builder only writes the used prefixes of the two
-    // with initialized storage so treating the completed C struct as a Rust
+    // metadata byte buffers. Start with initialized storage so treating the
-    // value never exposes uninitialized array elements.
+    // completed struct as a Rust value never exposes uninitialized elements.
     let mut entropy_metadata = MaybeUninit::<ZSTD_entropyCTablesMetadata_t>::zeroed();
     let entropy_result = unsafe {
-        ZSTD_buildBlockEntropyStats(
+        build_block_entropy_stats(
             seq_store,
             ptr::addr_of!((*prev_cblock).entropy),
             ptr::addr_of_mut!((*next_cblock).entropy),
-            cctx_params,
+            strategy,
+            disable_literal_compression,
             entropy_metadata.as_mut_ptr(),
             workspace,
             wksp_size,
@@ -1163,50 +1037,34 @@ pub unsafe extern "C" fn ZSTD_rust_compressSuperBlock(
 
 #[cfg(test)]
 mod tests {
+    // The shared C leaf layouts and the repcode update rules are asserted in
+    // `zstd_compress_stats`, which owns those definitions.
     use super::*;
-    use std::mem::{align_of, offset_of, size_of};
 
     #[test]
-    fn c_leaf_layouts_match_supported_abis() {
+    fn subblock_sizing_respects_the_budget() {
-        assert_eq!(size_of::<SeqDef>(), 8);
+        let sequences = [SeqDef {
-        assert_eq!(align_of::<SeqDef>(), align_of::<u32>());
+            offBase: 4,
-        assert_eq!(offset_of!(SeqStore_t, sequencesStart), 0);
+            litLength: 10,
-        assert_eq!(
+            mlBase: 10,
-            offset_of!(SeqStore_t, longLengthPos),
+        }; 8];
-            9 * size_of::<usize>() + 4
-        );
-        assert_eq!(size_of::<SeqStore_t>(), 9 * size_of::<usize>() + 8);
-        assert_eq!(size_of::<ZSTD_fseCTables_t>(), 3552);
-        assert_eq!(offset_of!(ZSTD_compressedBlockState_t, entropy), 0);
-        assert_eq!(
-            offset_of!(ZSTD_compressedBlockState_t, rep),
-            size_of::<ZSTD_entropyCTables_t>()
-        );
-        if size_of::<usize>() == 8 {
-            assert_eq!(size_of::<ZSTD_hufCTablesMetadata_t>(), 144);
-            assert_eq!(size_of::<ZSTD_fseCTablesMetadata_t>(), 168);
-            assert_eq!(size_of::<ZSTD_entropyCTablesMetadata_t>(), 312);
-            assert_eq!(size_of::<ZSTD_entropyCTables_t>(), 5616);
-            assert_eq!(size_of::<ZSTD_compressedBlockState_t>(), 5632);
-        } else {
-            assert_eq!(size_of::<ZSTD_hufCTablesMetadata_t>(), 136);
-            assert_eq!(size_of::<ZSTD_fseCTablesMetadata_t>(), 156);
-            assert_eq!(size_of::<ZSTD_entropyCTablesMetadata_t>(), 292);
-            assert_eq!(size_of::<ZSTD_entropyCTables_t>(), 4584);
-            assert_eq!(size_of::<ZSTD_compressedBlockState_t>(), 4596);
-        }
-    }
 
-    #[test]
+        // A generous budget keeps every sequence in one sub-block.
-    fn repcode_updates_match_the_c_sum_type_rules() {
+        let all = unsafe {
-        let mut reps = [1, 4, 8];
+            size_block_sequences(
-        update_rep(&mut reps, 10, false);
+                sequences.as_ptr(),
-        assert_eq!(reps, [7, 1, 4]);
+                sequences.len(),
-        update_rep(&mut reps, 1, true);
+                usize::MAX,
-        assert_eq!(reps, [1, 7, 4]);
+                256,
-        update_rep(&mut reps, 2, false);
+                256,
-        assert_eq!(reps, [7, 1, 4]);
+                true,
-        update_rep(&mut reps, 3, false);
+            )
-        assert_eq!(reps, [4, 7, 1]);
+        };
+        assert_eq!(all, sequences.len());
+
+        // The first sequence always survives, even over budget.
+        let first =
+            unsafe { size_block_sequences(sequences.as_ptr(), sequences.len(), 0, 256, 256, true) };
+        assert_eq!(first, 1);
     }
 }

tests/Makefile

@@ -79,8 +79,6 @@ RUST_TARGET_DIR := $(RUST_DIR)/target/$(RUST_BUILD_CONFIG)
 RUST_STATICLIB := $(RUST_TARGET_DIR)/release/libzstd_rs.a
 RUST_TARGET_32 ?= i686-unknown-linux-gnu
 RUST_STATICLIB_32 := $(RUST_TARGET_DIR)/$(RUST_TARGET_32)/release/libzstd_rs.a
-# Tests build every library module, so they use the crate's default feature
-# set (compression, decompression, and dict-builder) plus any forced HUF mode.
 RUST_CARGO_FLAGS := --manifest-path $(RUST_MANIFEST) --release \
                     --target-dir $(RUST_TARGET_DIR)
 ifneq ($(RUST_HUF_FEATURE),)