fc.c

/*
 * fc - Floating-Point Compressor
 * Copyright (c) 2026 Praveen Vaddadi <thynktank@gmail.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#define _POSIX_C_SOURCE 200112L

#include "fc.h"

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>
#include <immintrin.h>

#define ALIGNSIZE (4 * 1024)

#define BITS_PER_BYTE 8
#define BITS_PER_U32 32
#define BITS_PER_U64 64
#define LZ_MIN_MATCH_LEN ((size_t)sizeof(uint32_t))
#define AVX2_REG_BYTES ((size_t)sizeof(__m256i))
#define AVX2_U64_LANES ((size_t)(sizeof(__m256i) / sizeof(uint64_t)))

enum {
  M_PRED = 0, M_CONST = 1, M_STRIDE = 2, M_XORZ = 3, M_LZ = 4, M_RAW = 5,
  M_FLOAT32 = 6, M_ORDERED_DELTA = 7, M_FUZZY_STRIDE = 8, M_ALP = 9,
  M_TRAILING_ZERO_BP = 10, M_BYTE_TRANSPOSE = 11, M_XOR128 = 13,
  M_LSB_STRIP = 15, M_LOOKBACK_DELTA = 16, M_FLOAT_MULT = 17, M_FCM_RLE = 18,
  M_DICT = 19, M_DELTA2 = 20, M_BITPLANE = 21, M_INT_MULT = 22, M_CONV1 = 23,
  M_PRED_TANS = 24, M_PRED2 = 25, M_PRED_ADAPTIVE = 26, M_VITERBI = 27,
  M_DELTA_BINNED = 28, M_PRED_RC = 29, M_PRED_INTERLEAVED = 30, M_BWT = 31,
  M_LZ_DICT = 32, M_CONV_N = 33, M_SIGN_CONV = 34, M_CONV_DOUBLE = 35,
  M_MTF_LZ = 36, M_CONV_DOUBLE_BP = 37, M_CONV_N_BINNED = 38,
  M_PRED_SIMD_INTERLEAVED = 39, M_FUZZY_STRIDE_ANS = 40, M_PAQ_MIXER = 41,
  M_PAQ4_MIXER = 42, M_BWT_MTF_TANS = 43, M_PRED4 = 44, M_DELTA_DP_BINNED = 45,
  M_CONV_N_DP_BINNED = 46, M_ELF = 47, M_LZ_SPLIT = 48, M_BWT_MTF_RC = 49
};

#define C_INTERLEAVE_LANES 4U
#define C_LZDICT_PREAMBLE_BYTES 320U
#define C_CONV_N_MAX_ORDER 32U
#define C_CONV_N_SCALE_LOG 9
/* Order≤32, Q.9 weights, y_bound 2^44: 32*w*y+bias < 2^60, fits int64. */
#define C_CONV_N_Y_BOUND ((int64_t)1 << 44)
#define C_CONV_N_W_BOUND ((int32_t)((1 << (C_CONV_N_SCALE_LOG + 2)) - 1))
#define C_CONV_DOUBLE_ORDER 4
#define C_ELF_DELTA_BITS 4
#define C_DP_BIN_MAX 8U
#define C_DP_WIDTH_BUCKETS 65U
#define C_PAQ4_MIX_LOG 13
#define C_PAQ4_MIX_ONE ((int64_t)1 << C_PAQ4_MIX_LOG)
#define C_PAQ4_LEARN_SHIFT 4
#define C_PAQ_MIX_LOG 15
#define C_PAQ_MIX_ONE ((int64_t)1 << C_PAQ_MIX_LOG)
#define C_PAQ_LEARN_SHIFT 5
#define C_BWT_MAX_BYTES (C_QUANTUM_MAX_BYTES)
#define C_DICT_MAX_ENTRIES 256U
#define C_DICT_HASH_SIZE 1024U
#define C_DICT_HASH_MASK (C_DICT_HASH_SIZE - 1U)
#define C_FCM_RLE_HASH_SIZE 4096U
#define C_FCM_RLE_HASH_MASK (C_FCM_RLE_HASH_SIZE - 1U)
#define C_FCM_RLE_RUN_MAX 127U
#define C_LOOKBACK_K_COUNT 15U
#define C_QUANTUM_BYTES (256 * 1024)
#define C_QUANTUM_MAX_BYTES (1 * 1024 * 1024)
#define C_ENTROPY_PROBE_BYTES (48 * 1024)
#define C_MAGIC 0x32434650U

#define ull unsigned long long

static inline ull load_u64_unaligned(const void *ptr){ull x;memcpy(&x,ptr,sizeof(x));return x;}
static inline void store_u64_unaligned(void *ptr,ull v){memcpy(ptr,&v,sizeof(v));}
static inline void st32_le(unsigned char *p,uint32_t v){p[0]=(unsigned char)v;p[1]=(unsigned char)(v>>8);p[2]=(unsigned char)(v>>16);p[3]=(unsigned char)(v>>24);}
static inline uint32_t ld32_le(const unsigned char *p){return (uint32_t)p[0]|((uint32_t)p[1]<<8)|((uint32_t)p[2]<<16)|((uint32_t)p[3]<<24);}

static inline void avx2_copy(void *dst, const void *src, size_t n)
{
  unsigned char *d = (unsigned char *)dst;
  const unsigned char *s = (const unsigned char *)src;
  while (n >= AVX2_REG_BYTES) {
    __m256i v = _mm256_loadu_si256((const __m256i *)s);
    _mm256_storeu_si256((__m256i *)d, v);
    s += AVX2_REG_BYTES;
    d += AVX2_REG_BYTES;
    n -= AVX2_REG_BYTES;
  }
  while (n-- > 0) *d++ = *s++;
}

static inline size_t clz64_nonzero(ull value){return (size_t)__builtin_clzll(value);}
static inline size_t ctz64_nonzero(ull value){return (size_t)__builtin_ctzll(value);}

static inline size_t fc_crc32_u64(ull value){return (size_t)_mm_crc32_u64(0x9e3779b97f4a7c15ULL, value);}

static inline ull float_ordered(ull b){return (b&0x8000000000000000ULL)?~b:(b^0x8000000000000000ULL);}
static inline ull float_unordered(ull b){return (b&0x8000000000000000ULL)?(b^0x8000000000000000ULL):~b;}
static inline ull zigzag64(long long v){return ((ull)v<<1)^(ull)(v>>63);}
static inline long long unzigzag64(ull v){return (long long)((v>>1)^(0ULL-(v&1ULL)));}
static size_t bits_required64(ull v){return v?BITS_PER_U64-clz64_nonzero(v):0U;}

typedef struct { unsigned char *buf; uint64_t pos, cap, acc_bits; ull acc; } bw_t;
typedef struct { const unsigned char *buf; uint64_t pos, bytes, acc_bits; ull acc; } br_t;
typedef struct {
  uint64_t original_bytes;
  uint32_t magic, quantum_bytes;
  uint8_t predsizelg2, reserved[7];
} hdr_t;
typedef struct { uint32_t values, compressed_bytes; } bh_t;
typedef struct {
  uint64_t in_value_offset, out_byte_offset, values, compressed_bytes;
  unsigned char *compressed;
  int ok;
} job_t;
typedef struct {
  const ull *input;
  const unsigned char *compressed_stream;
  unsigned char *output;
  job_t *jobs;
  uint64_t job_count, next_job, predsizem1;
  pthread_mutex_t lock;
} pctx_t;

static inline void bw_init(bw_t *bw, unsigned char *buf, size_t cap)
{
  bw->buf = buf; bw->pos = 0; bw->cap = cap; bw->acc = 0; bw->acc_bits = 0;
}

static inline void bw_put(bw_t *bw, ull value, size_t bits)
{
  if (bits == 0U) return;
  if (bits < BITS_PER_U64) value &= ((ull)1U << bits) - 1ULL;
  if ((bw->acc_bits + bits) < BITS_PER_U64) {
    bw->acc = (bw->acc << bits) | value;
    bw->acc_bits += bits;
    return;
  }
  {
    size_t free_bits = BITS_PER_U64 - bw->acc_bits;
    ull acc_shifted = (free_bits >= BITS_PER_U64) ? 0ULL : (bw->acc << free_bits);
    ull take_from_value = (bits == free_bits) ? value : (value >> (bits - free_bits));
    ull head = acc_shifted | take_from_value;
    size_t i;
    for (i = 0; i < sizeof(ull); i++)
      if (bw->pos < bw->cap)
        bw->buf[bw->pos++] = (unsigned char)(head >> ((sizeof(ull) - 1U - i) * BITS_PER_BYTE));
    bw->acc_bits = bits - free_bits;
    bw->acc = (bw->acc_bits == 0) ? 0 : (value & (((ull)1U << bw->acc_bits) - 1ULL));
  }
}

/* Batched pack for 4 same-width values: coalesce into one bw_put
 * when 4*width ≤ 64; amortizes accumulator bookkeeping. */
static inline void bw_put4(bw_t *bw, ull v0, ull v1, ull v2, ull v3, size_t width)
{
  if (width == 0U) return;
  if ((width * 4U) <= BITS_PER_U64) {
    ull mask = (width >= BITS_PER_U64) ? ~(ull)0 : (((ull)1U << width) - 1ULL);
    ull combined = ((v0 & mask) << (3U * width))
                 | ((v1 & mask) << (2U * width))
                 | ((v2 & mask) << width)
                 |  (v3 & mask);
    bw_put(bw, combined, width * 4U);
  } else {
    bw_put(bw, v0, width);
    bw_put(bw, v1, width);
    bw_put(bw, v2, width);
    bw_put(bw, v3, width);
  }
}

static inline size_t bw_bytes(bw_t *bw)
{
  if (bw->acc_bits > 0) {
    size_t tail_bits = bw->acc_bits;
    ull tail = bw->acc << (BITS_PER_U64 - tail_bits);
    size_t byte_count = (tail_bits + 7U) >> 3;
    size_t i;
    for (i = 0; i < byte_count; i++)
      if (bw->pos < bw->cap)
        bw->buf[bw->pos++] = (unsigned char)(tail >> ((sizeof(ull) - 1U - i) * BITS_PER_BYTE));
    bw->acc = 0;
    bw->acc_bits = 0;
  }
  return bw->pos;
}

static inline void br_init(br_t *br, const unsigned char *buf, size_t bytes)
{
  br->buf = buf; br->pos = 0; br->bytes = bytes; br->acc = 0; br->acc_bits = 0;
}

static inline ull br_get(br_t *br, size_t bits)
{
  ull v = 0;
  if (bits == 0U) return 0;
  /* Drain accumulator first; never let acc_bits exceed 64 (overflow trap). */
  if (br->acc_bits > 0U) {
    size_t take = (bits < br->acc_bits) ? bits : br->acc_bits;
    ull part = br->acc >> (br->acc_bits - take);
    if (take < BITS_PER_U64) part &= ((ull)1U << take) - 1ULL;
    v = part;
    br->acc_bits -= take;
    br->acc = (br->acc_bits == 0U) ? 0ULL : (br->acc & (((ull)1U << br->acc_bits) - 1ULL));
    bits -= take;
  }
  while (bits >= BITS_PER_BYTE) {
    unsigned char b = (br->pos < br->bytes) ? br->buf[br->pos++] : 0U;
    v = (v << BITS_PER_BYTE) | (ull)b;
    bits -= BITS_PER_BYTE;
  }
  if (bits > 0U) {
    unsigned char b = (br->pos < br->bytes) ? br->buf[br->pos++] : 0U;
    size_t rest = BITS_PER_BYTE - bits;
    v = (v << bits) | (ull)((unsigned)b >> rest);
    br->acc_bits = rest;
    br->acc = (ull)b & (((ull)1U << rest) - 1ULL);
  }
  return v;
}

/* tANS, 8-bit symbols, table 1024, state in [1024,2048). LIFO at encode → bits
 * stored reverse, decoded forward. Wire format:
 *   [0]            num_syms - 1
 *   [1..N+1)       which_syms[i]   (u8)
 *   [N+1..3N+1)    weights[i]      (u16 LE)
 *   [3N+1..3N+5)   final_state     (u32 LE, in [1024,2048))
 *   [3N+5..3N+9)   total_bits      (u32 LE)
 *   [3N+9..)       renorm bits, MSB-first. */
#define C_ANS_MAX_SYMS    256U
#define C_ANS_SIZE_LOG    10U
#define C_ANS_TABLE_SIZE  (1U << C_ANS_SIZE_LOG)

typedef uint32_t fc_ans_state_t;
typedef uint16_t fc_ans_weight_t;

typedef struct {
  fc_ans_state_t renorm_cutoff;
  uint8_t min_renorm_bits;
  uint16_t weight, cum;
} fc_ans_sym_info_t;
typedef struct {
  fc_ans_sym_info_t infos[C_ANS_MAX_SYMS];
  fc_ans_state_t next_states[C_ANS_TABLE_SIZE];
  uint16_t num_syms;
} fc_ans_encoder_t;
typedef struct { uint16_t next_state_idx_base; uint8_t bits_to_read, symbol; } fc_ans_node_t;
typedef struct { fc_ans_node_t nodes[C_ANS_TABLE_SIZE]; } fc_ans_decoder_t;

static void fc_ans_spread(uint8_t *state_symbols, const fc_ans_weight_t *weights,
                             const uint8_t *which_syms, size_t num_syms)
{
  uint32_t step = 0U, stride = (3U * C_ANS_TABLE_SIZE) / 5U;
  size_t s;
  fc_ans_weight_t w;
  if ((stride & 1U) == 0U) stride++;
  for (s = 0; s < num_syms; s++) {
    uint8_t sym_id = which_syms[s];
    for (w = 0; w < weights[s]; w++) {
      uint32_t idx = (stride * step) & (C_ANS_TABLE_SIZE - 1U);
      state_symbols[idx] = sym_id;
      step++;
    }
  }
}

static int fc_ans_quantize(const uint32_t *counts, size_t num_syms, uint64_t total_count,
                              fc_ans_weight_t *weights_out)
{
  size_t i;
  fc_ans_weight_t weight_sum = 0U;
  float multiplier, surplus_mult, desired_surplus[C_ANS_MAX_SYMS], total_desired = 0.0f;
  size_t guard;
  if (num_syms == 0U || num_syms > C_ANS_MAX_SYMS) return 0;
  multiplier = (total_count > 0U) ? ((float)C_ANS_TABLE_SIZE / (float)total_count) : 0.0f;
  for (i = 0; i < num_syms; i++) {
    float v = (float)counts[i] * multiplier - 1.0f;
    if (v < 0.0f) v = 0.0f;
    desired_surplus[i] = v;
    total_desired += v;
  }
  surplus_mult = (total_desired > 0.0f)
                  ? ((float)((float)C_ANS_TABLE_SIZE - (float)num_syms) / total_desired)
                  : 0.0f;
  for (i = 0; i < num_syms; i++) {
    float w = 1.0f + desired_surplus[i] * surplus_mult;
    fc_ans_weight_t qw;
    qw = (fc_ans_weight_t)(w + 0.5f);
    if (qw == 0U) qw = 1U;
    weights_out[i] = qw;
  }
  for (i = 0; i < num_syms; i++) weight_sum = (fc_ans_weight_t)(weight_sum + weights_out[i]);
  /* Adjust to hit table_size, with a guard against pathological loops. */
  guard = num_syms * 8U + 16U;
  i = 0;
  while (weight_sum > C_ANS_TABLE_SIZE && guard > 0U) {
    if (weights_out[i] > 1U) { weights_out[i]--; weight_sum--; }
    i = (i + 1U) % num_syms;
    guard--;
  }
  guard = num_syms * 8U + 16U;
  i = 0;
  while (weight_sum < C_ANS_TABLE_SIZE && guard > 0U) {
    weights_out[i]++;
    weight_sum++;
    i = (i + 1U) % num_syms;
    guard--;
  }
  return (weight_sum == C_ANS_TABLE_SIZE) ? 1 : 0;
}

static void fc_ans_encoder_init(fc_ans_encoder_t *enc, const fc_ans_weight_t *weights,
                                const uint8_t *which_syms, size_t num_syms,
                                const uint8_t *state_symbols)
{
  size_t s;
  uint32_t i;
  uint16_t cum = 0U, fill_pos[C_ANS_MAX_SYMS];
  enc->num_syms = (uint16_t)num_syms;
  memset(enc->infos, 0, sizeof(enc->infos));
  for (s = 0; s < num_syms; s++) {
    fc_ans_weight_t w = weights[s];
    uint8_t sym_id = which_syms[s];
    uint32_t max_xs = (w > 0U) ? (2U * (uint32_t)w - 1U) : 1U, log_max = 0U;
    uint8_t mrb;
    while ((max_xs >> log_max) > 1U) log_max++;
    mrb = (uint8_t)((uint32_t)C_ANS_SIZE_LOG - log_max);
    enc->infos[sym_id].renorm_cutoff = (fc_ans_state_t)((uint32_t)w * 2U) << mrb;
    enc->infos[sym_id].min_renorm_bits = mrb;
    enc->infos[sym_id].weight = w;
    enc->infos[sym_id].cum = cum;
    fill_pos[s] = cum;
    cum = (uint16_t)(cum + w);
  }
  for (i = 0; i < C_ANS_TABLE_SIZE; i++) {
    uint8_t sym_id = state_symbols[i];
    size_t slot = 0U;
    while (slot < num_syms && which_syms[slot] != sym_id) slot++;
    enc->next_states[fill_pos[slot]++] = C_ANS_TABLE_SIZE + i;
  }
}

static void fc_ans_decoder_init(fc_ans_decoder_t *dec, const fc_ans_weight_t *weights,
                                const uint8_t *which_syms, size_t num_syms,
                                const uint8_t *state_symbols)
{
  fc_ans_state_t symbol_xs[C_ANS_MAX_SYMS];
  size_t s;
  uint32_t i;
  for (i = 0; i < C_ANS_MAX_SYMS; i++) symbol_xs[i] = 0U;
  for (s = 0; s < num_syms; s++) symbol_xs[which_syms[s]] = (fc_ans_state_t)weights[s];
  for (i = 0; i < C_ANS_TABLE_SIZE; i++) {
    uint8_t sym_id = state_symbols[i];
    fc_ans_state_t base = symbol_xs[sym_id];
    uint32_t bits = 0U;
    uint32_t a = (base != 0U) ? (uint32_t)__builtin_clz(base) : 31U;
    uint32_t b = (uint32_t)__builtin_clz(C_ANS_TABLE_SIZE);
    bits = a - b;
    dec->nodes[i].next_state_idx_base = (uint16_t)((base << bits) - C_ANS_TABLE_SIZE);
    dec->nodes[i].bits_to_read = (uint8_t)bits;
    dec->nodes[i].symbol = sym_id;
    symbol_xs[sym_id]++;
  }
}

/* Reverse-order (LIFO) bit emission: we record each (low, bits) pair as we
   encode in reverse symbol order, then write them to the stream in reverse
   so the decoder reading forward can reconstruct the original symbol order. */
typedef struct { uint16_t low; uint8_t bits; } fc_ans_bit_pair_t;

static size_t fc_ans_encode_bytes(const uint8_t *src, size_t src_len,
                                  const uint32_t *counts, size_t num_distinct,
                                  const uint8_t *which_syms,
                                  unsigned char *out, size_t out_cap)
{
  fc_ans_weight_t weights[C_ANS_MAX_SYMS];
  uint8_t state_symbols[C_ANS_TABLE_SIZE];
  fc_ans_encoder_t enc;
  fc_ans_state_t state = C_ANS_TABLE_SIZE;
  fc_ans_bit_pair_t *pairs;
  size_t header_bytes = 1U + num_distinct + (num_distinct * 2U) + 4U + 4U;
  size_t i, total_bits = 0U, byte_pos;
  uint64_t total_count = 0U;
  bw_t bw;
  if (num_distinct == 0U || num_distinct > C_ANS_MAX_SYMS) return (size_t)-1;
  if (header_bytes > out_cap) return (size_t)-1;
  for (i = 0; i < num_distinct; i++) total_count += counts[i];
  if (!fc_ans_quantize(counts, num_distinct, total_count, weights)) return (size_t)-1;
  fc_ans_spread(state_symbols, weights, which_syms, num_distinct);
  fc_ans_encoder_init(&enc, weights, which_syms, num_distinct, state_symbols);

  static __thread fc_ans_bit_pair_t *g_ans_pairs = NULL;
  static __thread size_t g_ans_pairs_cap = 0U;
  if (g_ans_pairs_cap < src_len) {
    size_t new_cap = src_len < 4096U ? 4096U : src_len;
    fc_ans_bit_pair_t *np = (fc_ans_bit_pair_t *)realloc(g_ans_pairs, new_cap * sizeof(*g_ans_pairs));
    if (!np) return (size_t)-1;
    g_ans_pairs = np; g_ans_pairs_cap = new_cap;
  }
  pairs = g_ans_pairs;
  for (i = src_len; i > 0U; i--) {
    uint8_t sym = src[i - 1U];
    fc_ans_sym_info_t *info = &enc.infos[sym];
    uint8_t renorm_bits;
    uint32_t low;
    fc_ans_state_t shifted, next_state;
    if (info->weight == 0U) return (size_t)-1;
    renorm_bits = (uint8_t)(info->min_renorm_bits + (state >= info->renorm_cutoff ? 1U : 0U));
    low = (renorm_bits == 0U) ? 0U : (state & ((1U << renorm_bits) - 1U));
    shifted = state >> renorm_bits;
    next_state = enc.next_states[info->cum + (shifted - info->weight)];
    pairs[src_len - i].low = (uint16_t)low;
    pairs[src_len - i].bits = renorm_bits;
    total_bits += renorm_bits;
    state = next_state;
  }

  out[0] = (uint8_t)(num_distinct - 1U);
  for (i = 0; i < num_distinct; i++) out[1U + i] = which_syms[i];
  byte_pos = 1U + num_distinct;
  for (i = 0; i < num_distinct; i++) {
    out[byte_pos]     = (uint8_t)(weights[i] & 0xffU);
    out[byte_pos + 1] = (uint8_t)((weights[i] >> 8) & 0xffU);
    byte_pos += 2;
  }
  st32_le(out + byte_pos, (uint32_t)state); byte_pos += 4;
  st32_le(out + byte_pos, (uint32_t)total_bits); byte_pos += 4;
  /* Reverse encoding order so decoder reads forward. */
  bw_init(&bw, out + byte_pos, out_cap - byte_pos);
  for (i = src_len; i > 0U; i--) {
    fc_ans_bit_pair_t p = pairs[i - 1U];
    if (p.bits > 0U) bw_put(&bw, (ull)p.low, p.bits);
  }
  return byte_pos + bw_bytes(&bw);
}

static size_t fc_ans_decode_bytes(const unsigned char *in, size_t in_bytes, size_t expected_len,
                                      uint8_t *out_buf)
{
  size_t num_distinct;
  uint8_t which_syms[C_ANS_MAX_SYMS], state_symbols[C_ANS_TABLE_SIZE];
  fc_ans_weight_t weights[C_ANS_MAX_SYMS];
  fc_ans_decoder_t dec;
  fc_ans_state_t state;
  size_t byte_pos, i;
  br_t br;
  if (in_bytes < 1U) return 0U;
  num_distinct = (size_t)in[0] + 1U;
  byte_pos = 1U;
  if (in_bytes < (1U + num_distinct + num_distinct * 2U + 8U)) return 0U;
  for (i = 0; i < num_distinct; i++) which_syms[i] = in[byte_pos + i];
  byte_pos += num_distinct;
  for (i = 0; i < num_distinct; i++) {
    weights[i] = (fc_ans_weight_t)((uint32_t)in[byte_pos] | ((uint32_t)in[byte_pos + 1] << 8));
    byte_pos += 2;
  }
  state = (fc_ans_state_t)ld32_le(in + byte_pos); byte_pos += 4;
  byte_pos += 4;
  fc_ans_spread(state_symbols, weights, which_syms, num_distinct);
  fc_ans_decoder_init(&dec, weights, which_syms, num_distinct, state_symbols);

  br_init(&br, in + byte_pos, in_bytes - byte_pos);
  for (i = 0; i < expected_len; i++) {
    fc_ans_node_t *node = &dec.nodes[state - C_ANS_TABLE_SIZE];
    ull bits = (node->bits_to_read == 0U) ? 0ULL : br_get(&br, node->bits_to_read);
    out_buf[i] = node->symbol;
    state = (fc_ans_state_t)(C_ANS_TABLE_SIZE + node->next_state_idx_base) + (fc_ans_state_t)bits;
  }
  return expected_len;
}

/* Binary range coder. 12-bit fractional probabilities, shift-rate
 * 5 adaptive update. Probabilities are P(bit==0) in [0, 4096]. */
typedef struct {
  uint64_t low, cache_size;
  uint32_t range;
  size_t op, cap;
  unsigned char *out;
  unsigned char cache;
} fc_rc_enc_t;
typedef struct {
  const unsigned char *in;
  size_t ip, in_bytes;
  uint32_t range, code;
} fc_rc_dec_t;

static void rc_enc_init(fc_rc_enc_t *rc, unsigned char *out, size_t cap)
{
  rc->low = 0U; rc->range = 0xffffffffU; rc->out = out;
  rc->op = 0U; rc->cap = cap; rc->cache = 0U; rc->cache_size = 1U;
}

/* Renormalize: when high 8 bits stable (or carry), flush cache + queued FFs.
 * Caller guarantees out_cap >= upper-bound on encoded bytes so the bounds check
 * is unnecessary on the per-byte hot path. */
static __attribute__((always_inline)) inline void rc_enc_shift_low(fc_rc_enc_t *rc)
{
  if (rc->low < 0xff000000ULL || rc->low >= 0x100000000ULL) {
    unsigned char carry = (unsigned char)(rc->low >> 32);
    rc->out[rc->op++] = (unsigned char)(rc->cache + carry);
    while (--rc->cache_size > 0U) rc->out[rc->op++] = (unsigned char)(0xffU + carry);
    rc->cache = (unsigned char)((rc->low >> 24) & 0xffU);
    rc->cache_size = 1U;
  } else rc->cache_size++;
  rc->low = (rc->low << 8) & 0xffffffffULL;
}

static __attribute__((always_inline)) inline void rc_enc_bit(fc_rc_enc_t *rc, int bit, uint16_t *prob)
{
  uint32_t new_bound = (rc->range >> 12) * (uint32_t)(*prob);
  if (bit == 0) {
    rc->range = new_bound;
    *prob = (uint16_t)(*prob + ((4096U - *prob) >> 5));
  } else {
    rc->low += new_bound;
    rc->range -= new_bound;
    *prob = (uint16_t)(*prob - (*prob >> 5));
  }
  while (rc->range < 0x01000000U) { rc->range <<= 8; rc_enc_shift_low(rc); }
}

static size_t rc_enc_finish(fc_rc_enc_t *rc)
{
  size_t k;
  for (k = 0; k < 5U; k++) rc_enc_shift_low(rc);
  return rc->op;
}

static void rc_dec_init(fc_rc_dec_t *rc, const unsigned char *in, size_t in_bytes)
{
  size_t i;
  rc->in = in; rc->ip = 0U; rc->in_bytes = in_bytes;
  rc->range = 0xffffffffU; rc->code = 0U;
  /* Read 5 bytes; first is always 0 from encoder's cache and is discarded. */
  for (i = 0; i < 5U; i++) rc->code = (rc->code << 8) | ((rc->ip < rc->in_bytes) ? rc->in[rc->ip++] : 0U);
}

static __attribute__((always_inline)) inline int rc_dec_bit(fc_rc_dec_t *rc, uint16_t *prob)
{
  uint32_t new_bound = (rc->range >> 12) * (uint32_t)(*prob);
  int bit;
  if (rc->code < new_bound) {
    rc->range = new_bound;
    *prob = (uint16_t)(*prob + ((4096U - *prob) >> 5));
    bit = 0;
  } else {
    rc->code -= new_bound;
    rc->range -= new_bound;
    *prob = (uint16_t)(*prob - (*prob >> 5));
    bit = 1;
  }
  while (rc->range < 0x01000000U) {
    /* Caller guarantees ≥16 zero-padded bytes past encoded_len; no bounds check needed. */
    unsigned char b = rc->in[rc->ip];
    rc->ip++;
    rc->range <<= 8;
    rc->code = (rc->code << 8) | b;
  }
  return bit;
}

/* Range-coded byte stream: 64 contexts indexed by
 * (prev_3_bits << 3) | bit_pos. Wire: [encoded_len:u32 LE][rc bits].
 * Refuses if encoded_len ≥ src_len. */
#define C_RC_HIST_BITS 3
#define C_RC_HIST_MASK ((1U << C_RC_HIST_BITS) - 1U)
#define C_RC_NUM_CONTEXTS (8U << C_RC_HIST_BITS)

static size_t fc_rc_compress_bytes(const uint8_t *src, size_t src_len,
                                   unsigned char *out, size_t out_cap)
{
  uint16_t probs[C_RC_NUM_CONTEXTS];
  fc_rc_enc_t rc;
  size_t header_bytes = 4U, i, b, encoded_len;
  unsigned int hist = 0U;
  if (src_len < 32U) return (size_t)-1;
  /* Need cap >= src_len + small constant so the inner bounds-free hot path can write without
   * overflow. Binary RC encoded size <= src_len + ~5 in absolute worst case. */
  if (out_cap < header_bytes + src_len + 16U) return (size_t)-1;
  for (i = 0; i < C_RC_NUM_CONTEXTS; i++) probs[i] = 2048U;
  rc_enc_init(&rc, out + header_bytes, out_cap - header_bytes);
  for (i = 0; i < src_len; i++) {
    uint8_t byte_val = src[i];
    for (b = 0; b < 8U; b++) {
      int bit = (byte_val >> b) & 1;
      size_t ctx = (size_t)((hist & C_RC_HIST_MASK) << 3) | b;
      rc_enc_bit(&rc, bit, &probs[ctx]);
      hist = (hist << 1) | (unsigned int)bit;
    }
  }
  encoded_len = rc_enc_finish(&rc);
  if (encoded_len >= src_len) return (size_t)-1;
  st32_le(out, (uint32_t)encoded_len);
  return header_bytes + encoded_len;
}

static __thread unsigned char *g_rc_pad_buf = NULL;
static __thread size_t g_rc_pad_cap = 0U;
static __thread int g_rc_pad_atexit_registered = 0;
static void fc_rc_pad_free(void){if(g_rc_pad_buf){free(g_rc_pad_buf);g_rc_pad_buf=NULL;g_rc_pad_cap=0U;}}

static size_t fc_rc_decompress_bytes(const unsigned char *in, size_t in_bytes,
                                     size_t expected_len, uint8_t *out_buf)
{
  uint16_t probs[C_RC_NUM_CONTEXTS];
  fc_rc_dec_t rc;
  size_t header_bytes = 4U, encoded_len, i, b;
  unsigned int hist = 0U;
  if (in_bytes < header_bytes) return 0U;
  encoded_len = (size_t)ld32_le(in);
  if ((header_bytes + encoded_len) > in_bytes) return 0U;
  for (i = 0; i < C_RC_NUM_CONTEXTS; i++) probs[i] = 2048U;
  /* Fast path: if there's ≥16 bytes of buffer past the encoded segment, we can
   * read past the boundary safely (those bytes feed renorm but never influence
   * any decoded output bit). Otherwise pad-copy via thread-local scratch. */
  const unsigned char *rc_in;
  size_t rc_bytes;
  if (in_bytes - header_bytes - encoded_len >= 16U) {
    rc_in = in + header_bytes;
    rc_bytes = in_bytes - header_bytes;
  } else {
    if (g_rc_pad_cap < encoded_len + 16U) {
      size_t new_cap = encoded_len + 16U;
      if (new_cap < 4096U) new_cap = 4096U;
      unsigned char *nb = (unsigned char *)realloc(g_rc_pad_buf, new_cap);
      if (!nb) return 0U;
      g_rc_pad_buf = nb; g_rc_pad_cap = new_cap;
      if (!g_rc_pad_atexit_registered) { atexit(fc_rc_pad_free); g_rc_pad_atexit_registered = 1; }
    }
    memcpy(g_rc_pad_buf, in + header_bytes, encoded_len);
    memset(g_rc_pad_buf + encoded_len, 0, 16U);
    rc_in = g_rc_pad_buf;
    rc_bytes = encoded_len + 16U;
  }
  rc_dec_init(&rc, rc_in, rc_bytes);
  for (i = 0; i < expected_len; i++) {
    uint8_t byte_val = 0U;
    for (b = 0; b < 8U; b++) {
      size_t ctx = (size_t)((hist & C_RC_HIST_MASK) << 3) | b;
      int bit = rc_dec_bit(&rc, &probs[ctx]);
      byte_val |= (uint8_t)(bit << b);
      hist = (hist << 1) | (unsigned int)bit;
    }
    out_buf[i] = byte_val;
  }
  return expected_len;
}

/* High-level wrapper: compress a byte buffer via tANS using its full 256-bin
   histogram, returning encoded size or (size_t)-1 on failure / non-improvement.
   Only writes if the encoded bytes are strictly fewer than src_len. */
static size_t fc_ans_compress_bytes(const uint8_t *src, size_t src_len,
                                       unsigned char *out, size_t out_cap)
{
  uint32_t hist[C_ANS_MAX_SYMS];
  uint8_t which_syms[C_ANS_MAX_SYMS];
  uint32_t counts[C_ANS_MAX_SYMS];
  size_t num_distinct = 0U, i, encoded;
  if (src_len < 16U) return (size_t)-1;
  memset(hist, 0, sizeof(hist));
  for (i = 0; i < src_len; i++) hist[src[i]]++;
  for (i = 0; i < C_ANS_MAX_SYMS; i++) {
    if (hist[i] > 0U) {
      which_syms[num_distinct] = (uint8_t)i;
      counts[num_distinct] = hist[i];
      num_distinct++;
    }
  }
  if (num_distinct < 2U) return (size_t)-1;
  encoded = fc_ans_encode_bytes(src, src_len, counts, num_distinct, which_syms, out, out_cap);
  if (encoded == (size_t)-1 || encoded >= src_len) return (size_t)-1;
  return encoded;
}

static size_t pred_enc(const ull *input, size_t num, size_t predsizem1,
                       ull *fcm, ull *dfcm, unsigned char *out);
static void pred_dec(const unsigned char *in, size_t in_bytes, size_t num,
                     size_t predsizem1, ull *fcm, ull *dfcm, ull *out);
static void fc_sample_unique(uint64_t seed, size_t n, size_t k,
                             uint8_t *visited_bits, size_t *out_indices);
static double fc_im_significance_threshold(int g, double target_concentration);
static int fc_bcode(ull x);
static void fc_mtf_forward(const unsigned char *src, size_t n, unsigned char *dst);
static void fc_mtf_inverse(const unsigned char *src, size_t n, unsigned char *dst);
static inline float fc_fast_log2f(float x);

/* PRED_TANS: predictor output [tags|payload], tags re-coded via tANS.
 * Wire: [tans_size:u32 LE][tANS tags][raw predictor payload]. Refuses if
 * tans_size >= num (i.e. tANS doesn't beat raw tags). */
static size_t lz_enc(const unsigned char *input, size_t n,
                                      unsigned char *out, size_t out_cap);
static void lz_dec(const unsigned char *in, size_t in_bytes,
                                       unsigned char *out, size_t out_bytes);
static void byte_transpose8(const unsigned char *src, size_t values, unsigned char *dst);
static void byte_untranspose8(const unsigned char *src, size_t values, unsigned char *dst);

/* SA-IS linear-time suffix array. Sentinel at position n (smaller than any
 * real char); sa[] has length n+1, sa[0]=n, sa[1..n]=sorted suffixes.
 * Recursion depth O(log n) — uses C call stack. */
typedef struct {
  const uint8_t *src8;
  const int *src32;
  int is_int, n, alpha;
} sais_in_t;

static inline int sais_get(const sais_in_t *in, int i)
{
  if (i >= in->n) return -1;  /* virtual sentinel = -1 (smaller than all) */
  return in->is_int ? in->src32[i] : (int)in->src8[i];
}

#define SAIS_S_TYPE 1
#define SAIS_L_TYPE 0

static void sais_classify(const sais_in_t *in, uint8_t *t)
{
  int i, n = in->n;
  if (n == 0) return;
  t[n - 1] = SAIS_L_TYPE;
  for (i = n - 2; i >= 0; i--) {
    int a = sais_get(in, i), b = sais_get(in, i + 1);
    if (a < b) t[i] = SAIS_S_TYPE;
    else if (a > b) t[i] = SAIS_L_TYPE;
    else t[i] = t[i + 1];
  }
}

/* LMS (Leftmost-S): i > 0 && t[i] == S && t[i-1] == L. */
static int sais_is_lms(const uint8_t *t, int i)
{
  return i > 0 && t[i] == SAIS_S_TYPE && t[i - 1] == SAIS_L_TYPE;
}

static void sais_get_buckets(const sais_in_t *in, int *bucket, int end)
{
  int n = in->n, alpha = in->alpha, i, sum = 0;
  for (i = 0; i < alpha; i++) bucket[i] = 0;
  for (i = 0; i < n; i++) bucket[sais_get(in, i)]++;
  for (i = 0; i < alpha; i++) { sum += bucket[i]; bucket[i] = end ? sum : sum - bucket[i]; }
}

static void sais_induce_l(const sais_in_t *in, int *sa, const uint8_t *t, int *bucket)
{
  int n = in->n, i;
  sais_get_buckets(in, bucket, 0);
  for (i = 0; i < n; i++) {
    int j = sa[i] - 1;
    if (j >= 0 && t[j] == SAIS_L_TYPE) sa[bucket[sais_get(in, j)]++] = j;
  }
}

static void sais_induce_s(const sais_in_t *in, int *sa, const uint8_t *t, int *bucket)
{
  int n = in->n, i;
  sais_get_buckets(in, bucket, 1);
  for (i = n - 1; i >= 0; i--) {
    int j = sa[i] - 1;
    if (j >= 0 && t[j] == SAIS_S_TYPE) sa[--bucket[sais_get(in, j)]] = j;
  }
}

/* Compare two LMS-substrings starting at p and q. */
static int sais_lms_eq(const sais_in_t *in, const uint8_t *t, int p, int q)
{
  int n = in->n, i;
  if (p == q) return 1;
  if (p >= n || q >= n) return 0;
  for (i = 0;; i++) {
    int pa = (p + i < n) ? sais_get(in, p + i) : -1;
    int qa = (q + i < n) ? sais_get(in, q + i) : -1;
    int p_lms = sais_is_lms(t, p + i), q_lms = sais_is_lms(t, q + i);
    if (i > 0 && p_lms && q_lms) return 1;
    if (pa != qa || p_lms != q_lms) return 0;
  }
}

static void sais_compute(const sais_in_t *in, int *sa)
{
  int n = in->n, alpha = in->alpha, i, n1 = 0, name = 0, prev = -1, alpha2 = 0;
  uint8_t *t = NULL;
  int *bucket = NULL;
  if (n == 0) return;
  if (n == 1) { sa[0] = 0; return; }
  t = (uint8_t *)malloc((size_t)n);
  bucket = (int *)malloc((size_t)alpha * sizeof(int));
  if (t == NULL || bucket == NULL) goto cleanup;
  sais_classify(in, t);

  /* Stage 1: bucket-place LMS suffixes at end of buckets, then induce. */
  for (i = 0; i < n; i++) sa[i] = -1;
  sais_get_buckets(in, bucket, 1);
  for (i = n - 1; i >= 0; i--) if (sais_is_lms(t, i)) sa[--bucket[sais_get(in, i)]] = i;
  sais_induce_l(in, sa, t, bucket);
  sais_induce_s(in, sa, t, bucket);
  /* Stage 2: compact LMS-suffix order in SA[0..n1), assign names to LMS-substrings. */
  n1 = 0;
  for (i = 0; i < n; i++) if (sa[i] > 0 && sais_is_lms(t, sa[i])) sa[n1++] = sa[i];
  for (i = n1; i < n; i++) sa[i] = -1;
  prev = -1;
  name = 0;
  for (i = 0; i < n1; i++) {
    int pos = sa[i];
    if (prev == -1 || !sais_lms_eq(in, t, prev, pos)) name++;
    prev = pos;
    sa[n1 + (pos / 2)] = name - 1;
  }
  {
    int j = n - 1;
    for (i = n - 1; i >= n1; i--) if (sa[i] >= 0) sa[j--] = sa[i];
  }
  alpha2 = name;
  /* Stage 3: recurse if names not unique, else SA1 is trivial. */
  if (name < n1) {
    sais_in_t rec_in = { NULL, sa + (n - n1), 1, n1, alpha2 };
    sais_compute(&rec_in, sa);
  } else {
    int *s1 = sa + (n - n1);
    for (i = 0; i < n1; i++) sa[s1[i]] = i;
  }
  /* Stage 4: induced sort with sorted SA1. */
  {
    int *lms_positions = (int *)malloc((size_t)n1 * sizeof(int));
    int *temp_lms;
    int j = 0;
    if (!lms_positions) goto cleanup;
    for (i = 0; i < n; i++) if (sais_is_lms(t, i)) lms_positions[j++] = i;
    for (i = 0; i < n1; i++) sa[i] = lms_positions[sa[i]];
    for (i = n1; i < n; i++) sa[i] = -1;
    sais_get_buckets(in, bucket, 1);
    temp_lms = (int *)malloc((size_t)n1 * sizeof(int));
    if (!temp_lms) { free(lms_positions); goto cleanup; }
    for (i = 0; i < n1; i++) temp_lms[i] = sa[i];
    for (i = 0; i < n; i++) sa[i] = -1;
    for (i = n1 - 1; i >= 0; i--) { int pos = temp_lms[i]; sa[--bucket[sais_get(in, pos)]] = pos; }
    free(temp_lms);
    sais_induce_l(in, sa, t, bucket);
    sais_induce_s(in, sa, t, bucket);
    free(lms_positions);
  }
cleanup:
  free(t); free(bucket);
}

/* SA-IS byte entry: sa[] of length n holds suffix positions sorted lex. */
static void sais_byte(const uint8_t *src, int n, int *sa)
{
  sais_in_t in = { src, NULL, 0, n, 256 };
  sais_compute(&in, sa);
}

/* Cyclic BWT via doubled-buffer SA-IS on src++src; entries <n are the cyclic order. */
static int sais_cyclic_bwt(const uint8_t *src, int n, uint8_t *bwt_out)
{
  int *sa_full;
  uint8_t *dbl;
  int primary = -1, i, filt = 0;
  if (n <= 0) return -1;
  dbl = (uint8_t *)malloc((size_t)n * 2U);
  sa_full = (int *)malloc((size_t)n * 2U * sizeof(int));
  if (!dbl || !sa_full) { free(dbl); free(sa_full); return -1; }
  memcpy(dbl, src, (size_t)n);
  memcpy(dbl + n, src, (size_t)n);
  sais_byte(dbl, 2 * n, sa_full);
  for (i = 0; i < 2 * n; i++) {
    int s = sa_full[i];
    if (s < n) {
      bwt_out[filt] = (s == 0) ? src[n - 1] : src[s - 1];
      if (s == 0) primary = filt;
      filt++;
    }
  }
  free(dbl);
  free(sa_full);
  return primary;
}

/* BWT: doubling-SA forward (O(n log²n)), L→F inverse (O(n)). */
static __thread int *g_bwt_sa_rank;
static __thread int  g_bwt_sa_k;
static __thread int  g_bwt_sa_n;

static int bwt_sa_compare(const void *pa, const void *pb)
{
  int a = *(const int *)pa, b = *(const int *)pb;
  int ra = g_bwt_sa_rank[a], rb = g_bwt_sa_rank[b], idx_a, idx_b, ra2, rb2;
  if (ra != rb) return (ra < rb) ? -1 : 1;
  idx_a = a + g_bwt_sa_k; idx_b = b + g_bwt_sa_k;
  if (idx_a >= g_bwt_sa_n) idx_a -= g_bwt_sa_n;
  if (idx_b >= g_bwt_sa_n) idx_b -= g_bwt_sa_n;
  ra2 = g_bwt_sa_rank[idx_a]; rb2 = g_bwt_sa_rank[idx_b];
  if (ra2 != rb2) return (ra2 < rb2) ? -1 : 1;
  return 0;
}

static int bwt_build_sa(const uint8_t *src, int n, int *sa, int *rank, int *new_rank)
{
  int i, k;
  if (n <= 0) return 0;
  for (i = 0; i < n; i++) { sa[i] = i; rank[i] = (int)src[i]; }
  for (k = 1; k <= n; k *= 2) {
    int r = 0;
    g_bwt_sa_rank = rank; g_bwt_sa_k = k; g_bwt_sa_n = n;
    qsort(sa, (size_t)n, sizeof(int), bwt_sa_compare);
    new_rank[sa[0]] = 0;
    for (i = 1; i < n; i++) {
      if (bwt_sa_compare(&sa[i - 1], &sa[i]) != 0) r++;
      new_rank[sa[i]] = r;
    }
    memcpy(rank, new_rank, (size_t)n * sizeof(int));
    if (r == n - 1) break;
  }
  return 1;
}

static int bwt_encode(const uint8_t *src, int n, uint8_t *out, int *primary_out,
                       int *sa, int *rank, int *new_rank)
{
  int i;
  if (!bwt_build_sa(src, n, sa, rank, new_rank)) return 0;
  *primary_out = -1;
  for (i = 0; i < n; i++) {
    int s = sa[i];
    out[i] = (s == 0) ? src[n - 1] : src[s - 1];
    if (s == 0) *primary_out = i;
  }
  return (*primary_out >= 0) ? 1 : 0;
}

static void bwt_decode(const uint8_t *L, int n, int primary, uint8_t *out, int *T)
{
  int count[256];
  int cum[257];
  int occ[256];
  int i;
  int c, idx;
  memset(count, 0, sizeof(count));
  memset(occ, 0, sizeof(occ));
  for (i = 0; i < n; i++) count[L[i]]++;
  cum[0] = 0;
  for (c = 1; c < 257; c++) cum[c] = cum[c - 1] + count[c - 1];
  for (i = 0; i < n; i++) { T[i] = cum[L[i]] + occ[L[i]]; occ[L[i]]++; }
  /* Walk: T^k[primary] = row index of rotation k; L of that row = original[k-1]. */
  idx = primary;
  for (i = 0; i < n; i++) { idx = T[idx]; out[i] = L[idx]; }
}

/* M_BWT: byte-transpose, BWT, LZ. SA-IS used above C_BWT_DOUBLING_THRESHOLD.
 * Wire: [primary_index:i32 LE][bwt_size:u32 LE][lz_size:u32 LE][lz payload]. */
#define C_BWT_DOUBLING_THRESHOLD (8U * 1024U)

static size_t bwt_enc(const ull *input, size_t num, unsigned char *transposed, unsigned char *bwt_buf,
                      int *sa, int *rank, int *new_rank, unsigned char *out, size_t out_cap)
{
  size_t bytes = num * sizeof(ull), header_bytes = 12U, lz_size;
  int primary;
  if (bytes < 256U || bytes > C_BWT_MAX_BYTES) return (size_t)-1;
  if ((header_bytes + bytes) > out_cap) return (size_t)-1;
  byte_transpose8((const unsigned char *)(const void *)input, num, transposed);
  if (bytes <= C_BWT_DOUBLING_THRESHOLD) {
    if (!bwt_encode(transposed, (int)bytes, bwt_buf, &primary, sa, rank, new_rank)) return (size_t)-1;
  } else {
    primary = sais_cyclic_bwt(transposed, (int)bytes, bwt_buf);
    if (primary < 0) return (size_t)-1;
  }
  lz_size = lz_enc(bwt_buf, bytes, out + header_bytes, out_cap - header_bytes);
  if (lz_size > bytes || (header_bytes + lz_size) > out_cap) return (size_t)-1;
  st32_le(out, (uint32_t)primary);
  st32_le(out + 4, (uint32_t)bytes);
  st32_le(out + 8, (uint32_t)lz_size);
  return header_bytes + lz_size;
}

static void bwt_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t header_bytes = 12U, bwt_size, lz_size, bytes;
  int primary, *T;
  unsigned char *bwt_buf, *transposed;
  if (in_bytes < header_bytes) return;
  primary  = (int)ld32_le(in);
  bwt_size = (size_t)ld32_le(in + 4);
  lz_size  = (size_t)ld32_le(in + 8);
  bytes = num * sizeof(ull);
  if (bwt_size != bytes || lz_size > in_bytes - header_bytes) return;
  bwt_buf = (unsigned char *)malloc(bytes);
  transposed = (unsigned char *)malloc(bytes);
  T = (int *)malloc(bytes * sizeof(int));
  if (!bwt_buf || !transposed || !T) goto cleanup;
  lz_dec(in + header_bytes, lz_size, bwt_buf, bytes);
  bwt_decode(bwt_buf, (int)bytes, primary, transposed, T);
  byte_untranspose8(transposed, num, (unsigned char *)(void *)out);
cleanup:
  free(bwt_buf); free(transposed); free(T);
}

/* PRED_INTERLEAVED: C_INTERLEAVE_LANES round-robin sub-streams,
 * predictor each independently. Per-lane chains have independent loop-carried
 * deps so OoO can interleave them.
 * Wire: [lane_size[0..L]:u32 LE × L][lane_payloads concatenated]. */
/* AVX2 gather: 4 independent FCM/DFCM lookups in one op. */
static inline __m256i fc_simd_gather_u64x4(const ull *base, __m256i indices)
{
  return _mm256_i64gather_epi64((const long long *)base, indices, 8);
}

static inline void fc_fcm_gather4(const ull *fcm_bank, size_t bank_stride,
                                       size_t hashes[4], ull preds_out[4])
{
  __m256i lane_offsets = _mm256_set_epi64x((long long)(3U * bank_stride),
                                              (long long)(2U * bank_stride),
                                              (long long)(1U * bank_stride),
                                              0LL);
  __m256i indices = _mm256_add_epi64(_mm256_loadu_si256((const __m256i *)hashes),
                                       lane_offsets);
  __m256i preds = fc_simd_gather_u64x4(fcm_bank, indices);
  _mm256_storeu_si256((__m256i *)preds_out, preds);
}

/* 4-lane SIMD-gather predictor: direct-mapped FCM+DFCM (1-way), 3 pred_ids.
 * Wire (matches PRED_INTERLEAVED): [lane_size[0..3]:u32 LE × 4]
 * [per lane: tag_bytes + payload]. */

static void predSI_dec_lane(const unsigned char *in, size_t num,
                            size_t predsizem1, ull *fcm, ull *dfcm, ull *out)
{
  size_t i, hash = 0, dhash = 0, code_bytes = num, data = code_bytes;
  ull lastval = 0, laststride = 0, prevstride = 0;
  memset(fcm, 0, (predsizem1 + 1U) * sizeof(ull));
  memset(dfcm, 0, (predsizem1 + 1U) * sizeof(ull));
  for (i = 0; i < num; i++) {
    int code = in[i], bcode = code & 0x7, pred_id = (code >> 3) & 0x7, bytes = bcode + (bcode >> 2);
    ull val = 0, stride, pred, preds[8];
    size_t j;
    for (j = 0; j < (size_t)bytes; j++) val |= ((ull)in[data++]) << (j * 8U);
    preds[0] = fcm[hash];
    preds[1] = preds[0];
    preds[2] = lastval + dfcm[dhash];
    preds[3] = lastval + laststride + (laststride - prevstride);
    preds[4] = 0; preds[5] = 0; preds[6] = 0; preds[7] = 0;
    pred = preds[(unsigned)pred_id & 7U];
    val ^= pred;
    stride = val - lastval;
    prevstride = laststride;
    laststride = stride;
    fcm[hash] = val;
    hash = fc_crc32_u64(val) & predsizem1;
    dfcm[dhash] = stride;
    dhash = fc_crc32_u64(stride) & predsizem1;
    lastval = val;
    out[i] = val;
  }
  (void)prevstride;
}

/* 4-lane SIMD-lockstep encoder: one AVX2 gather per iteration over 4 lanes;
 * output byte-identical to the serial 4-call form. */
static size_t predSI_enc(const ull *input, size_t num, size_t predsizem1,
                                                  unsigned char *out, size_t out_cap)
{
  enum { L = 4 };
  size_t bank_stride = predsizem1 + 1U;
  ull *fcm_bank = NULL, *dfcm_bank = NULL;
  unsigned char *lane_buf_pool = NULL;
  size_t lane_n[L], lane_op[L], hash_arr[L], dhash_arr[L];
  size_t header_bytes = (size_t)L * 4U, lane_buf_cap, i, k, max_lane_n, op, lane, result_size;
  unsigned char *lane_buf[L];
  ull lastval[L], laststride[L], prevstride[L];
  if (num < (4U * (size_t)L)) return (size_t)-1;
  for (k = 0; k < (size_t)L; k++) lane_n[k] = (num + (size_t)(L - 1U) - k) / (size_t)L;
  max_lane_n = lane_n[0];
  for (k = 1; k < (size_t)L; k++) if (lane_n[k] > max_lane_n) max_lane_n = lane_n[k];
  fcm_bank  = (ull *)calloc((size_t)L * bank_stride, sizeof(ull));
  dfcm_bank = (ull *)calloc((size_t)L * bank_stride, sizeof(ull));
  lane_buf_cap = max_lane_n * 9U + 64U;
  lane_buf_pool = (unsigned char *)malloc((size_t)L * lane_buf_cap);
  if (!fcm_bank || !dfcm_bank || !lane_buf_pool) { free(fcm_bank); free(dfcm_bank); free(lane_buf_pool); return (size_t)-1; }
  for (k = 0; k < (size_t)L; k++) {
    lane_buf[k] = lane_buf_pool + k * lane_buf_cap;
    memset(lane_buf[k], 0, lane_n[k]);
    lane_op[k] = lane_n[k];
    hash_arr[k] = 0U; dhash_arr[k] = 0U;
    lastval[k] = 0U; laststride[k] = 0U; prevstride[k] = 0U;
  }
  /* Lockstep over max_lane_n; lanes past their length skip via the i>=lane_n[k] guard. */
  for (i = 0; i < max_lane_n; i++) {
    ull pred_fcm[L], pred_dfcm_table[L];
    fc_fcm_gather4(fcm_bank, bank_stride, hash_arr, pred_fcm);
    fc_fcm_gather4(dfcm_bank, bank_stride, dhash_arr, pred_dfcm_table);
    for (k = 0; k < (size_t)L; k++) {
      ull v, stride, best, xor1, xor2, xor3;
      ull pred1, pred2, pred3;
      int code, pred_id = 0, bcode, bytes;
      size_t j;
      if (i >= lane_n[k]) continue;
      v = input[k + i * (size_t)L];
      pred1 = pred_fcm[k];
      pred2 = lastval[k] + pred_dfcm_table[k];
      pred3 = lastval[k] + laststride[k] + (laststride[k] - prevstride[k]);
      xor1 = v ^ pred1; xor2 = v ^ pred2; xor3 = v ^ pred3;
      best = xor1;
      if (xor2 < best) { best = xor2; pred_id = 2; }
      if (xor3 < best) { best = xor3; pred_id = 3; }
      stride = v - lastval[k];
      prevstride[k] = laststride[k];
      laststride[k] = stride;
      lastval[k] = v;
      bcode = fc_bcode(best);
      bytes = bcode + (bcode >> 2);
      code = (pred_id << 3) | bcode;
      lane_buf[k][i] = (unsigned char)code;
      for (j = 0; j < (size_t)bytes; j++) if (lane_op[k] < lane_buf_cap) lane_buf[k][lane_op[k]++] = (unsigned char)(best >> (j * 8U));
      fcm_bank[k * bank_stride + hash_arr[k]] = v;
      hash_arr[k] = fc_crc32_u64(v) & predsizem1;
      dfcm_bank[k * bank_stride + dhash_arr[k]] = stride;
      dhash_arr[k] = fc_crc32_u64(stride) & predsizem1;
    }
  }

  if (header_bytes > out_cap) { free(fcm_bank); free(dfcm_bank); free(lane_buf_pool); return (size_t)-1; }
  op = header_bytes;
  for (lane = 0; lane < (size_t)L; lane++) {
    size_t lane_size = lane_op[lane];
    if ((op + lane_size) > out_cap) { free(fcm_bank); free(dfcm_bank); free(lane_buf_pool); return (size_t)-1; }
    st32_le(out + lane * 4U, (uint32_t)lane_size);
    memcpy(out + op, lane_buf[lane], lane_size);
    op += lane_size;
  }
  result_size = op;
  free(fcm_bank); free(dfcm_bank); free(lane_buf_pool);
  return result_size;
}

static void predSI_dec(const unsigned char *in, size_t in_bytes, size_t num,
                       size_t predsizem1, ull *fcm, ull *dfcm, ull *substream_buf, ull *out)
{
  enum { L = 4 };
  size_t header_bytes = (size_t)L * 4U, lane, ip = header_bytes;
  if (in_bytes < header_bytes) return;
  for (lane = 0; lane < (size_t)L; lane++) {
    size_t lane_n = (num + (size_t)(L - 1U) - lane) / (size_t)L, k;
    size_t sz = ld32_le(in + lane * 4U);
    if ((ip + sz) > in_bytes) return;
    predSI_dec_lane(in + ip, lane_n, predsizem1, fcm, dfcm, substream_buf);
    for (k = 0; k < lane_n; k++) out[lane + (k * (size_t)L)] = substream_buf[k];
    ip += sz;
  }
}

static size_t predI_enc(const ull *input, size_t num, size_t predsizem1,
                        ull *fcm, ull *dfcm, ull *substream_buf, unsigned char *fc_scratch,
                        unsigned char *out, size_t out_cap)
{
  size_t header_bytes = C_INTERLEAVE_LANES * 4U, op = header_bytes, lane;
  if (num < (4U * C_INTERLEAVE_LANES)) return (size_t)-1;
  for (lane = 0; lane < C_INTERLEAVE_LANES; lane++) {
    size_t lane_n = (num + (C_INTERLEAVE_LANES - 1U) - lane) / C_INTERLEAVE_LANES, k, sz;
    for (k = 0; k < lane_n; k++) substream_buf[k] = input[lane + (k * C_INTERLEAVE_LANES)];
    sz = pred_enc(substream_buf, lane_n, predsizem1, fcm, dfcm, fc_scratch);
    if ((op + sz) > out_cap) return (size_t)-1;
    st32_le(out + lane * 4U, (uint32_t)sz);
    memcpy(out + op, fc_scratch, sz);
    op += sz;
  }
  return op;
}

static void predI_dec(const unsigned char *in, size_t in_bytes, size_t num,
                      size_t predsizem1, ull *fcm, ull *dfcm, ull *substream_buf, ull *out)
{
  size_t header_bytes = C_INTERLEAVE_LANES * 4U, lane, ip = header_bytes;
  if (in_bytes < header_bytes) return;
  for (lane = 0; lane < C_INTERLEAVE_LANES; lane++) {
    size_t lane_n = (num + (C_INTERLEAVE_LANES - 1U) - lane) / C_INTERLEAVE_LANES, k;
    size_t sz = ld32_le(in + lane * 4U);
    if ((ip + sz) > in_bytes) return;
    pred_dec(in + ip, sz, lane_n, predsizem1, fcm, dfcm, substream_buf);
    for (k = 0; k < lane_n; k++) out[lane + (k * C_INTERLEAVE_LANES)] = substream_buf[k];
    ip += sz;
  }
}

/* PRED_RC: PRED_TANS layout with binary range coder on tags.
 * Wire: [rc_size:u32 LE][rc-encoded tags][raw payload]. */
static size_t predRC_enc_cached(const ull *input, size_t num, size_t predsizem1,
                         ull *fcm, ull *dfcm, unsigned char *scratch_fc,
                         size_t cached_fc_size, size_t *out_fc_size,
                         unsigned char *out, size_t out_cap)
{
  size_t fc_size, payload_size, header_bytes = 4U, rc_size;
  if (num < 32U) return (size_t)-1;
  if (cached_fc_size != 0U) {
    fc_size = cached_fc_size;
  } else {
    fc_size = pred_enc(input, num, predsizem1, fcm, dfcm, scratch_fc);
    if (out_fc_size) *out_fc_size = fc_size;
  }
  if (fc_size <= num) return (size_t)-1;
  payload_size = fc_size - num;
  if ((header_bytes + payload_size + num) > out_cap) return (size_t)-1;
  rc_size = fc_rc_compress_bytes(scratch_fc, num,
                                     out + header_bytes,
                                     out_cap - header_bytes - payload_size);
  if (rc_size == (size_t)-1) return (size_t)-1;
  st32_le(out, (uint32_t)rc_size);
  memcpy(out + header_bytes + rc_size, scratch_fc + num, payload_size);
  return header_bytes + rc_size + payload_size;
}

static void predRC_dec(const unsigned char *in, size_t in_bytes, size_t num,
                       size_t predsizem1, ull *fcm, ull *dfcm,
                       unsigned char *scratch_fc, ull *out)
{
  size_t rc_size, header_bytes = 4U, payload_size;
  if (in_bytes < header_bytes) return;
  rc_size = (size_t)ld32_le(in);
  if ((header_bytes + rc_size) > in_bytes) return;
  /* Pass the full envelope so fc_rc_decompress_bytes can take its no-copy fast path. */
  if (fc_rc_decompress_bytes(in + header_bytes, in_bytes - header_bytes, num, scratch_fc) != num) return;
  payload_size = in_bytes - header_bytes - rc_size;
  memcpy(scratch_fc + num, in + header_bytes + rc_size, payload_size);
  pred_dec(scratch_fc, num + payload_size, num, predsizem1, fcm, dfcm, out);
}

/* Cached variant: if cached_fc_size != 0, reuse precomputed pred_enc output in scratch_fc;
 * else call pred_enc fresh (and the caller can read out the size via *out_fc_size). */
static size_t predT_enc_cached(const ull *input, size_t num, size_t predsizem1,
                        ull *fcm, ull *dfcm, unsigned char *scratch_fc,
                        size_t cached_fc_size, size_t *out_fc_size,
                        unsigned char *out, size_t out_cap)
{
  size_t fc_size, payload_size, header_bytes = 4U, tans_size;
  if (num < 16U) return (size_t)-1;
  if (cached_fc_size != 0U) {
    fc_size = cached_fc_size;
  } else {
    fc_size = pred_enc(input, num, predsizem1, fcm, dfcm, scratch_fc);
    if (out_fc_size) *out_fc_size = fc_size;
  }
  if (fc_size <= num) return (size_t)-1;
  payload_size = fc_size - num;
  if ((header_bytes + payload_size + num) > out_cap) return (size_t)-1;
  tans_size = fc_ans_compress_bytes(scratch_fc, num,
                                        out + header_bytes,
                                        out_cap - header_bytes - payload_size);
  if (tans_size == (size_t)-1) return (size_t)-1;
  st32_le(out, (uint32_t)tans_size);
  memcpy(out + header_bytes + tans_size, scratch_fc + num, payload_size);
  return header_bytes + tans_size + payload_size;
}


static void predT_dec(const unsigned char *in, size_t in_bytes, size_t num,
                      size_t predsizem1, ull *fcm, ull *dfcm,
                      unsigned char *scratch_fc, ull *out)
{
  size_t tans_size, header_bytes = 4U, payload_size;
  if (in_bytes < header_bytes) return;
  tans_size = (size_t)ld32_le(in);
  if ((header_bytes + tans_size) > in_bytes) return;
  if (fc_ans_decode_bytes(in + header_bytes, tans_size, num, scratch_fc) != num) return;
  payload_size = in_bytes - header_bytes - tans_size;
  memcpy(scratch_fc + num, in + header_bytes + tans_size, payload_size);
  pred_dec(scratch_fc, num + payload_size, num, predsizem1, fcm, dfcm, out);
}

static int block_is_constant_avx2(const ull *input, size_t num)
{
  size_t i = 1U;
  __m256i first;
  if (num == 0U) return 1;
  first = _mm256_set1_epi64x((long long)input[0]);
  for (; (i + AVX2_U64_LANES) <= num; i += AVX2_U64_LANES) {
    __m256i v = _mm256_loadu_si256((const __m256i *)(input + i));
    __m256i eq = _mm256_cmpeq_epi64(v, first);
    if (_mm256_movemask_epi8(eq) != -1) return 0;
  }
  for (; i < num; i++) if (input[i] != input[0]) return 0;
  return 1;
}

static int block_is_stride(const ull *input, size_t num, ull *stride)
{
  size_t i;
  if (num <= 2) {
    *stride = (num == 2) ? input[1] - input[0] : 0;
    return 1;
  }
  *stride = input[1] - input[0];
  for (i = 2; i < num; i++) if ((input[i] - input[i - 1]) != *stride) return 0;
  return 1;
}

static size_t xorz_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  size_t i, prev_leading = 64U, prev_sigbits = 0U;
  ull prev;
  bw_t bw;
  if (num <= 0) return 0;
  if (out_cap < 8) return (size_t)-1;
  store_u64_unaligned(out, input[0]);
  bw_init(&bw, out + 8, out_cap - 8);
  prev = input[0];

  for (i = 1; i < num; i++) {
    ull value = input[i], x = value ^ prev;
    if (x == 0) bw_put(&bw, 0, 1);
    else {
      size_t leading = clz64_nonzero(x), trailing = ctz64_nonzero(x);
      size_t sigbits = BITS_PER_U64 - leading - trailing;
      if (prev_leading != BITS_PER_U64 && leading >= prev_leading && sigbits <= prev_sigbits) {
        bw_put(&bw, 2, 2);
        bw_put(&bw, x >> (BITS_PER_U64 - prev_leading - prev_sigbits), prev_sigbits);
      } else {
        bw_put(&bw, 3, 2);
        bw_put(&bw, (ull)leading, 5);
        bw_put(&bw, (ull)(sigbits == BITS_PER_U64 ? 0U : sigbits), 6);
        bw_put(&bw, x >> trailing, sigbits);
        prev_leading = leading; prev_sigbits = sigbits;
      }
    }
    prev = value;
  }
  return sizeof(ull) + bw_bytes(&bw);
}

static void xorz_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t i, prev_leading = 64U, prev_sigbits = 0U;
  ull prev;
  br_t br;
  if (num == 0U) return;
  out[0] = load_u64_unaligned(in);
  prev = out[0];
  br_init(&br, in + sizeof(ull), in_bytes - sizeof(ull));

  for (i = 1; i < num; i++) {
    ull value;
    if (br_get(&br, 1) == 0) value = prev;
    else {
      ull payload, x;
      if (br_get(&br, 1) != 0) {
        prev_leading = (size_t)br_get(&br, 5);
        prev_sigbits = (size_t)br_get(&br, 6);
        if (prev_sigbits == 0U) prev_sigbits = BITS_PER_U64;
      }
      payload = br_get(&br, prev_sigbits);
      x = payload << (BITS_PER_U64 - prev_leading - prev_sigbits);
      value = prev ^ x;
    }
    out[i] = value;
    prev = value;
  }
}

/* predictor residual bcode: encodes how many bytes are needed for value x.
   The 8 bcode levels map to {0,1,2,3,5,6,7,8} bytes via bytes=bcode+(bcode>>2). */
enum {
  C_BCODE_0BYTE = 0,
  C_BCODE_1BYTE = 1,
  C_BCODE_2BYTE = 2,
  C_BCODE_3BYTE = 3,
  C_BCODE_5BYTE = 4,
  C_BCODE_6BYTE = 5,
  C_BCODE_7BYTE = 6,
  C_BCODE_8BYTE = 7
};

static inline int fc_bcode(ull x)
{
  /* _lzcnt_u64 is defined for x=0 (returns 64); table size is 65. */
  unsigned lz = (unsigned)_lzcnt_u64(x);
  static const unsigned char tab[65] = {
    7,7,7,7,7,7,7,7,
    6,6,6,6,6,6,6,6,
    5,5,5,5,5,5,5,5,
    4,4,4,4,4,4,4,4,
    4,4,4,4,4,4,4,4,
    3,3,3,3,3,3,3,3,
    2,2,2,2,2,2,2,2,
    1,1,1,1,1,1,1,1,
    0  /* x == 0 → bcode 0 */
  };
  return (int)tab[lz];
}

/* Shared self-cleaning predictor scratch.
 * pred_enc, pred2_enc, pred4_enc all share fcm/dfcm; each self-cleans at end of call,
 * leaving them all-zero so the next caller can safely skip the 4MB memset on entry.
 * Caller (worker thread) provides initially-zero fcm/dfcm via al_alloc. */
static __thread uint32_t *g_pred_touched_fcm = NULL;
static __thread uint32_t *g_pred_touched_dfcm = NULL;
static __thread size_t g_pred_touched_cap = 0U;

static int pred_track_grow(size_t need) {
  if (g_pred_touched_cap >= need) return 1;
  size_t new_cap = need < 4096U ? 4096U : need;
  uint32_t *nf = (uint32_t *)realloc(g_pred_touched_fcm, new_cap * sizeof(uint32_t));
  uint32_t *nd = (uint32_t *)realloc(g_pred_touched_dfcm, new_cap * sizeof(uint32_t));
  if (!nf || !nd) { free(nf); free(nd); return 0; }
  g_pred_touched_fcm = nf; g_pred_touched_dfcm = nd; g_pred_touched_cap = new_cap;
  return 1;
}

static size_t pred_enc(const ull *input, size_t num, size_t predsizem1, ull *fcm, ull *dfcm, unsigned char *out)
{
  size_t i, hash = 0, dhash = 0, code_bytes = num, data = code_bytes;
  ull lastval = 0, laststride = 0, prevstride = 0, pred1 = 0, pred1b = 0, pred2 = 0, pred3 = 0;
  size_t fcm_count = 0U, dfcm_count = 0U;
  int track_ok = pred_track_grow(num + 1U);
  if (!track_ok) {
    memset(fcm, 0, (predsizem1 + 1U) * sizeof(ull));
    memset(dfcm, 0, (predsizem1 + 1U) * sizeof(ull));
  }
  memset(out, 0, code_bytes);

  for (i = 0; i < num; i++) {
    ull val = input[i], stride, best, xor1 = val ^ pred1, xor1b = val ^ pred1b, xor2, xor3;
    int code = 0, pred_id = 0, bcode, bytes;
    size_t j, base;
    xor2 = val ^ pred2;
    pred3 = lastval + laststride + (laststride - prevstride);
    xor3 = val ^ pred3;
    best = xor1;
    if (xor1b < best) { best = xor1b; pred_id = 1; }
    if (xor2 < best) { best = xor2; pred_id = 2; }
    if (xor3 < best) { best = xor3; pred_id = 3; }
    stride = val - lastval;
    prevstride = laststride;
    laststride = stride;
    lastval = val;
    base = hash & ~(size_t)1U;
    fcm[base + 1U] = fcm[base];
    fcm[base] = val;
    if (track_ok) g_pred_touched_fcm[fcm_count++] = (uint32_t)base;
    hash = fc_crc32_u64(val) & predsizem1;
    base = hash & ~(size_t)1U;
    pred1 = fcm[base]; pred1b = fcm[base + 1U];
    dfcm[dhash] = stride;
    if (track_ok) g_pred_touched_dfcm[dfcm_count++] = (uint32_t)dhash;
    dhash = fc_crc32_u64(stride) & predsizem1;
    pred2 = val + dfcm[dhash];
    bcode = fc_bcode(best);
    bytes = bcode + (bcode >> 2);
    code = (pred_id << 3) | bcode;
    out[i] = (unsigned char)code;
    /* Single 8-byte store, advance by `bytes`. Subsequent iterations overwrite
     * the over-written tail; final iteration's tail is unused (caller's `out`
     * has ≥8 bytes of slack past the maximal data length). */
    store_u64_unaligned(out + data, best);
    data += (size_t)bytes;
    (void)j;
  }
  if (track_ok) {
    for (i = 0; i < fcm_count; i++) { size_t b = (size_t)g_pred_touched_fcm[i]; _mm_storeu_si128((__m128i *)(void *)&fcm[b], _mm_setzero_si128()); }
    for (i = 0; i < dfcm_count; i++) dfcm[(size_t)g_pred_touched_dfcm[i]] = 0;
  }
  return data;
}

static void pred_dec(const unsigned char *in, size_t in_bytes, size_t num, size_t predsizem1, ull *fcm, ull *dfcm, ull *out)
{
  size_t i, hash = 0, dhash = 0, code_bytes = num, data = code_bytes;
  ull lastval = 0, laststride = 0, prevstride = 0, pred1 = 0, pred1b = 0, pred2 = 0, pred3 = 0;
  size_t fcm_count = 0U, dfcm_count = 0U;
  int track_ok = pred_track_grow(num + 1U);
  (void)in_bytes;
  if (!track_ok) {
    memset(fcm, 0, (predsizem1 + 1U) * sizeof(ull));
    memset(dfcm, 0, (predsizem1 + 1U) * sizeof(ull));
  }

  for (i = 0; i < num; i++) {
    int code = in[i], bcode = code & 0x7, pred_id = code >> 3, bytes = bcode + (bcode >> 2);
    ull val = 0, stride, preds[4];
    size_t j, base;
    for (j = 0; j < (size_t)bytes; j++) val |= ((ull)in[data++]) << (j * 8U);
    /* branchless residual decode via 4-entry lookup. */
    preds[0] = pred1; preds[1] = pred1b; preds[2] = pred2; preds[3] = pred3;
    val ^= preds[(unsigned)pred_id & 3U];
    stride = val - lastval;
    pred3 = val + stride + (stride - laststride);
    prevstride = laststride;
    laststride = stride;
    (void)prevstride;
    base = hash & ~(size_t)1U;
    fcm[base + 1U] = fcm[base];
    fcm[base] = val;
    if (track_ok) g_pred_touched_fcm[fcm_count++] = (uint32_t)base;
    hash = fc_crc32_u64(val) & predsizem1;
    base = hash & ~(size_t)1U;
    pred1 = fcm[base]; pred1b = fcm[base + 1U];
    dfcm[dhash] = stride;
    if (track_ok) g_pred_touched_dfcm[dfcm_count++] = (uint32_t)dhash;
    dhash = fc_crc32_u64(stride) & predsizem1;
    pred2 = val + dfcm[dhash];
    lastval = val;
    out[i] = val;
  }
  if (track_ok) {
    for (i = 0; i < fcm_count; i++) { size_t b = (size_t)g_pred_touched_fcm[i]; _mm_storeu_si128((__m128i *)(void *)&fcm[b], _mm_setzero_si128()); }
    for (i = 0; i < dfcm_count; i++) dfcm[(size_t)g_pred_touched_dfcm[i]] = 0;
  }
}

static inline size_t lz_hash32(uint32_t v)
{
  return fc_crc32_u64((ull)v) & 0xffffU;
}

typedef struct { uint64_t len, off; int recent; } lz_match_t;
typedef struct { uint64_t off[3]; } recent_t;

static void recent_init(recent_t *r)
{
  r->off[0] = 1; r->off[1] = sizeof(float); r->off[2] = sizeof(double);
}

static void recent_update(recent_t *r, size_t off)
{
  if (off == 0U || r->off[0] == off) return;
  r->off[2] = r->off[1]; r->off[1] = r->off[0]; r->off[0] = off;
}

static size_t lz_match_len(const unsigned char *a, const unsigned char *b, size_t max_len)
{
  size_t len = 0U;
  while (len + 8U <= max_len && load_u64_unaligned(a + len) == load_u64_unaligned(b + len)) len += 8U;
  while (len < max_len && a[len] == b[len]) len++;
  return len;
}

static lz_match_t lz_find_match(const unsigned char *input, size_t n, size_t pos, const uint64_t *table, uint32_t epoch, const recent_t *recent)
{
  lz_match_t best = {0U, 0U, -1};
  size_t h, i, ref_pos;
  uint64_t entry;
  int ref_valid;
  if ((pos + LZ_MIN_MATCH_LEN) > n) return best;
  for (i = 0; i < 3; i++) {
    size_t off = recent->off[i];
    if ((off <= pos) && (off <= 65535U) && ((pos + LZ_MIN_MATCH_LEN) <= n) &&
        (memcmp(input + pos - off, input + pos, LZ_MIN_MATCH_LEN) == 0)) {
      size_t len = lz_match_len(input + pos - off, input + pos, n - pos);
      if (len > best.len) {
        best.len = len;
        best.off = off;
        best.recent = (int)i;
      }
    }
  }
  h = lz_hash32((uint32_t)load_u64_unaligned(input + pos));
  entry = table[h];
  ref_valid = ((uint32_t)(entry >> BITS_PER_U32) == epoch) ? 1 : 0;
  ref_pos = (size_t)(uint32_t)entry;
  if (ref_valid && (pos > ref_pos) && ((pos - ref_pos) <= 65535U) &&
      (memcmp(input + ref_pos, input + pos, LZ_MIN_MATCH_LEN) == 0)) {
    size_t len = lz_match_len(input + ref_pos, input + pos, n - pos);
    if (len > best.len) {
      best.len = len;
      best.off = pos - ref_pos;
      best.recent = -1;
    }
  }
  if (best.len < LZ_MIN_MATCH_LEN) {
    best.len = 0U;
    best.off = 0U;
    best.recent = -1;
  }
  return best;
}

/* Synthetic LZ dictionary: 40 common float patterns prefixed
 * before the LZ window; matches on first occurrence cost no literals. */
static void fc_build_lz_dict(unsigned char *out)
{
  static const double common[40] = {
    0.0, 1.0, -1.0, 2.0, -2.0, 0.5, -0.5, 0.25,
    3.14159265358979323846, 2.71828182845904523536, 1.41421356237309504880, 1.61803398874989484820,
    1e0, 1e1, 1e2, 1e3, 1e4, 1e6, 1e9, 1e-1,
    1e-2, 1e-3, 1e-6, 1e-9,
    3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0,
    1024.0, 65536.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
  };
  size_t i;
  for (i = 0; i < 40U; i++) memcpy(out + i * sizeof(double), &common[i], sizeof(double));
}

static unsigned char *write_varint(unsigned char *p, size_t v)
{
  while (v >= 128) {
    *p++ = (unsigned char)(v | 0x80);
    v >>= 7;
  }
  *p++ = (unsigned char)v;
  return p;
}

static const unsigned char *read_varint(const unsigned char *p, const unsigned char *end, size_t *v)
{
  size_t value = 0;
  int shift = 0;
  while ((p < end) && (shift < (int)(sizeof(size_t) * 8U))) {
    unsigned char c = *p++;
    value |= (size_t)(c & 0x7f) << shift;
    if ((c & 0x80) == 0) { *v = value; return p; }
    shift += 7;
  }
  *v = 0;
  return p;
}

/* Hash entry: position in low 32 bits + 32-bit epoch tag in high 32 bits.
   Resetting the epoch invalidates all entries without a 256KB memset. */
static size_t lz_enc(const unsigned char *input, size_t n, unsigned char *out, size_t out_cap)
{
  static __thread uint64_t s_table[65536];
  static __thread uint32_t s_epoch = 0U;
  uint64_t *table = s_table;
  uint32_t epoch;
  size_t pos = 0, lit_start = 0;
  unsigned char *op = out, *end = out + out_cap;
  recent_t recent;
  s_epoch++;
  if (s_epoch == 0U) { memset(s_table, 0, sizeof(s_table)); s_epoch = 1U; }
  epoch = s_epoch;
  recent_init(&recent);

  while (pos + 8 <= n && op < end) {
    size_t h = lz_hash32((uint32_t)load_u64_unaligned(input + pos));
    lz_match_t m;
    table[h] = ((uint64_t)epoch << BITS_PER_U32) | (uint32_t)pos;
    m = lz_find_match(input, n, pos, table, epoch, &recent);
    if (m.len > 0U) {
      if ((pos + 1U) < n) { lz_match_t m1 = lz_find_match(input, n, pos + 1U, table, epoch, &recent); if (m1.len > (m.len + 1U)) { pos++; continue; } }
      if ((pos + 2U) < n) { lz_match_t m2 = lz_find_match(input, n, pos + 2U, table, epoch, &recent); if (m2.len > (m.len + 2U)) { pos++; continue; } }
      size_t lit_len = pos - lit_start;
      op = write_varint(op, lit_len);
      if (op + lit_len + 12 >= end) return n + 1;
      avx2_copy(op, input + lit_start, lit_len);
      op += lit_len;
      op = write_varint(op, m.len);
      if (m.recent >= 0) {
        *op++ = (unsigned char)(2 + m.recent);
      } else {
        uint16_t off16 = (uint16_t)m.off;
        *op++ = 1U;
        *op++ = (unsigned char)off16;
        *op++ = (unsigned char)(off16 >> 8);
      }
      recent_update(&recent, m.off);
      pos += m.len;
      lit_start = pos;
      continue;
    }
    pos++;
  }

  op = write_varint(op, n - lit_start);
  if (op + (n - lit_start) + 3 > end) return n + 1;
  avx2_copy(op, input + lit_start, n - lit_start);
  op += n - lit_start;
  op = write_varint(op, 0);
  *op++ = 0;
  return (size_t)(op - out);
}

/* lz-with-dict variant: caller passes a buffer where bytes [0, dict_n)
   are a known dictionary preamble that BOTH encoder and decoder construct
   identically. Encoder hashes positions [0, n) so matches can reach into the
   dict, but only emits literals/match-records starting from position dict_n.
   Decoder pre-fills its output buffer with the dict preamble, then runs LZ
   decompress starting at op = out + dict_n. */
static size_t lz_enc_d(const unsigned char *input, size_t n, size_t dict_n,
                                          unsigned char *out, size_t out_cap)
{
  static __thread uint64_t s_table[65536];
  static __thread uint32_t s_epoch = 0U;
  uint64_t *table = s_table;
  uint32_t epoch;
  size_t pos = dict_n, lit_start = dict_n, i;
  unsigned char *op = out, *end = out + out_cap;
  recent_t recent;
  s_epoch++;
  if (s_epoch == 0U) { memset(s_table, 0, sizeof(s_table)); s_epoch = 1U; }
  epoch = s_epoch;
  recent_init(&recent);
  for (i = 0; (i + 8U) <= dict_n; i++) {
    size_t h = lz_hash32((uint32_t)load_u64_unaligned(input + i));
    table[h] = ((uint64_t)epoch << BITS_PER_U32) | (uint32_t)i;
  }
  while (pos + 8 <= n && op < end) {
    size_t h = lz_hash32((uint32_t)load_u64_unaligned(input + pos));
    lz_match_t m;
    table[h] = ((uint64_t)epoch << BITS_PER_U32) | (uint32_t)pos;
    m = lz_find_match(input, n, pos, table, epoch, &recent);
    if (m.len > 0U) {
      if ((pos + 1U) < n) { lz_match_t m1 = lz_find_match(input, n, pos + 1U, table, epoch, &recent); if (m1.len > (m.len + 1U)) { pos++; continue; } }
      if ((pos + 2U) < n) { lz_match_t m2 = lz_find_match(input, n, pos + 2U, table, epoch, &recent); if (m2.len > (m.len + 2U)) { pos++; continue; } }
      {
        size_t lit_len = pos - lit_start;
        op = write_varint(op, lit_len);
        if (op + lit_len + 12 >= end) return n + 1;
        avx2_copy(op, input + lit_start, lit_len);
        op += lit_len;
        op = write_varint(op, m.len);
        if (m.recent >= 0) {
          *op++ = (unsigned char)(2 + m.recent);
        } else {
          uint16_t off16 = (uint16_t)m.off;
          *op++ = 1U;
          *op++ = (unsigned char)off16;
          *op++ = (unsigned char)(off16 >> 8);
        }
        recent_update(&recent, m.off);
        pos += m.len;
        lit_start = pos;
        continue;
      }
    }
    pos++;
  }
  op = write_varint(op, n - lit_start);
  if (op + (n - lit_start) + 3 > end) return n + 1;
  avx2_copy(op, input + lit_start, n - lit_start);
  op += n - lit_start;
  op = write_varint(op, 0);
  *op++ = 0;
  return (size_t)(op - out);
}

static void lz_dec_d(const unsigned char *in, size_t in_bytes,
                                           const unsigned char *dict, size_t dict_n,
                                           unsigned char *out, size_t out_bytes)
{
  if (dict_n > out_bytes) return;
  memcpy(out, dict, dict_n);
  {
    const unsigned char *ip = in, *end = in + in_bytes;
    unsigned char *op = out + dict_n, *oend = out + out_bytes;
    recent_t recent;
    recent_init(&recent);
    while (ip < end && op <= oend) {
      size_t lit_len, match_len, off = 0U;
      unsigned char kind;
      ip = read_varint(ip, end, &lit_len);
      if ((ip + lit_len) > end || (op + lit_len) > oend) break;
      avx2_copy(op, ip, lit_len);
      op += lit_len;
      ip += lit_len;
      ip = read_varint(ip, end, &match_len);
      if (ip >= end) break;
      kind = *ip++;
      if (match_len == 0) break;
      {
        enum { LZ_KIND_EXPLICIT_OFFSET = 1U, LZ_KIND_RECENT_BASE = 2U };
        enum { LZ_KIND_RECENT_MAX = LZ_KIND_RECENT_BASE + 3U - 1U };
        if (kind == LZ_KIND_EXPLICIT_OFFSET) {
          if ((ip + 2) > end) break;
          off = (size_t)ip[0] | ((size_t)ip[1] << BITS_PER_BYTE);
          ip += 2;
        } else if ((kind >= LZ_KIND_RECENT_BASE) && (kind <= LZ_KIND_RECENT_MAX)) {
          off = recent.off[kind - LZ_KIND_RECENT_BASE];
        } else {
          break;
        }
      }
      if ((off == 0U) || (off > (size_t)(op - out)) || ((op + match_len) > oend)) break;
      recent_update(&recent, off);
      if (off >= 8U) {
        size_t remaining = match_len;
        while (remaining >= 8U) {
          store_u64_unaligned(op, load_u64_unaligned(op - off));
          op += 8;
          remaining -= 8U;
        }
        while (remaining-- > 0U) { *op = *(op - off); op++; }
      } else {
        while (match_len-- > 0) { *op = *(op - off); op++; }
      }
    }
  }
}

static size_t lzd_enc(const ull *input, size_t num, unsigned char *combined_buf,
                      unsigned char *out, size_t out_cap)
{
  size_t bytes = num * sizeof(ull), total = C_LZDICT_PREAMBLE_BYTES + bytes, lz_size;
  if (num < 32U) return (size_t)-1;
  fc_build_lz_dict(combined_buf);
  memcpy(combined_buf + C_LZDICT_PREAMBLE_BYTES, input, bytes);
  lz_size = lz_enc_d(combined_buf, total, C_LZDICT_PREAMBLE_BYTES,
                                         out, out_cap);
  if (lz_size > bytes) return (size_t)-1;
  return lz_size;
}

static void lzd_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t bytes = num * sizeof(ull), total = C_LZDICT_PREAMBLE_BYTES + bytes;
  unsigned char *combined = (unsigned char *)malloc(total);
  unsigned char dict[C_LZDICT_PREAMBLE_BYTES];
  if (combined == NULL) return;
  fc_build_lz_dict(dict);
  lz_dec_d(in, in_bytes, dict, C_LZDICT_PREAMBLE_BYTES, combined, total);
  memcpy(out, combined + C_LZDICT_PREAMBLE_BYTES, bytes);
  free(combined);
}

static void lz_dec(const unsigned char *in, size_t in_bytes, unsigned char *out, size_t out_bytes)
{
  const unsigned char *ip = in, *end = in + in_bytes;
  unsigned char *op = out, *oend = out + out_bytes;
  recent_t recent;
  recent_init(&recent);
  while (ip < end && op <= oend) {
    size_t lit_len, match_len, off = 0U;
    unsigned char kind;
    ip = read_varint(ip, end, &lit_len);
    if ((ip + lit_len) > end || (op + lit_len) > oend) break;
    avx2_copy(op, ip, lit_len);
    op += lit_len;
    ip += lit_len;
    ip = read_varint(ip, end, &match_len);
    if (ip >= end) break;
    kind = *ip++;
    if (match_len == 0) break;
    /* kind: 1 = explicit 16-bit offset; 2..4 = recent-offset slots; else terminates. */
    if (kind == 1U) {
      if (ip + 2 > end) break;
      off = (size_t)ip[0] | ((size_t)ip[1] << BITS_PER_BYTE);
      ip += 2;
    } else if (kind >= 2U && kind <= 4U) off = recent.off[kind - 2U];
    else break;
    if ((off == 0U) || (off > (size_t)(op - out)) || ((op + match_len) > oend)) break;
    recent_update(&recent, off);
    if (off >= 8U) {
      size_t remaining = match_len;
      while (remaining >= 8U) { store_u64_unaligned(op, load_u64_unaligned(op - off)); op += 8; remaining -= 8U; }
      while (remaining-- > 0U) { *op = *(op - off); op++; }
    } else {
      while (match_len-- > 0) { *op = *(op - off); op++; }
    }
  }
}

/* LZ_SPLIT: split LZ output into 4 streams (literals, lit_lens,
 * match_lens, kinds) tANS-coded; offsets stay raw-16. Lengths ≥255 capped with
 * follow-on raw u32 overflow.
 * Wire: [n_records:u32 LE][lit_bytes_size:u32][lit_lens_tans:u32]
 *       [match_lens_tans:u32][kinds_tans:u32][offsets_size:u32][literals]
 *       [tANS lit_lens][tANS match_lens (0=not-a-match)]
 *       [tANS kinds (0=lit, 1=offset, 2/3/4=recent)][raw offsets (2B)]. */
typedef struct {
  uint8_t  *lit_buf;       size_t lit_pos;       size_t lit_cap;
  uint8_t  *lit_len_buf;   size_t lit_len_pos;   size_t lit_len_cap;
  uint8_t  *match_len_buf; size_t match_len_pos; size_t match_len_cap;
  uint8_t  *kind_buf;      size_t kind_pos;      size_t kind_cap;
  uint16_t *offset_buf;    size_t offset_pos;    size_t offset_cap;
  uint32_t *overflow_buf;  size_t overflow_pos;  size_t overflow_cap;
} fc_lz_split_streams_t;

static int fc_lz_split_init(fc_lz_split_streams_t *s, size_t input_n)
{
  size_t worst = input_n + 64U;
  s->lit_cap = s->lit_len_cap = s->match_len_cap = s->kind_cap = s->offset_cap = worst;
  s->overflow_cap = worst / 4U + 16U;
  s->lit_buf       = (uint8_t  *)malloc(s->lit_cap);
  s->lit_len_buf   = (uint8_t  *)malloc(s->lit_len_cap);
  s->match_len_buf = (uint8_t  *)malloc(s->match_len_cap);
  s->kind_buf      = (uint8_t  *)malloc(s->kind_cap);
  s->offset_buf    = (uint16_t *)malloc(s->offset_cap * sizeof(uint16_t));
  s->overflow_buf  = (uint32_t *)malloc(s->overflow_cap * sizeof(uint32_t));
  s->lit_pos = s->lit_len_pos = s->match_len_pos = s->kind_pos = s->offset_pos = s->overflow_pos = 0;
  return (s->lit_buf && s->lit_len_buf && s->match_len_buf && s->kind_buf && s->offset_buf && s->overflow_buf) ? 1 : 0;
}

static void fc_lz_split_free(fc_lz_split_streams_t *s)
{
  free(s->lit_buf); free(s->lit_len_buf); free(s->match_len_buf);
  free(s->kind_buf); free(s->offset_buf); free(s->overflow_buf);
}

static void fc_lz_split_emit_overflow(fc_lz_split_streams_t *s, uint32_t v)
{
  if (s->overflow_pos < s->overflow_cap) s->overflow_buf[s->overflow_pos++] = v;
}

static size_t lzs_enc(const unsigned char *input, size_t n,
                                      unsigned char *out, size_t out_cap)
{
  static __thread uint64_t s_table[65536];
  static __thread uint32_t s_epoch = 0U;
  uint64_t *table = s_table;
  uint32_t epoch;
  size_t pos = 0, lit_start = 0, header_bytes = 24U, records = 0U;
  size_t total, lit_bytes_size, lit_lens_tans, match_lens_tans, kinds_tans;
  size_t offsets_bytes, overflow_bytes, off_total;
  recent_t recent;
  fc_lz_split_streams_t streams;
  unsigned char *p;
  if (n < 64U || out_cap < header_bytes) return (size_t)-1;
  if (!fc_lz_split_init(&streams, n)) { fc_lz_split_free(&streams); return (size_t)-1; }
  s_epoch++;
  if (s_epoch == 0U) { memset(s_table, 0, sizeof(s_table)); s_epoch = 1U; }
  epoch = s_epoch;
  recent_init(&recent);

  while (pos + 8 <= n) {
    size_t h = lz_hash32((uint32_t)load_u64_unaligned(input + pos));
    lz_match_t m;
    table[h] = ((uint64_t)epoch << BITS_PER_U32) | (uint32_t)pos;
    m = lz_find_match(input, n, pos, table, epoch, &recent);
    if (m.len > 0U) {
      size_t lit_len = pos - lit_start;
      uint8_t kind;
      if ((streams.lit_pos + lit_len) > streams.lit_cap) { fc_lz_split_free(&streams); return (size_t)-1; }
      memcpy(streams.lit_buf + streams.lit_pos, input + lit_start, lit_len);
      streams.lit_pos += lit_len;
      if (lit_len < 255U) streams.lit_len_buf[streams.lit_len_pos++] = (uint8_t)lit_len;
      else { streams.lit_len_buf[streams.lit_len_pos++] = 255U; fc_lz_split_emit_overflow(&streams, (uint32_t)lit_len); }
      if (m.len < 255U) streams.match_len_buf[streams.match_len_pos++] = (uint8_t)m.len;
      else { streams.match_len_buf[streams.match_len_pos++] = 255U; fc_lz_split_emit_overflow(&streams, (uint32_t)m.len); }
      if (m.recent >= 0) kind = (uint8_t)(2 + m.recent);
      else { kind = 1U; streams.offset_buf[streams.offset_pos++] = (uint16_t)m.off; }
      streams.kind_buf[streams.kind_pos++] = kind;
      recent_update(&recent, m.off);
      records++;
      pos += m.len;
      lit_start = pos;
    } else pos++;
  }
  {
    size_t lit_len = n - lit_start;
    if ((streams.lit_pos + lit_len) > streams.lit_cap) { fc_lz_split_free(&streams); return (size_t)-1; }
    memcpy(streams.lit_buf + streams.lit_pos, input + lit_start, lit_len);
    streams.lit_pos += lit_len;
    if (lit_len < 255U) streams.lit_len_buf[streams.lit_len_pos++] = (uint8_t)lit_len;
    else { streams.lit_len_buf[streams.lit_len_pos++] = 255U; fc_lz_split_emit_overflow(&streams, (uint32_t)lit_len); }
    streams.match_len_buf[streams.match_len_pos++] = 0U;
    streams.kind_buf[streams.kind_pos++] = 0U;
    records++;
  }

  lit_bytes_size = streams.lit_pos;
  offsets_bytes = streams.offset_pos * sizeof(uint16_t);
  overflow_bytes = streams.overflow_pos * sizeof(uint32_t);
  total = header_bytes + lit_bytes_size + offsets_bytes + overflow_bytes;
  if (total >= out_cap) { fc_lz_split_free(&streams); return (size_t)-1; }
  {
    unsigned char *tans_lit_lens   = (unsigned char *)malloc(streams.lit_len_pos + 1024U);
    unsigned char *tans_match_lens = (unsigned char *)malloc(streams.match_len_pos + 1024U);
    unsigned char *tans_kinds      = (unsigned char *)malloc(streams.kind_pos + 1024U);
    if (!tans_lit_lens || !tans_match_lens || !tans_kinds) { free(tans_lit_lens); free(tans_match_lens); free(tans_kinds); fc_lz_split_free(&streams); return (size_t)-1; }
    lit_lens_tans   = fc_ans_compress_bytes(streams.lit_len_buf, streams.lit_len_pos, tans_lit_lens, streams.lit_len_pos + 1024U);
    match_lens_tans = fc_ans_compress_bytes(streams.match_len_buf, streams.match_len_pos, tans_match_lens, streams.match_len_pos + 1024U);
    kinds_tans      = fc_ans_compress_bytes(streams.kind_buf, streams.kind_pos, tans_kinds, streams.kind_pos + 1024U);
    if (lit_lens_tans   == (size_t)-1) lit_lens_tans   = streams.lit_len_pos;
    if (match_lens_tans == (size_t)-1) match_lens_tans = streams.match_len_pos;
    if (kinds_tans      == (size_t)-1) kinds_tans      = streams.kind_pos;
    total = header_bytes + lit_bytes_size + lit_lens_tans + match_lens_tans + kinds_tans + offsets_bytes + overflow_bytes;
    if (total >= out_cap) { free(tans_lit_lens); free(tans_match_lens); free(tans_kinds); fc_lz_split_free(&streams); return (size_t)-1; }
    st32_le(out,      (uint32_t)records);
    st32_le(out + 4,  (uint32_t)lit_bytes_size);
    st32_le(out + 8,  (uint32_t)lit_lens_tans);
    st32_le(out + 12, (uint32_t)match_lens_tans);
    st32_le(out + 16, (uint32_t)kinds_tans);
    st32_le(out + 20, (uint32_t)offsets_bytes);
    p = out + header_bytes;
    memcpy(p, streams.lit_buf, lit_bytes_size); p += lit_bytes_size;
    if (lit_lens_tans == streams.lit_len_pos) {
      memcpy(p, streams.lit_len_buf, lit_lens_tans);
    } else {
      memcpy(p, tans_lit_lens, lit_lens_tans);
    }
    p += lit_lens_tans;
    if (match_lens_tans == streams.match_len_pos) {
      memcpy(p, streams.match_len_buf, match_lens_tans);
    } else {
      memcpy(p, tans_match_lens, match_lens_tans);
    }
    p += match_lens_tans;
    if (kinds_tans == streams.kind_pos) {
      memcpy(p, streams.kind_buf, kinds_tans);
    } else {
      memcpy(p, tans_kinds, kinds_tans);
    }
    p += kinds_tans;
    {
      size_t i;
      for (i = 0; i < streams.offset_pos; i++) { p[2 * i] = (unsigned char)(streams.offset_buf[i] & 0xff); p[2 * i + 1] = (unsigned char)((streams.offset_buf[i] >> 8) & 0xff); }
      p += offsets_bytes;
    }
    {
      size_t i;
      for (i = 0; i < streams.overflow_pos; i++) st32_le(p + 4 * i, streams.overflow_buf[i]);
      p += overflow_bytes;
    }
    off_total = (size_t)(p - out);
    free(tans_lit_lens); free(tans_match_lens); free(tans_kinds);
  }
  fc_lz_split_free(&streams);
  return off_total;
}

static void lzs_dec(const unsigned char *in, size_t in_bytes,
                                      unsigned char *out, size_t out_bytes)
{
  size_t header_bytes = 24U, records, lit_bytes_size, lit_lens_tans, match_lens_tans;
  size_t kinds_tans, offsets_bytes, r, lit_idx = 0, off_idx = 0, overflow_idx = 0;
  const unsigned char *p_lit, *p_lit_lens, *p_match_lens, *p_kinds, *p_offsets, *p_overflow;
  uint8_t *lit_lens, *match_lens, *kinds;
  recent_t recent;
  unsigned char *op = out, *oend = out + out_bytes;
  if (in_bytes < header_bytes) return;
  records = (size_t)ld32_le(in);
  lit_bytes_size = (size_t)ld32_le(in + 4);
  lit_lens_tans = (size_t)ld32_le(in + 8);
  match_lens_tans = (size_t)ld32_le(in + 12);
  kinds_tans = (size_t)ld32_le(in + 16);
  offsets_bytes = (size_t)ld32_le(in + 20);
  p_lit        = in + header_bytes;
  p_lit_lens   = p_lit + lit_bytes_size;
  p_match_lens = p_lit_lens + lit_lens_tans;
  p_kinds      = p_match_lens + match_lens_tans;
  p_offsets    = p_kinds + kinds_tans;
  p_overflow   = p_offsets + offsets_bytes;
  if (p_overflow > in + in_bytes) return;
  lit_lens   = (uint8_t *)malloc(records);
  match_lens = (uint8_t *)malloc(records);
  kinds      = (uint8_t *)malloc(records);
  if (!lit_lens || !match_lens || !kinds) goto cleanup;
  /* tans_size == records ⇒ encoder fell back to raw; else tANS-decode. */
  if (lit_lens_tans == records) memcpy(lit_lens, p_lit_lens, records);
  else if (fc_ans_decode_bytes(p_lit_lens, lit_lens_tans, records, lit_lens) != records) goto cleanup;
  if (match_lens_tans == records) memcpy(match_lens, p_match_lens, records);
  else if (fc_ans_decode_bytes(p_match_lens, match_lens_tans, records, match_lens) != records) goto cleanup;
  if (kinds_tans == records) memcpy(kinds, p_kinds, records);
  else if (fc_ans_decode_bytes(p_kinds, kinds_tans, records, kinds) != records) goto cleanup;

  recent_init(&recent);
  for (r = 0; r < records; r++) {
    size_t lit_len = (size_t)lit_lens[r];
    size_t match_len = (size_t)match_lens[r];
    size_t off = 0U;
    uint8_t kind = kinds[r];
    if (lit_len == 255U) {
      const unsigned char *o = p_overflow + 4U * overflow_idx;
      if (o + 4U > in + in_bytes) goto cleanup;
      lit_len = (size_t)ld32_le(o); overflow_idx++;
    }
    if (match_len == 255U) {
      const unsigned char *o = p_overflow + 4U * overflow_idx;
      if (o + 4U > in + in_bytes) goto cleanup;
      match_len = (size_t)ld32_le(o); overflow_idx++;
    }
    if ((lit_idx + lit_len) > lit_bytes_size || (op + lit_len) > oend) goto cleanup;
    avx2_copy(op, p_lit + lit_idx, lit_len);
    op += lit_len;
    lit_idx += lit_len;
    if (match_len == 0) continue;
    if (kind == 1U) {
      const unsigned char *o = p_offsets + 2U * off_idx;
      if (o + 2U > p_overflow) goto cleanup;
      off = (size_t)o[0] | ((size_t)o[1] << 8);
      off_idx++;
    } else if (kind >= 2U && kind <= 4U) off = recent.off[kind - 2U];
    else goto cleanup;
    if ((op + match_len) > oend || off == 0U || off > (size_t)(op - out)) goto cleanup;
    recent_update(&recent, off);
    if (off >= 8U) {
      while (match_len >= 8U) { store_u64_unaligned(op, load_u64_unaligned(op - off)); op += 8; match_len -= 8U; }
      while (match_len-- > 0U) { *op = *(op - off); op++; }
    } else while (match_len-- > 0) { *op = *(op - off); op++; }
  }
cleanup:
  free(lit_lens); free(match_lens); free(kinds);
}

static int f32_enc(const ull *input, size_t num, unsigned char *out)
{
  size_t i;
  for (i = 0; i < num; i++) {
    double d;
    double round_trip;
    float f;
    ull a;
    ull b;
    memcpy(&d, &input[i], sizeof(d));
    f = (float)d;
    round_trip = (double)f;
    /* Bit-exact round-trip check (NaN-safe; not an epsilon comparison). */
    memcpy(&a, &d, sizeof(a));
    memcpy(&b, &round_trip, sizeof(b));
    if (a != b) return 0;
    memcpy(out + ((size_t)i * sizeof(float)), &f, sizeof(f));
  }
  return 1;
}

static void f32_dec(const unsigned char *in, size_t num, ull *out)
{
  size_t i;
  for (i = 0; i < num; i++) {
    float f;
    double d;
    memcpy(&f, in + ((size_t)i * sizeof(float)), sizeof(f));
    d = (double)f;
    memcpy(&out[i], &d, sizeof(d));
  }
}

static size_t ord_delta_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  size_t i, width;
  ull prev, max_zz = 0;
  bw_t bw;
  if (num <= 0) return 0;
  prev = float_ordered(input[0]);
  for (i = 1; i < num; i++) {
    ull cur = float_ordered(input[i]);
    ull zz = zigzag64((long long)(cur - prev));
    if (zz > max_zz) max_zz = zz;
    prev = cur;
  }
  width = bits_required64(max_zz);
  if (width == 0) width = 1;
  if (9 + (((size_t)(num - 1) * (size_t)width + 7) >> 3) > out_cap) return (size_t)-1;
  store_u64_unaligned(out, float_ordered(input[0]));
  out[8] = (unsigned char)width;
  bw_init(&bw, out + 9, out_cap - 9);
  prev = float_ordered(input[0]);
  /* BMI2 fast path: pack 4 same-width zigzag deltas at a time
     when 4 * width <= 64. Falls back to per-value put for the tail. */
  i = 1;
  if (width <= 16U) {
    while ((i + 4U) <= num) {
      ull c0 = float_ordered(input[i]);
      ull z0 = zigzag64((long long)(c0 - prev));
      ull c1 = float_ordered(input[i + 1U]);
      ull z1 = zigzag64((long long)(c1 - c0));
      ull c2 = float_ordered(input[i + 2U]);
      ull z2 = zigzag64((long long)(c2 - c1));
      ull c3 = float_ordered(input[i + 3U]);
      ull z3 = zigzag64((long long)(c3 - c2));
      bw_put4(&bw, z0, z1, z2, z3, width);
      prev = c3;
      i += 4U;
    }
  }
  for (; i < num; i++) {
    ull cur = float_ordered(input[i]);
    bw_put(&bw, zigzag64((long long)(cur - prev)), width);
    prev = cur;
  }
  return 9 + bw_bytes(&bw);
}

static void ord_delta_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t i, width;
  ull prev;
  br_t br;
  if (num <= 0) return;
  prev = load_u64_unaligned(in);
  width = in[8];
  out[0] = float_unordered(prev);
  br_init(&br, in + 9, in_bytes - 9);
  for (i = 1; i < num; i++) {
    ull zz = br_get(&br, width);
    prev += (ull)unzigzag64(zz);
    out[i] = float_unordered(prev);
  }
}

static size_t fzs_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  size_t i, width;
  ull base, stride, expected, max_zz = 0;
  bw_t bw;
  if (num <= 0) return 0;
  base = input[0];
  stride = (num > 1) ? input[1] - input[0] : 0;
  expected = base;
  for (i = 0; i < num; i++) {
    ull zz = zigzag64((long long)(input[i] - expected));
    if (zz > max_zz) max_zz = zz;
    expected += stride;
  }
  width = bits_required64(max_zz);
  if (width == 0) width = 1;
  if (17 + (((size_t)num * (size_t)width + 7) >> 3) > out_cap) return (size_t)-1;
  store_u64_unaligned(out, base);
  store_u64_unaligned(out + 8, stride);
  out[16] = (unsigned char)width;
  bw_init(&bw, out + 17, out_cap - 17);
  expected = base;
  for (i = 0; i < num; i++) { bw_put(&bw, zigzag64((long long)(input[i] - expected)), width); expected += stride; }
  return 17 + bw_bytes(&bw);
}

static void fzs_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t i, width;
  ull expected, stride;
  br_t br;
  expected = load_u64_unaligned(in);
  stride = load_u64_unaligned(in + 8);
  width = in[16];
  br_init(&br, in + 17, in_bytes - 17);
  for (i = 0; i < num; i++) { out[i] = expected + (ull)unzigzag64(br_get(&br, width)); expected += stride; }
}

static size_t alp_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  static const double scales[] = {1.0, 10.0, 100.0, 1000.0, 10000.0, 1000000.0};
  int scale_id;
  for (scale_id = 0; scale_id < (int)(sizeof(scales) / sizeof(scales[0])); scale_id++) {
    double scale = scales[scale_id];
    long long first = 0, prev = 0;
    ull max_zz = 0;
    size_t width, i;
    bw_t bw;
    for (i = 0; i < num; i++) {
      double d, scaled, back;
      long long q;
      ull a, b;
      memcpy(&d, &input[i], sizeof(d));
      scaled = d * scale;
      if (scaled < -9223372036854774784.0 || scaled > 9223372036854774784.0) break;
      q = (long long)(scaled >= 0.0 ? scaled + 0.5 : scaled - 0.5);
      back = (double)q / scale;
      memcpy(&a, &back, sizeof(a)); memcpy(&b, &d, sizeof(b));
      if (a != b) break;
      if (i == 0) { first = q; prev = q; }
      else { ull zz = zigzag64(q - prev); if (zz > max_zz) max_zz = zz; prev = q; }
    }
    if (i != num) continue;

    width = bits_required64(max_zz);
    if (width == 0) width = 1;
    if (10 + (((size_t)(num - 1) * (size_t)width + 7) >> 3) > out_cap) continue;
    out[0] = (unsigned char)scale_id;
    out[1] = (unsigned char)width;
    store_u64_unaligned(out + 2, (ull)first);
    bw_init(&bw, out + 10, out_cap - 10);
    prev = first;
    for (i = 1; i < num; i++) {
      double d;
      long long q;
      memcpy(&d, &input[i], sizeof(d));
      q = (long long)(d * scale + (d >= 0.0 ? 0.5 : -0.5));
      bw_put(&bw, zigzag64(q - prev), width);
      prev = q;
    }
    return 10 + bw_bytes(&bw);
  }
  return (size_t)-1;
}

static void alp_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  static const double scales[] = {1.0, 10.0, 100.0, 1000.0, 10000.0, 1000000.0};
  size_t scale_id = (size_t)in[0];
  size_t width = (size_t)in[1];
  long long prev = (long long)load_u64_unaligned(in + 2);
  size_t i;
  br_t br;
  double d = (double)prev / scales[scale_id];
  memcpy(&out[0], &d, sizeof(d));
  br_init(&br, in + 10, in_bytes - 10);
  for (i = 1; i < num; i++) {
    prev += unzigzag64(br_get(&br, width));
    d = (double)prev / scales[scale_id];
    memcpy(&out[i], &d, sizeof(d));
  }
}

static size_t tzbp_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  size_t i, min_tz = BITS_PER_U64, width;
  bw_t bw;
  for (i = 0; i < num; i++) {
    size_t tz = (input[i] != 0U) ? ctz64_nonzero(input[i]) : (size_t)BITS_PER_U64;
    if (tz < min_tz) min_tz = tz;
  }
  if ((min_tz == 0U) || (min_tz >= BITS_PER_U64)) return (size_t)-1;
  width = BITS_PER_U64 - min_tz;
  if ((1U + (((num * width) + 7U) >> 3U)) > out_cap) return (size_t)-1;
  out[0] = (unsigned char)min_tz;
  bw_init(&bw, out + 1, out_cap - 1U);
  for (i = 0; i < num; i++) bw_put(&bw, input[i] >> min_tz, width);
  return 1U + bw_bytes(&bw);
}

static void tzbp_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t i, shift = (size_t)in[0], width = BITS_PER_U64 - shift;
  br_t br;
  br_init(&br, in + 1, in_bytes - 1U);
  for (i = 0; i < num; i++) out[i] = br_get(&br, width) << shift;
}

static size_t xor128_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  enum { XOR_HIST_LEN = 128, XOR_BUCKET_LEN = 1024, XOR_AGE_BITS = 7 };
  ull hist[XOR_HIST_LEN], bucket_val[XOR_BUCKET_LEN];
  size_t bucket_idx[XOR_BUCKET_LEN], inserts = 0U, hist_pos = 0, i;
  bw_t bw;
  if (num == 0U) return 0U;
  if (out_cap < sizeof(ull)) return (size_t)-1;
  memset(hist, 0, sizeof(hist));
  /* All-ones is an "impossible" insert index so first lookup misses cleanly. */
  memset(bucket_idx, 0xff, sizeof(bucket_idx));
  store_u64_unaligned(out, input[0]);
  hist[hist_pos] = input[0];
  bucket_val[fc_crc32_u64(input[0]) & (XOR_BUCKET_LEN - 1U)] = input[0];
  bucket_idx[fc_crc32_u64(input[0]) & (XOR_BUCKET_LEN - 1U)] = inserts;
  inserts++;
  hist_pos = (hist_pos + 1U) & (XOR_HIST_LEN - 1U);
  bw_init(&bw, out + sizeof(ull), out_cap - sizeof(ull));
  for (i = 1; i < num; i++) {
    ull v = input[i];
    size_t h = fc_crc32_u64(v) & (XOR_BUCKET_LEN - 1U);
    int found = -1;
    if (bucket_val[h] == v) {
      size_t age = inserts - 1U - bucket_idx[h];
      if (age < XOR_HIST_LEN && hist[(hist_pos - 1U - age) & (XOR_HIST_LEN - 1U)] == v) found = (int)age;
    }
    if (found >= 0) { bw_put(&bw, 1U, 1); bw_put(&bw, (ull)found, XOR_AGE_BITS); }
    else { bw_put(&bw, 0U, 1); bw_put(&bw, v, BITS_PER_U64); }
    hist[hist_pos] = v;
    bucket_val[h] = v;
    bucket_idx[h] = inserts;
    inserts++;
    hist_pos = (hist_pos + 1U) & (XOR_HIST_LEN - 1U);
  }
  return sizeof(ull) + bw_bytes(&bw);
}

static void xor128_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  enum { XOR_HIST_LEN = 128, XOR_AGE_BITS = 7 };
  ull hist[XOR_HIST_LEN];
  size_t hist_pos = 0, i;
  br_t br;
  if (num == 0U) return;
  memset(hist, 0, sizeof(hist));
  out[0] = load_u64_unaligned(in);
  hist[hist_pos] = out[0];
  hist_pos = (hist_pos + 1U) & (XOR_HIST_LEN - 1U);
  br_init(&br, in + sizeof(ull), in_bytes - sizeof(ull));
  for (i = 1; i < num; i++) {
    ull value;
    if (br_get(&br, 1) != 0U) {
      size_t age = (size_t)br_get(&br, XOR_AGE_BITS);
      value = hist[(hist_pos - 1U - age) & (XOR_HIST_LEN - 1U)];
    } else {
      value = br_get(&br, BITS_PER_U64);
    }
    out[i] = value;
    hist[hist_pos] = value;
    hist_pos = (hist_pos + 1U) & (XOR_HIST_LEN - 1U);
  }
}

/* Elf: XOR-stream with α-erase leading-zero context reuse.
 * Per value: bit 0 zero-diff flag; if 1, bit 1 reuse-context flag:
 *   0 → reuse: read C_ELF_DELTA_BITS-bit signed leading-delta; sigbits = prev;
 *              then prev_sigbits raw payload bits.
 *   1 → rebuild: read 5-bit leading, 6-bit sigbits (0=64), then raw bits.
 * Wire: [input[0]:u64][bit-packed encoding of input[1..num)]. */
static size_t elf_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  size_t i, prev_leading = 64U, prev_sigbits = 0U;
  ull prev;
  bw_t bw;
  if (num == 0U) return 0U;
  if (out_cap < 8U) return (size_t)-1;
  store_u64_unaligned(out, input[0]);
  bw_init(&bw, out + 8, out_cap - 8U);
  prev = input[0];
  for (i = 1; i < num; i++) {
    ull v = input[i];
    ull x = v ^ prev;
    if (x == 0U) {
      bw_put(&bw, 0U, 1);
    } else {
      size_t leading = clz64_nonzero(x);
      size_t trailing = ctz64_nonzero(x);
      size_t sigbits = BITS_PER_U64 - leading - trailing;
      bw_put(&bw, 1U, 1);
      if (prev_leading != 64U && sigbits <= prev_sigbits) {
        long long delta = (long long)leading - (long long)prev_leading;
        long long delta_min = -(1LL << (C_ELF_DELTA_BITS - 1));
        long long delta_max =  (1LL << (C_ELF_DELTA_BITS - 1)) - 1LL;
        if (delta >= delta_min && delta <= delta_max) {
          size_t prev_trailing = BITS_PER_U64 - prev_leading - prev_sigbits;
          ull delta_bits = (ull)(delta - delta_min);
          bw_put(&bw, 0U, 1);
          bw_put(&bw, delta_bits, C_ELF_DELTA_BITS);
          bw_put(&bw, x >> prev_trailing, prev_sigbits);
          prev_leading = (size_t)((long long)prev_leading + delta);
          prev = v;
          continue;
        }
      }
      bw_put(&bw, 1U, 1);
      bw_put(&bw, (ull)leading, 5);
      bw_put(&bw, (ull)(sigbits == BITS_PER_U64 ? 0U : sigbits), 6);
      bw_put(&bw, x >> trailing, sigbits);
      prev_leading = leading;
      prev_sigbits = sigbits;
    }
    prev = v;
  }
  return 8U + bw_bytes(&bw);
}

static void elf_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t i, prev_leading = 64U, prev_sigbits = 0U;
  ull prev;
  br_t br;
  if (num == 0U) return;
  out[0] = load_u64_unaligned(in);
  prev = out[0];
  br_init(&br, in + 8, in_bytes - 8U);
  for (i = 1; i < num; i++) {
    ull v;
    if (br_get(&br, 1) == 0U) {
      v = prev;
    } else {
      ull x;
      ull payload;
      if (br_get(&br, 1) == 0U) {
        ull delta_bits = br_get(&br, C_ELF_DELTA_BITS);
        long long delta_min = -(1LL << (C_ELF_DELTA_BITS - 1));
        long long delta = (long long)delta_bits + delta_min;
        size_t prev_trailing;
        prev_leading = (size_t)((long long)prev_leading + delta);
        prev_trailing = BITS_PER_U64 - prev_leading - prev_sigbits;
        payload = br_get(&br, prev_sigbits);
        x = payload << prev_trailing;
      } else {
        prev_leading = (size_t)br_get(&br, 5);
        prev_sigbits = (size_t)br_get(&br, 6);
        if (prev_sigbits == 0U) prev_sigbits = BITS_PER_U64;
        payload = br_get(&br, prev_sigbits);
        x = payload << (BITS_PER_U64 - prev_leading - prev_sigbits);
      }
      v = prev ^ x;
    }
    out[i] = v;
    prev = v;
  }
}

static void byte_transpose8(const unsigned char *src, size_t values, unsigned char *dst)
{
  size_t i, plane;
  for (plane = 0U; plane < 8U; plane++)
    for (i = 0U; i < values; i++) dst[plane * values + i] = src[i * 8U + plane];
}

static void byte_untranspose8(const unsigned char *src, size_t values, unsigned char *dst)
{
  size_t i, plane;
  for (plane = 0U; plane < 8U; plane++)
    for (i = 0U; i < values; i++) dst[i * 8U + plane] = src[plane * values + i];
}

static size_t byte_xpose_enc(const ull *input, size_t num, unsigned char *tmp, unsigned char *out, size_t out_cap)
{
  size_t raw_bytes = (size_t)num * sizeof(ull);
  byte_transpose8((const unsigned char *)(const void *)input, (size_t)num, tmp);
  return lz_enc(tmp, raw_bytes, out, out_cap);
}

static void byte_xpose_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  static __thread unsigned char *g_xp_tmp = NULL;
  static __thread size_t g_xp_cap = 0U;
  size_t raw_bytes = (size_t)num * sizeof(ull);
  if (g_xp_cap < raw_bytes) {
    size_t new_cap = raw_bytes < 4096U ? 4096U : raw_bytes;
    unsigned char *nb = (unsigned char *)realloc(g_xp_tmp, new_cap);
    if (!nb) return;
    g_xp_tmp = nb; g_xp_cap = new_cap;
  }
  lz_dec(in, in_bytes, g_xp_tmp, raw_bytes);
  byte_untranspose8(g_xp_tmp, (size_t)num, (unsigned char *)(void *)out);
}

/* LSB-strip / Bit-Weaving: when the low k bits of every value
   look like noise (flip ~50% across consecutive values), strip them and
   store raw, then predictor-encode (val >> k) which has lower entropy. */
static size_t lsb_strip_probe_k(const ull *input, size_t num)
{
  enum { LSB_PROBE_BITS = 52, LSB_PROBE_SAMPLES = 4096, LSB_FLIP_THRESHOLD_PCT = 35 };
  uint32_t flip[LSB_PROBE_BITS] = {0};
  size_t sample_n, i, b, k;
  if (num < 64U) return 0U;
  sample_n = num - 1U;
  if (sample_n > LSB_PROBE_SAMPLES) sample_n = LSB_PROBE_SAMPLES;
  for (i = 0; i < sample_n; i++) { ull x = input[i + 1] ^ input[i]; for (b = 0; b < LSB_PROBE_BITS; b++) flip[b] += (uint32_t)((x >> b) & 1ULL); }
  /* k = highest bit index whose flip rate >= threshold (then add 1 to get count). */
  k = 0U;
  for (b = 0; b < LSB_PROBE_BITS; b++)
    if (((size_t)flip[b] * 100U) >= (sample_n * (size_t)LSB_FLIP_THRESHOLD_PCT)) k = b + 1U;
  k &= ~(size_t)3U;
  if (k > 48U) k = 48U;
  return k;
}

static size_t lsb_enc(const ull *input, size_t num, size_t predsizem1, ull *fcm, ull *dfcm, unsigned char *scratch, unsigned char *out, size_t out_cap)
{
  size_t k = lsb_strip_probe_k(input, num), i, fc_bytes, lsb_bytes;
  ull *highs, mask;
  unsigned char *fc_out;
  bw_t bw;
  if (k < 8) return (size_t)-1;
  highs = (ull *)(void *)scratch;
  fc_out = scratch + (num * sizeof(ull));
  mask = (1ULL << k) - 1ULL;
  for (i = 0; i < num; i++) highs[i] = input[i] >> k;
  fc_bytes = pred_enc(highs, num, predsizem1, fcm, dfcm, fc_out);
  {
    /* Header: 1 byte k + sizeof(uint32_t) bytes encoding fc_bytes. */
    const size_t header_bytes = 1U + sizeof(uint32_t);
    lsb_bytes = (((size_t)k * num) + 7U) >> 3;
    if ((header_bytes + fc_bytes + lsb_bytes) > out_cap) return (size_t)-1;
    out[0] = (unsigned char)k;
    st32_le(out + 1, (uint32_t)fc_bytes);
    memcpy(out + header_bytes, fc_out, fc_bytes);
    bw_init(&bw, out + header_bytes + fc_bytes, lsb_bytes);
    for (i = 0; i < num; i++) bw_put(&bw, input[i] & mask, k);
    return header_bytes + fc_bytes + bw_bytes(&bw);
  }
}

static void lsb_dec(const unsigned char *in, size_t in_bytes, size_t num, size_t predsizem1, ull *fcm, ull *dfcm, ull *out)
{
  const size_t header_bytes = 1U + sizeof(uint32_t);
  size_t k = (size_t)in[0], fc_bytes = (size_t)ld32_le(in + 1), i;
  ull mask = ((ull)1U << k) - 1ULL;
  br_t br;
  pred_dec(in + header_bytes, fc_bytes, num, predsizem1, fcm, dfcm, out);
  br_init(&br, in + header_bytes + fc_bytes, in_bytes - header_bytes - fc_bytes);
  for (i = 0; i < num; i++) { ull lo = br_get(&br, k); out[i] = (out[i] << k) | (lo & mask); }
}

/* Lookback-Delta: encode x[i] - x[i-k] in float-ordered
   space for the optimal lookback k from {1,2,4,8,16,32,64,128}.
   Wins on periodic data (e.g. seasonal/daily) where higher-k deltas are
   smaller than first-order. */
static const size_t fc_lookback_k_table[C_LOOKBACK_K_COUNT] = {
  1U, 2U, 4U, 8U, 16U, 32U, 64U, 128U,
  256U, 512U, 1024U, 2048U, 4096U, 8192U, 16384U
};

static size_t lbd_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  enum { LOOKBACK_PROBE_DELTAS = 1024 };
  size_t best_k_index = 0U, best_total = SIZE_MAX, kx, i, k, width, total, header_bytes;
  bw_t bw;
  if (num < 2U) return (size_t)-1;
  for (kx = 0; kx < C_LOOKBACK_K_COUNT; kx++) {
    size_t kk = fc_lookback_k_table[kx];
    ull max_zz = 0;
    size_t scan_end;
    if (kk >= num) break;
    scan_end = num;
    if ((scan_end - kk) > LOOKBACK_PROBE_DELTAS) scan_end = kk + LOOKBACK_PROBE_DELTAS;
    for (i = kk; i < scan_end; i++) { ull zz = zigzag64((long long)(float_ordered(input[i]) - float_ordered(input[i - kk]))); if (zz > max_zz) max_zz = zz; }
    width = bits_required64(max_zz);
    if (width == 0U) width = 1U;
    total = 2U + (kk * sizeof(ull)) + (((num - kk) * width) + 7U) / 8U;
    if (total < best_total) { best_total = total; best_k_index = kx; }
  }
  if (best_total == SIZE_MAX) return (size_t)-1;
  k = fc_lookback_k_table[best_k_index];
  {
    ull max_zz = 0;
    for (i = k; i < num; i++) { ull zz = zigzag64((long long)(float_ordered(input[i]) - float_ordered(input[i - k]))); if (zz > max_zz) max_zz = zz; }
    width = bits_required64(max_zz);
    if (width == 0U) width = 1U;
  }
  header_bytes = 2U + (k * sizeof(ull));
  if ((header_bytes + (((num - k) * width) + 7U) / 8U) > out_cap) return (size_t)-1;
  out[0] = (unsigned char)best_k_index;
  out[1] = (unsigned char)width;
  for (i = 0; i < k; i++) store_u64_unaligned(out + 2U + (i * sizeof(ull)), float_ordered(input[i]));
  bw_init(&bw, out + header_bytes, out_cap - header_bytes);
  for (i = k; i < num; i++)
    bw_put(&bw, zigzag64((long long)(float_ordered(input[i]) - float_ordered(input[i - k]))), width);
  return header_bytes + bw_bytes(&bw);
}

static void lbd_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t k_index = (size_t)in[0], width = (size_t)in[1], k, header_bytes, i;
  br_t br;
  if (k_index >= C_LOOKBACK_K_COUNT) return;
  k = fc_lookback_k_table[k_index];
  header_bytes = 2U + (k * sizeof(ull));
  for (i = 0; i < k; i++) out[i] = float_unordered(load_u64_unaligned(in + 2U + (i * sizeof(ull))));
  br_init(&br, in + header_bytes, in_bytes - header_bytes);
  for (i = k; i < num; i++)
    out[i] = float_unordered(float_ordered(out[i - k]) + (ull)unzigzag64(br_get(&br, width)));
}

/* Delta2: d[i] = ord[i] - 2·ord[i-1] + ord[i-2] (mod 2^64).
 * Wire: [ord[0]:u64][ord[1]:u64][width:u8][zigzag(d[i]) for i in [2,num)]. */
static size_t d2_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  size_t i, width;
  ull o0, o1, o2, max_zz = 0U;
  bw_t bw;

  if (num < 3U) return (size_t)-1;
  if (out_cap < 17U) return (size_t)-1;
  o0 = float_ordered(input[0]);
  o1 = float_ordered(input[1]);
  for (i = 2; i < num; i++) {
    ull diff;
    ull zz;
    o2 = float_ordered(input[i]);
    diff = o2 - (o1 << 1) + o0;
    zz = zigzag64((long long)diff);
    if (zz > max_zz) max_zz = zz;
    o0 = o1;
    o1 = o2;
  }
  width = bits_required64(max_zz);
  if (width == 0U) width = 1U;
  if ((17U + (((num - 2U) * width + 7U) >> 3)) > out_cap) return (size_t)-1;
  store_u64_unaligned(out, float_ordered(input[0]));
  store_u64_unaligned(out + 8, float_ordered(input[1]));
  out[16] = (unsigned char)width;
  bw_init(&bw, out + 17, out_cap - 17U);
  o0 = float_ordered(input[0]);
  o1 = float_ordered(input[1]);
  for (i = 2; i < num; i++) {
    ull diff;
    o2 = float_ordered(input[i]);
    diff = o2 - (o1 << 1) + o0;
    bw_put(&bw, zigzag64((long long)diff), width);
    o0 = o1;
    o1 = o2;
  }
  return 17U + bw_bytes(&bw);
}

static void d2_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t i;
  ull o0;
  ull o1;
  size_t width;
  br_t br;
  if (num == 0U) return;
  o0 = load_u64_unaligned(in);
  out[0] = float_unordered(o0);
  if (num == 1U) return;
  o1 = load_u64_unaligned(in + 8);
  out[1] = float_unordered(o1);
  if (num == 2U) return;
  width = (size_t)in[16];
  br_init(&br, in + 17, in_bytes - 17U);
  for (i = 2; i < num; i++) {
    ull zz = br_get(&br, width);
    long long d = unzigzag64(zz);
    ull o2 = (o1 << 1) - o0 + (ull)d;
    out[i] = float_unordered(o2);
    o0 = o1;
    o1 = o2;
  }
}

/* BitPlane: split f64 into (sign[1]|exp[11]|mant[52]); signs
 * raw 1bpv; exps as zigzag-delta width≤12; mantissa raw 52bpv.
 * Wire: [exp_width:u8][packed signs][first exp (11b) + (num-1) zigzag deltas]
 *       [packed 52-bit mantissas]. */
static size_t bp_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  size_t i, exp_width, prev_exp, header_bytes, signs_bytes, exp_bytes, mant_bytes, total_bytes;
  ull max_zz = 0U;
  bw_t bw_signs, bw_exps, bw_mant;
  unsigned char *p_signs, *p_exps, *p_mant;
  if (num < 2U) return (size_t)-1;
  prev_exp = (size_t)((input[0] >> 52U) & 0x7ffULL);
  for (i = 1; i < num; i++) {
    size_t cur_exp = (size_t)((input[i] >> 52U) & 0x7ffULL);
    long long d = (long long)cur_exp - (long long)prev_exp;
    ull zz = zigzag64(d);
    if (zz > max_zz) max_zz = zz;
    prev_exp = cur_exp;
  }
  exp_width = bits_required64(max_zz);
  if (exp_width == 0U) exp_width = 1U;
  if (exp_width > 12U) exp_width = 12U;

  header_bytes = 1U;
  signs_bytes = (num + 7U) >> 3;
  exp_bytes = ((11U + ((num - 1U) * exp_width)) + 7U) >> 3;
  mant_bytes = ((num * 52U) + 7U) >> 3;
  total_bytes = header_bytes + signs_bytes + exp_bytes + mant_bytes;
  if (total_bytes > out_cap) return (size_t)-1;

  out[0] = (unsigned char)exp_width;
  p_signs = out + header_bytes;
  p_exps  = p_signs + signs_bytes;
  p_mant  = p_exps + exp_bytes;
  bw_init(&bw_signs, p_signs, signs_bytes);
  bw_init(&bw_exps,  p_exps,  exp_bytes);
  bw_init(&bw_mant,  p_mant,  mant_bytes);
  prev_exp = (size_t)((input[0] >> 52U) & 0x7ffULL);
  bw_put(&bw_exps, (ull)prev_exp, 11);
  bw_put(&bw_signs, (input[0] >> 63U) & 1ULL, 1);
  bw_put(&bw_mant,  input[0] & ((1ULL << 52U) - 1ULL), 52);
  for (i = 1; i < num; i++) {
    size_t cur_exp = (size_t)((input[i] >> 52U) & 0x7ffULL);
    long long d = (long long)cur_exp - (long long)prev_exp;
    bw_put(&bw_exps, zigzag64(d), exp_width);
    bw_put(&bw_signs, (input[i] >> 63U) & 1ULL, 1);
    bw_put(&bw_mant,  input[i] & ((1ULL << 52U) - 1ULL), 52);
    prev_exp = cur_exp;
  }
  (void)bw_bytes(&bw_signs);
  (void)bw_bytes(&bw_exps);
  (void)bw_bytes(&bw_mant);
  return total_bytes;
}

static void bp_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t i, exp_width, prev_exp, signs_bytes, exp_bytes, mant_bytes;
  br_t br_signs, br_exps, br_mant;
  if (num == 0U) return;
  exp_width = (size_t)in[0];
  signs_bytes = (num + 7U) >> 3;
  exp_bytes = ((11U + ((num - 1U) * exp_width)) + 7U) >> 3;
  mant_bytes = ((num * 52U) + 7U) >> 3;
  (void)in_bytes;
  br_init(&br_signs, in + 1U, signs_bytes);
  br_init(&br_exps,  in + 1U + signs_bytes, exp_bytes);
  br_init(&br_mant,  in + 1U + signs_bytes + exp_bytes, mant_bytes);
  prev_exp = (size_t)br_get(&br_exps, 11);
  {
    ull s = br_get(&br_signs, 1);
    ull m = br_get(&br_mant, 52);
    out[0] = (s << 63U) | ((ull)prev_exp << 52U) | m;
  }
  for (i = 1; i < num; i++) {
    long long d = unzigzag64(br_get(&br_exps, exp_width));
    ull s = br_get(&br_signs, 1);
    ull m = br_get(&br_mant, 52);
    prev_exp = (size_t)((long long)prev_exp + d) & 0x7ffU;
    out[i] = (s << 63U) | ((ull)prev_exp << 52U) | m;
  }
}

/* IntMult: GCD-based base B in ordered space; encode q where
 * x = q*B + adj. Probe: GCD of smallest few first-order |diff|.
 * Wire: [B:u64][ord[0]:u64][zigzag_q_delta_width:u8][packed zigzag q deltas]. */
static ull fc_gcd_u64(ull a, ull b)
{
  while (b != 0U) {
    ull t = a % b;
    a = b;
    b = t;
  }
  return a;
}

static size_t imul_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  enum { IM_PROBE = 64, IM_VALIDATE_THRESH_NUM = 95, IM_VALIDATE_THRESH_DEN = 100 };
  size_t i, width, header_bytes = 17U, valid;
  ull base = 0, prev_ord, cur_ord, max_zz = 0;
  long long prev_q;
  bw_t bw;
  if (num < 4U) return (size_t)-1;
  /* Random sampling for periodic-structure detection. */
  prev_ord = float_ordered(input[0]);
  if (num >= 1024U) {
    size_t probe_n = IM_PROBE;
    uint8_t *visited = (uint8_t *)malloc((num + 7U) >> 3);
    size_t *idx_buf = (size_t *)malloc(probe_n * sizeof(size_t));
    if (visited && idx_buf) {
      fc_sample_unique((uint64_t)num ^ (uint64_t)input[0], num, probe_n, visited, idx_buf);
      for (i = 0; i < probe_n; i++) {
        size_t pos = idx_buf[i];
        ull diff;
        if (pos == 0U) continue;
        cur_ord = float_ordered(input[pos]);
        prev_ord = float_ordered(input[pos - 1U]);
        diff = (cur_ord >= prev_ord) ? (cur_ord - prev_ord) : (prev_ord - cur_ord);
        if (diff != 0U) base = (base == 0U) ? diff : fc_gcd_u64(base, diff);
      }
    }
    free(visited); free(idx_buf);
    prev_ord = float_ordered(input[0]);
  } else {
    size_t probe_n = (num < IM_PROBE) ? num : IM_PROBE;
    for (i = 1; i < probe_n; i++) {
      ull diff;
      cur_ord = float_ordered(input[i]);
      diff = (cur_ord >= prev_ord) ? (cur_ord - prev_ord) : (prev_ord - cur_ord);
      if (diff != 0U) base = (base == 0U) ? diff : fc_gcd_u64(base, diff);
      prev_ord = cur_ord;
    }
  }
  if (base < 2U) return (size_t)-1;
  valid = 0U;
  prev_ord = float_ordered(input[0]);
  for (i = 1; i < num; i++) {
    ull diff;
    cur_ord = float_ordered(input[i]);
    diff = (cur_ord >= prev_ord) ? (cur_ord - prev_ord) : (prev_ord - cur_ord);
    if (diff % base == 0U) valid++;
    prev_ord = cur_ord;
  }
  if (valid * IM_VALIDATE_THRESH_DEN < (num - 1U) * IM_VALIDATE_THRESH_NUM) return (size_t)-1;
  if (valid != num - 1U) return (size_t)-1;  /* lossless: every diff must divide */
  /* cubic-concentration gate. */
  if (base < 16U) {
    double threshold = fc_im_significance_threshold((int)(num < 256U ? num : 256U), 0.5);
    if (threshold > 0.95) return (size_t)-1;
  }
  prev_ord = float_ordered(input[0]);
  prev_q = 0;
  for (i = 1; i < num; i++) {
    long long q;
    ull diff, zz;
    cur_ord = float_ordered(input[i]);
    if (cur_ord >= prev_ord) { diff = cur_ord - prev_ord; q = (long long)(diff / base); }
    else { diff = prev_ord - cur_ord; q = -(long long)(diff / base); }
    zz = zigzag64(q - prev_q);
    if (zz > max_zz) max_zz = zz;
    prev_q = q; prev_ord = cur_ord;
  }
  width = bits_required64(max_zz);
  if (width == 0U) width = 1U;
  if ((header_bytes + (((num - 1U) * width + 7U) >> 3)) > out_cap) return (size_t)-1;

  store_u64_unaligned(out, base);
  store_u64_unaligned(out + 8, float_ordered(input[0]));
  out[16] = (unsigned char)width;
  bw_init(&bw, out + header_bytes, out_cap - header_bytes);
  prev_ord = float_ordered(input[0]);
  prev_q = 0;
  for (i = 1; i < num; i++) {
    long long q;
    ull diff;
    cur_ord = float_ordered(input[i]);
    if (cur_ord >= prev_ord) { diff = cur_ord - prev_ord; q = (long long)(diff / base); }
    else { diff = prev_ord - cur_ord; q = -(long long)(diff / base); }
    bw_put(&bw, zigzag64(q - prev_q), width);
    prev_q = q; prev_ord = cur_ord;
  }
  return header_bytes + bw_bytes(&bw);
}

static void imul_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t i, width;
  ull base, prev_ord;
  long long prev_q = 0;
  br_t br;
  if (num == 0U) return;
  base = load_u64_unaligned(in);
  prev_ord = load_u64_unaligned(in + 8);
  width = (size_t)in[16];
  out[0] = float_unordered(prev_ord);
  br_init(&br, in + 17U, in_bytes - 17U);
  for (i = 1; i < num; i++) {
    long long q = prev_q + unzigzag64(br_get(&br, width));
    ull step = (q >= 0) ? ((ull)q * base) : (0U - ((ull)(-q) * base));
    prev_ord += step;
    out[i] = float_unordered(prev_ord);
    prev_q = q;
  }
}

/* Conv1: order-2 AR in float-ordered integer space.
 *   pred[i] = (w0_q*y[i-1] + w1_q*y[i-2] + bias_q) >> scale_log
 * Bit-exact. Quantization guard refuses mode unless |y|*|w_q|+|bias_q| < 2^62.
 * Regression: 2x2 normal eqs by Cramer's rule (encoder only — ratio only).
 *
 * Wire: [scale_log:u8][res_width:u8][pivot:u64]
 *       [w0_q:i32][w1_q:i32][bias_q:i64][(ord[0]-pivot):i64][(ord[1]-pivot):i64]
 *       [bit-packed zigzag residuals, width bits each, for i in [2,num)]. */
#define C_CONV1_SCALE_LOG 10
#define C_CONV1_SCALE ((double)(1 << C_CONV1_SCALE_LOG))
#define C_CONV1_HEADER_BYTES 42U
#define C_CONV1_Y_BOUND ((int64_t)1 << 30)   /* refuse if any |y| > 2^30 */
#define C_CONV1_W_BOUND ((int32_t)((1 << (C_CONV1_SCALE_LOG + 1)) - 1))
   /* w_q < 2^11, so |w * y| < 2^41, safely accumulates in int64. */

static inline int64_t conv1_predict(int32_t w0_q, int32_t w1_q, int64_t bias_q,
                                     int64_t y_prev, int64_t y_prev2)
{
  /* All operands fit such that products and sum fit in int64 under the
     bounds above. Right-shift on signed int64 is implementation-defined for
     negatives in C, but on all sane targets (including GCC/Clang on x86_64)
     it's arithmetic shift; the chain is bit-exact at encoder and decoder. */
  int64_t acc = (int64_t)w0_q * y_prev + (int64_t)w1_q * y_prev2 + bias_q;
  return acc >> C_CONV1_SCALE_LOG;
}

static size_t conv1_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  size_t i, width;
  ull pivot, max_zz = 0;
  int64_t y0, y1, y2, bias_q;
  double c00_d = 0.0, c01_d = 0.0, c11_d = 0.0, r0_d = 0.0, r1_d = 0.0, mean_y_d = 0.0;
  double w0_d, w1_d, det;
  int32_t w0_q, w1_q;
  bw_t bw;
  if (num < 8U) return (size_t)-1;
  if (out_cap < C_CONV1_HEADER_BYTES) return (size_t)-1;
  pivot = float_ordered(input[0]);

  y0 = 0;
  y1 = (int64_t)(float_ordered(input[1]) - pivot);
  if (y1 > C_CONV1_Y_BOUND || y1 < -C_CONV1_Y_BOUND) return (size_t)-1;
  for (i = 2; i < num; i++) {
    double dy0, dy1, dy2;
    y2 = (int64_t)(float_ordered(input[i]) - pivot);
    if (y2 > C_CONV1_Y_BOUND || y2 < -C_CONV1_Y_BOUND) return (size_t)-1;
    dy0 = (double)y0; dy1 = (double)y1; dy2 = (double)y2;
    c00_d += dy1 * dy1; c01_d += dy1 * dy0; c11_d += dy0 * dy0;
    r0_d += dy2 * dy1;  r1_d += dy2 * dy0;
    mean_y_d += dy2;
    y0 = y1; y1 = y2;
  }
  det = c00_d * c11_d - c01_d * c01_d;
  if (det == 0.0) return (size_t)-1;
  w0_d = (c11_d * r0_d - c01_d * r1_d) / det;
  w1_d = (c00_d * r1_d - c01_d * r0_d) / det;
  {
    double w0_scaled = w0_d * C_CONV1_SCALE, w1_scaled = w1_d * C_CONV1_SCALE;
    if (w0_scaled > (double)C_CONV1_W_BOUND || w0_scaled < (double)(-C_CONV1_W_BOUND)
     || w1_scaled > (double)C_CONV1_W_BOUND || w1_scaled < (double)(-C_CONV1_W_BOUND)) return (size_t)-1;
    w0_q = (int32_t)(w0_scaled >= 0.0 ? w0_scaled + 0.5 : w0_scaled - 0.5);
    w1_q = (int32_t)(w1_scaled >= 0.0 ? w1_scaled + 0.5 : w1_scaled - 0.5);
  }
  {
    double mean = mean_y_d / (double)(num - 2U);
    double leftover = (double)((int64_t)1 << C_CONV1_SCALE_LOG) - (double)w0_q - (double)w1_q;
    double bias_d = mean * leftover;
    if (bias_d > (double)((int64_t)1 << 56) || bias_d < -(double)((int64_t)1 << 56)) return (size_t)-1;
    bias_q = (int64_t)(bias_d >= 0.0 ? bias_d + 0.5 : bias_d - 0.5);
  }
  y0 = (int64_t)(float_ordered(input[0]) - pivot);
  y1 = (int64_t)(float_ordered(input[1]) - pivot);
  for (i = 2; i < num; i++) {
    ull zz;
    y2 = (int64_t)(float_ordered(input[i]) - pivot);
    zz = zigzag64(y2 - conv1_predict(w0_q, w1_q, bias_q, y1, y0));
    if (zz > max_zz) max_zz = zz;
    y0 = y1; y1 = y2;
  }
  width = bits_required64(max_zz);
  if (width == 0U) width = 1U;
  if (width >= 60U) return (size_t)-1;
  if ((C_CONV1_HEADER_BYTES + (((num - 2U) * width + 7U) >> 3)) > out_cap) return (size_t)-1;

  out[0] = (unsigned char)C_CONV1_SCALE_LOG;
  out[1] = (unsigned char)width;
  store_u64_unaligned(out + 2, pivot);
  st32_le(out + 10, (uint32_t)w0_q);
  st32_le(out + 14, (uint32_t)w1_q);
  store_u64_unaligned(out + 18, (ull)bias_q);
  store_u64_unaligned(out + 26, (ull)(int64_t)(float_ordered(input[0]) - pivot));
  store_u64_unaligned(out + 34, (ull)(int64_t)(float_ordered(input[1]) - pivot));

  bw_init(&bw, out + C_CONV1_HEADER_BYTES, out_cap - C_CONV1_HEADER_BYTES);
  y0 = (int64_t)(float_ordered(input[0]) - pivot);
  y1 = (int64_t)(float_ordered(input[1]) - pivot);
  for (i = 2; i < num; i++) {
    y2 = (int64_t)(float_ordered(input[i]) - pivot);
    bw_put(&bw, zigzag64(y2 - conv1_predict(w0_q, w1_q, bias_q, y1, y0)), width);
    y0 = y1; y1 = y2;
  }
  return C_CONV1_HEADER_BYTES + bw_bytes(&bw);
}

static void conv1_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t i, width;
  ull pivot;
  int32_t w0_q, w1_q;
  int64_t bias_q, y0, y1;
  br_t br;
  if (num == 0U) return;
  width = (size_t)in[1];
  pivot = load_u64_unaligned(in + 2);
  w0_q = (int32_t)ld32_le(in + 10);
  w1_q = (int32_t)ld32_le(in + 14);
  bias_q = (int64_t)load_u64_unaligned(in + 18);
  y0 = (int64_t)load_u64_unaligned(in + 26);
  y1 = (int64_t)load_u64_unaligned(in + 34);
  out[0] = float_unordered(pivot + (ull)y0);
  if (num == 1U) return;
  out[1] = float_unordered(pivot + (ull)y1);
  if (num == 2U) return;
  br_init(&br, in + C_CONV1_HEADER_BYTES, in_bytes - C_CONV1_HEADER_BYTES);
  for (i = 2; i < num; i++) {
    int64_t pred;
    int64_t residual;
    int64_t y2;
    pred = conv1_predict(w0_q, w1_q, bias_q, y1, y0);
    residual = unzigzag64(br_get(&br, width));
    y2 = pred + residual;
    out[i] = float_unordered(pivot + (ull)y2);
    y0 = y1;
    y1 = y2;
  }
}

/* DeltaBinned: per-value width on ordered-delta residuals;
 * width sequence tANS-coded; deltas bit-packed at width[i] bits each.
 * Wire: [ord[0]:u64][tans_size:u32 LE][tANS widths][packed deltas]. */
static size_t db_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  size_t i, header_bytes = 12U, tans_size, delta_bytes, total;
  uint64_t total_width_bits = 0U;
  uint8_t *widths;
  ull prev;
  bw_t bw;
  if (num < 16U) return (size_t)-1;
  if (header_bytes >= out_cap) return (size_t)-1;
  widths = (uint8_t *)malloc(num);
  if (widths == NULL) return (size_t)-1;
  prev = float_ordered(input[0]);
  widths[0] = 0U;
  for (i = 1; i < num; i++) {
    ull cur = float_ordered(input[i]);
    ull zz = zigzag64((long long)(cur - prev));
    size_t w = bits_required64(zz);
    widths[i] = (uint8_t)w;
    total_width_bits += w;
    prev = cur;
  }
  tans_size = fc_ans_compress_bytes(widths, num, out + header_bytes, out_cap - header_bytes);
  if (tans_size == (size_t)-1) { free(widths); return (size_t)-1; }
  delta_bytes = (size_t)((total_width_bits + 7U) >> 3);
  if ((header_bytes + tans_size + delta_bytes) > out_cap) { free(widths); return (size_t)-1; }
  store_u64_unaligned(out, float_ordered(input[0]));
  st32_le(out + 8, (uint32_t)tans_size);
  bw_init(&bw, out + header_bytes + tans_size,
                  out_cap - header_bytes - tans_size);
  prev = float_ordered(input[0]);
  for (i = 1; i < num; i++) {
    ull cur = float_ordered(input[i]), zz = zigzag64((long long)(cur - prev));
    if (widths[i] > 0U) bw_put(&bw, zz, widths[i]);
    prev = cur;
  }
  total = header_bytes + tans_size + bw_bytes(&bw);
  free(widths);
  return total;
}

static void db_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  ull first, prev;
  size_t tans_size, i;
  uint8_t *widths;
  br_t br;
  if (num == 0U || in_bytes < 12U) return;
  first = load_u64_unaligned(in);
  static __thread uint8_t *g_db_widths = NULL;
  static __thread size_t g_db_cap = 0U;
  tans_size = (size_t)ld32_le(in + 8);
  if ((12U + tans_size) > in_bytes) return;
  if (g_db_cap < num) {
    size_t new_cap = num < 4096U ? 4096U : num;
    uint8_t *nb = (uint8_t *)realloc(g_db_widths, new_cap);
    if (!nb) return;
    g_db_widths = nb; g_db_cap = new_cap;
  }
  widths = g_db_widths;
  if (fc_ans_decode_bytes(in + 12U, tans_size, num, widths) != num) return;
  out[0] = float_unordered(first);
  prev = first;
  br_init(&br, in + 12U + tans_size, in_bytes - 12U - tans_size);
  for (i = 1; i < num; i++) {
    size_t w = (size_t)widths[i];
    ull zz = (w > 0U) ? br_get(&br, w) : 0ULL;
    long long d = unzigzag64(zz);
    prev += (ull)d;
    out[i] = float_unordered(prev);
  }
}

/* DeltaDPBinned: DP-optimal partition of 65 width-buckets into
 * K∈[1,C_DP_BIN_MAX] bins. Cost = Σ bin_max_width·count + tANS overhead + meta.
 * Wire: [ord[0]:u64][K:u8][bin_max_widths:u8×K][tans_size:u32 LE]
 *       [tANS bin_ids][bit-packed variable-width residuals]. */
static size_t ddp_enc(const ull *input, size_t num,
                                            unsigned char *out, size_t out_cap)
{
  uint32_t hist[C_DP_WIDTH_BUCKETS];
  uint8_t *width_buf, *bin_buf;
  ull *zz_buf;
  unsigned char *tans_buf;
  ull prev;
  size_t i, w, k, best_k, header_bytes;
  /* dp[k][i] = min-cost K=k+1 partition of width-buckets [0..i]; prev_split tracks splits. */
  double dp[C_DP_BIN_MAX][C_DP_WIDTH_BUCKETS], best_cost;
  int prev_split[C_DP_BIN_MAX][C_DP_WIDTH_BUCKETS];
  size_t prefix_count[C_DP_WIDTH_BUCKETS + 1], boundaries[C_DP_BIN_MAX + 1];
  uint8_t bin_max_width[C_DP_BIN_MAX];
  size_t tans_size, total_residual_bits, total;
  bw_t bw;

  if (num < 32U || out_cap < 16U) return (size_t)-1;
  /* Thread-local growing scratch, avoids malloc/free per call (~580 MB of churn on 17-dataset bench). */
  static __thread uint8_t *g_ddp_width = NULL;
  static __thread ull *g_ddp_zz = NULL;
  static __thread uint8_t *g_ddp_bin = NULL;
  static __thread unsigned char *g_ddp_tans = NULL;
  static __thread size_t g_ddp_cap = 0U;
  if (g_ddp_cap < num + 1024U) {
    size_t new_cap = num + 1024U < 4096U ? 4096U : num + 1024U;
    uint8_t *nw = (uint8_t *)realloc(g_ddp_width, new_cap);
    ull *nz = (ull *)realloc(g_ddp_zz, new_cap * sizeof(ull));
    uint8_t *nb = (uint8_t *)realloc(g_ddp_bin, new_cap);
    unsigned char *nt = (unsigned char *)realloc(g_ddp_tans, new_cap);
    if (!nw || !nz || !nb || !nt) { free(nw); free(nz); free(nb); free(nt); return (size_t)-1; }
    g_ddp_width = nw; g_ddp_zz = nz; g_ddp_bin = nb; g_ddp_tans = nt; g_ddp_cap = new_cap;
  }
  width_buf = g_ddp_width;
  zz_buf = g_ddp_zz;
  bin_buf = g_ddp_bin;
  tans_buf = g_ddp_tans;
  memset(hist, 0, sizeof(hist));
  prev = float_ordered(input[0]);
  width_buf[0] = 0; zz_buf[0] = 0; hist[0]++;
  for (i = 1; i < num; i++) {
    ull cur = float_ordered(input[i]), zz = zigzag64((long long)(cur - prev));
    size_t wi = bits_required64(zz);
    if (wi >= C_DP_WIDTH_BUCKETS) wi = C_DP_WIDTH_BUCKETS - 1U;
    width_buf[i] = (uint8_t)wi; zz_buf[i] = zz;
    hist[wi]++;
    prev = cur;
  }
  prefix_count[0] = 0;
  for (w = 0; w < C_DP_WIDTH_BUCKETS; w++) prefix_count[w + 1] = prefix_count[w] + hist[w];

  for (i = 0; i < C_DP_WIDTH_BUCKETS; i++) {
    dp[0][i] = (double)i * (double)prefix_count[i + 1];
    prev_split[0][i] = -1;
  }
  for (k = 1; k < C_DP_BIN_MAX; k++) for (i = 0; i < C_DP_WIDTH_BUCKETS; i++) {
    double best = 1e30;
    int best_j = -1, j;
    for (j = 0; j < (int)i; j++) { double total_cost = dp[k - 1][j] + (double)i * (double)(prefix_count[i + 1] - prefix_count[j + 1]); if (total_cost < best) { best = total_cost; best_j = j; } }
    dp[k][i] = best; prev_split[k][i] = best_j;
  }
  best_k = 0; best_cost = 1e30;
  for (k = 0; k < C_DP_BIN_MAX; k++) {
    double total_bits = dp[k][C_DP_WIDTH_BUCKETS - 1U] + (double)num * (double)fc_fast_log2f((float)(k + 1U)) + (double)((k + 1U) * 8U + 13U);
    if (total_bits < best_cost) { best_cost = total_bits; best_k = k; }
  }
  {
    int cur = (int)C_DP_WIDTH_BUCKETS - 1;
    boundaries[best_k + 1U] = (size_t)cur;
    for (k = best_k; k > 0U; k--) { cur = prev_split[k][(size_t)cur]; boundaries[k] = (size_t)cur; }
    boundaries[0] = (size_t)-1;
  }
  for (k = 0; k <= best_k; k++) bin_max_width[k] = (uint8_t)boundaries[k + 1U];
  /* Width-to-bin lookup: precompute once (65 entries) instead of nested per-value scan. */
  {
    uint8_t width_to_bin[C_DP_WIDTH_BUCKETS];
    size_t w, b = 0;
    for (w = 0; w < C_DP_WIDTH_BUCKETS; w++) {
      while (b < best_k && w > bin_max_width[b]) b++;
      width_to_bin[w] = (uint8_t)b;
    }
    for (i = 0; i < num; i++) bin_buf[i] = width_to_bin[width_buf[i]];
  }
  total_residual_bits = 0U;
  for (i = 1; i < num; i++) total_residual_bits += bin_max_width[bin_buf[i]];
  tans_size = fc_ans_compress_bytes(bin_buf, num, tans_buf, num + 1024U);
  if (tans_size == (size_t)-1) { return (size_t)-1; }
  header_bytes = 8U + 1U + (best_k + 1U) + 4U;
  total = header_bytes + tans_size + ((total_residual_bits + 7U) >> 3);
  if (total > out_cap) { return (size_t)-1; }
  store_u64_unaligned(out, float_ordered(input[0]));
  out[8] = (unsigned char)(best_k + 1U);
  for (k = 0; k <= best_k; k++) out[9 + k] = bin_max_width[k];
  {
    size_t off = 9U + (best_k + 1U);
    st32_le(out + off, (uint32_t)tans_size);
    memcpy(out + off + 4, tans_buf, tans_size);
    bw_init(&bw, out + off + 4 + tans_size, out_cap - off - 4 - tans_size);
    for (i = 1; i < num; i++) {
      size_t bin_w = bin_max_width[bin_buf[i]];
      if (bin_w > 0U) bw_put(&bw, zz_buf[i], bin_w);
    }
    total = off + 4 + tans_size + bw_bytes(&bw);
  }
  return total;
}

static void ddp_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  ull first, prev;
  size_t k_count, tans_size, i, k, off;
  uint8_t bin_max_width[C_DP_BIN_MAX], *bin_buf;
  br_t br;
  if (num == 0U || in_bytes < 13U) return;
  first = load_u64_unaligned(in);
  k_count = (size_t)in[8];
  if (k_count == 0U || k_count > C_DP_BIN_MAX) return;
  for (k = 0; k < k_count; k++) bin_max_width[k] = in[9 + k];
  off = 9U + k_count;
  tans_size = (size_t)in[off] | ((size_t)in[off+1] << 8) | ((size_t)in[off+2] << 16) | ((size_t)in[off+3] << 24);
  off += 4U;
  if ((off + tans_size) > in_bytes) return;
  static __thread uint8_t *g_ddp_bin_buf = NULL;
  static __thread size_t g_ddp_bin_cap = 0U;
  if (g_ddp_bin_cap < num) {
    size_t new_cap = num < 4096U ? 4096U : num;
    uint8_t *nb = (uint8_t *)realloc(g_ddp_bin_buf, new_cap);
    if (!nb) return;
    g_ddp_bin_buf = nb; g_ddp_bin_cap = new_cap;
  }
  bin_buf = g_ddp_bin_buf;
  if (fc_ans_decode_bytes(in + off, tans_size, num, bin_buf) != num) { return; }
  out[0] = float_unordered(first);
  prev = first;
  br_init(&br, in + off + tans_size, in_bytes - off - tans_size);
  for (i = 1; i < num; i++) {
    size_t bin_w;
    ull zz;
    long long d;
    if (bin_buf[i] >= k_count) return;
    bin_w = (size_t)bin_max_width[bin_buf[i]];
    zz = (bin_w > 0U) ? br_get(&br, bin_w) : 0ULL;
    d = unzigzag64(zz);
    prev += (ull)d;
    out[i] = float_unordered(prev);
  }
  /* For i=0, bin_id may be 0 with width 0 — that's already handled above. */
}

/* Viterbi: coarse per-sub-block mode pick from {CONST, STRIDE,
 * ORDERED_DELTA, predictor, RAW}. Wire: [sub_size:u16 LE][n_sub:u16 LE]
 * then per sub-block: [mode:u8][compressed_bytes:u32 LE][payload]. */
#define C_VITERBI_SUB_VALUES 1024U

static size_t viterbi_try_const(const ull *src, size_t n, unsigned char *out)
{
  if (!block_is_constant_avx2(src, n)) return (size_t)-1;
  store_u64_unaligned(out, src[0]);
  return 8U;
}

static size_t viterbi_try_stride(const ull *src, size_t n, unsigned char *out)
{
  ull stride;
  if (!block_is_stride(src, n, &stride)) return (size_t)-1;
  store_u64_unaligned(out, src[0]);
  store_u64_unaligned(out + 8, stride);
  return 16U;
}

static size_t vit_enc(const ull *input, size_t num, size_t predsizem1,
                      ull *fcm, ull *dfcm, unsigned char *scratch_fc, unsigned char *scratch_od,
                      unsigned char *out, size_t out_cap)
{
  size_t sub = C_VITERBI_SUB_VALUES, sub_count, header_bytes = 4U, op = header_bytes, i;
  (void)predsizem1;  /* sub-block predictor uses fixed C_VITERBI_SUB_VALUES-sized table */
  if (num < (2U * sub)) return (size_t)-1;
  sub_count = (num + sub - 1U) / sub;
  if (sub_count > 65535U) return (size_t)-1;
  out[0] = (unsigned char)(sub & 0xffU);
  out[1] = (unsigned char)((sub >> 8) & 0xffU);
  out[2] = (unsigned char)(sub_count & 0xffU);
  out[3] = (unsigned char)((sub_count >> 8) & 0xffU);
  for (i = 0; i < sub_count; i++) {
    size_t start = i * sub, end = start + sub, sub_n, raw_bytes, sz, best_size;
    int best_mode = M_RAW;
    unsigned char *best_buf;
    if (end > num) end = num;
    sub_n = end - start;
    raw_bytes = sub_n * sizeof(ull);
    best_size = raw_bytes;
    best_buf = (unsigned char *)(uintptr_t)(input + start);
    sz = viterbi_try_const(input + start, sub_n, scratch_od);
    if (sz != (size_t)-1 && sz < best_size) { best_size = sz; best_mode = M_CONST; best_buf = scratch_od; }
    if (best_mode != M_CONST) {
      unsigned char *strbuf = scratch_od + 32U;
      sz = viterbi_try_stride(input + start, sub_n, strbuf);
      if (sz != (size_t)-1 && sz < best_size) { best_size = sz; best_mode = M_STRIDE; best_buf = strbuf; }
    }
    {
      unsigned char *od_buf = scratch_od + 64U;
      sz = ord_delta_enc(input + start, sub_n, od_buf, raw_bytes + 1024U);
      if (sz != (size_t)-1 && sz < best_size) { best_size = sz; best_mode = M_ORDERED_DELTA; best_buf = od_buf; }
    }
    /* Sub-blocks are typically 1024 elements — a 1024-entry hash table is right-sized
     * (fits L1 cache, cleanup is tiny). Encoder and decoder both override here. */
    sz = pred_enc(input + start, sub_n, (size_t)C_VITERBI_SUB_VALUES - 1U, fcm, dfcm, scratch_fc);
    if (sz < best_size) { best_size = sz; best_mode = M_PRED; best_buf = scratch_fc; }
    if ((op + 5U + best_size) > out_cap) return (size_t)-1;
    out[op] = (unsigned char)best_mode;
    st32_le(out + op + 1, (uint32_t)best_size);
    memcpy(out + op + 5U, best_buf, best_size);
    op += 5U + best_size;
  }
  return op;
}

static void vit_dec(const unsigned char *in, size_t in_bytes, size_t num,
                    size_t predsizem1, ull *fcm, ull *dfcm, ull *out)
{
  size_t sub, sub_count, ip = 4U, out_idx = 0U, i;
  if (in_bytes < 4U) return;
  sub = (size_t)in[0] | ((size_t)in[1] << 8);
  sub_count = (size_t)in[2] | ((size_t)in[3] << 8);
  for (i = 0; i < sub_count; i++) {
    int mode;
    size_t size_b, sub_n;
    if ((ip + 5U) > in_bytes) return;
    mode = in[ip];
    size_b = (size_t)ld32_le(in + ip + 1);
    ip += 5U;
    if ((ip + size_b) > in_bytes) return;
    sub_n = (out_idx + sub <= num) ? sub : (num - out_idx);
    switch (mode) {
      case M_CONST: {
        ull v = load_u64_unaligned(in + ip);
        size_t k;
        for (k = 0; k < sub_n; k++) out[out_idx + k] = v;
        break;
      }
      case M_STRIDE: {
        ull v = load_u64_unaligned(in + ip);
        ull s = load_u64_unaligned(in + ip + 8);
        size_t k;
        for (k = 0; k < sub_n; k++) { out[out_idx + k] = v; v += s; }
        break;
      }
      case M_ORDERED_DELTA:
        ord_delta_dec(in + ip, size_b, sub_n, out + out_idx);
        break;
      case M_PRED:
        /* Match vit_enc's smaller sub-block predictor table. */
        pred_dec(in + ip, size_b, sub_n, (size_t)C_VITERBI_SUB_VALUES - 1U, fcm, dfcm, out + out_idx);
        (void)predsizem1;
        break;
      case M_RAW:
      default:
        memcpy(out + out_idx, in + ip, sub_n * sizeof(ull));
        break;
    }
    ip += size_b;
    out_idx += sub_n;
  }
}

/* fc_adaptive: per-block predictor table sizing — probe sizes
 * {1024, 4096, 16384, 65536}, pick smallest output.
 * Wire: [predsizelg2:u8 ∈[10,16]][predictor tags][predictor payload]. */
static size_t predA_enc(const ull *input, size_t num, ull *fcm, ull *dfcm,
                        unsigned char *scratch, unsigned char *out, size_t out_cap)
{
  static const uint8_t candidates[] = {10, 12, 14, 16};
  size_t best = (size_t)-1, i;
  uint8_t best_lg2 = 16;
  for (i = 0; i < sizeof(candidates) / sizeof(candidates[0]); i++) {
    size_t pm1 = ((size_t)1U << candidates[i]) - 1U, sz;
    if ((1U + (num * 9U)) > out_cap) return (size_t)-1;
    sz = pred_enc(input, num, pm1, fcm, dfcm, scratch);
    if (sz < best) {
      best = sz;
      best_lg2 = candidates[i];
      if ((1U + sz) > out_cap) { best = (size_t)-1; continue; }
      out[0] = best_lg2;
      memcpy(out + 1, scratch, sz);
    }
  }
  if (best == (size_t)-1) return (size_t)-1;
  return 1U + best;
}

static void predA_dec(const unsigned char *in, size_t in_bytes, size_t num,
                                          ull *fcm, ull *dfcm, ull *out)
{
  uint8_t lg2;
  size_t pm1;
  if (in_bytes < 1U) return;
  lg2 = in[0];
  if (lg2 < 10U || lg2 > 16U) return;
  pm1 = ((size_t)1U << lg2) - 1U;
  pred_dec(in + 1, in_bytes - 1U, num, pm1, fcm, dfcm, out);
}

/* PRED2: 2-way set-associative DFCM, 5 candidates {FCM_a, FCM_b,
 * DFCM_a, DFCM_b, DDFCM}. Tag = pred_id(3b) | bcode(3b). Wire matches predictor. */
static size_t pred2_enc(const ull *input, size_t num, size_t predsizem1,
                        ull *fcm, ull *dfcm, unsigned char *out)
{
  size_t i, hash = 0, dhash = 0, code_bytes = num, data = code_bytes;
  ull lastval = 0, laststride = 0, prevstride = 0, pred1 = 0, pred1b = 0, pred2a = 0, pred2b = 0, pred3 = 0;
  size_t fcm_count = 0U, dfcm_count = 0U;
  int track_ok = pred_track_grow(num + 1U);
  if (!track_ok) {
    memset(fcm,  0, (predsizem1 + 1U) * sizeof(ull));
    memset(dfcm, 0, (predsizem1 + 1U) * sizeof(ull));
  }
  memset(out, 0, code_bytes);

  for (i = 0; i < num; i++) {
    ull val = input[i], stride, best, xor3;
    ull xor1 = val ^ pred1, xor1b = val ^ pred1b, xor2a = val ^ pred2a, xor2b = val ^ pred2b;
    int code = 0, pred_id = 0, bcode, bytes;
    size_t j, base, dbase;
    pred3 = lastval + laststride + (laststride - prevstride);
    xor3 = val ^ pred3;
    best = xor1;
    if (xor1b < best) { best = xor1b; pred_id = 1; }
    if (xor2a < best) { best = xor2a; pred_id = 2; }
    if (xor2b < best) { best = xor2b; pred_id = 3; }
    if (xor3  < best) { best = xor3;  pred_id = 4; }
    stride = val - lastval;
    prevstride = laststride;
    laststride = stride;
    lastval = val;
    base = hash & ~(size_t)1U;
    fcm[base + 1U] = fcm[base];
    fcm[base] = val;
    if (track_ok) g_pred_touched_fcm[fcm_count++] = (uint32_t)base;
    hash = fc_crc32_u64(val) & predsizem1;
    base = hash & ~(size_t)1U;
    pred1 = fcm[base]; pred1b = fcm[base + 1U];
    dbase = dhash & ~(size_t)1U;
    dfcm[dbase + 1U] = dfcm[dbase];
    dfcm[dbase] = stride;
    if (track_ok) g_pred_touched_dfcm[dfcm_count++] = (uint32_t)dbase;
    dhash = fc_crc32_u64(stride) & predsizem1;
    dbase = dhash & ~(size_t)1U;
    pred2a = val + dfcm[dbase]; pred2b = val + dfcm[dbase + 1U];
    bcode = fc_bcode(best);
    bytes = bcode + (bcode >> 2);
    code = (pred_id << 3) | bcode;
    out[i] = (unsigned char)code;
    store_u64_unaligned(out + data, best);
    data += (size_t)bytes;
    (void)j;
  }
  if (track_ok) {
    for (i = 0; i < fcm_count; i++) { size_t b = (size_t)g_pred_touched_fcm[i]; _mm_storeu_si128((__m128i *)(void *)&fcm[b], _mm_setzero_si128()); }
    for (i = 0; i < dfcm_count; i++) { size_t b = (size_t)g_pred_touched_dfcm[i]; _mm_storeu_si128((__m128i *)(void *)&dfcm[b], _mm_setzero_si128()); }
  }
  return data;
}

static void pred2_dec(const unsigned char *in, size_t in_bytes, size_t num,
                      size_t predsizem1, ull *fcm, ull *dfcm, ull *out)
{
  size_t i, hash = 0, dhash = 0, code_bytes = num, data = code_bytes;
  ull lastval = 0, laststride = 0, pred1 = 0, pred1b = 0, pred2a = 0, pred2b = 0, pred3 = 0;
  size_t fcm_count = 0U, dfcm_count = 0U;
  int track_ok = pred_track_grow(num + 1U);
  (void)in_bytes;
  if (!track_ok) {
    memset(fcm,  0, (predsizem1 + 1U) * sizeof(ull));
    memset(dfcm, 0, (predsizem1 + 1U) * sizeof(ull));
  }

  for (i = 0; i < num; i++) {
    int code = in[i], bcode = code & 0x7, pred_id = (code >> 3) & 0x7, bytes = bcode + (bcode >> 2);
    ull val = 0, stride, preds[8];
    size_t j, base, dbase;
    for (j = 0; j < (size_t)bytes; j++) val |= ((ull)in[data++]) << (j * 8U);
    preds[0] = pred1; preds[1] = pred1b; preds[2] = pred2a; preds[3] = pred2b;
    preds[4] = pred3; preds[5] = 0; preds[6] = 0; preds[7] = 0;
    val ^= preds[(unsigned)pred_id & 7U];
    stride = val - lastval;
    pred3 = val + stride + (stride - laststride);
    laststride = stride;
    base = hash & ~(size_t)1U;
    fcm[base + 1U] = fcm[base];
    fcm[base] = val;
    if (track_ok) g_pred_touched_fcm[fcm_count++] = (uint32_t)base;
    hash = fc_crc32_u64(val) & predsizem1;
    base = hash & ~(size_t)1U;
    pred1 = fcm[base]; pred1b = fcm[base + 1U];
    dbase = dhash & ~(size_t)1U;
    dfcm[dbase + 1U] = dfcm[dbase];
    dfcm[dbase] = stride;
    if (track_ok) g_pred_touched_dfcm[dfcm_count++] = (uint32_t)dbase;
    dhash = fc_crc32_u64(stride) & predsizem1;
    dbase = dhash & ~(size_t)1U;
    pred2a = val + dfcm[dbase]; pred2b = val + dfcm[dbase + 1U];
    lastval = val;
    out[i] = val;
  }
  if (track_ok) {
    for (i = 0; i < fcm_count; i++) { size_t b = (size_t)g_pred_touched_fcm[i]; _mm_storeu_si128((__m128i *)(void *)&fcm[b], _mm_setzero_si128()); }
    for (i = 0; i < dfcm_count; i++) { size_t b = (size_t)g_pred_touched_dfcm[i]; _mm_storeu_si128((__m128i *)(void *)&dfcm[b], _mm_setzero_si128()); }
  }
}

/* Fast log2 approximation: polynomial of the mantissa after
   extracting the IEEE-754 exponent. Continuity preferred over absolute
   accuracy; ~5 decimal digits of precision in [1, 2). Used in cost
   estimation hot paths where libm log2 is too slow. */
static inline float fc_fast_log2f(float x)
{
  union { float f; uint32_t u; } un;
  float y, m;
  un.f = x;
  y = (float)(int)((un.u >> 23) & 0xffU) - 127.0f;
  un.u = (un.u & 0x007fffffU) | 0x3f800000U;
  m = un.f;
  /* Minimax-ish polynomial valid in [1, 2). */
  y += -1.7417939f + (2.8212026f
       + (-1.4699568f + (0.4471957f - 0.0560175f * m) * m) * m) * m;
  return y;
}

/* bitpacked sampling without replacement — efficient way to draw
   K unique indices from [0, N) for mode-discovery probes. Uses a small
   bit-vector to track visited indices; collisions are retried with the
   same xorshift PRNG state. Memory: N/8 bytes; time: O(K) amortized. */
typedef struct { uint64_t state[2]; } fc_xoroshiro_t;

static inline uint64_t fc_xoroshiro_next(fc_xoroshiro_t *r)
{
  uint64_t s0 = r->state[0], s1 = r->state[1], result = s0 + s1;
  s1 ^= s0;
  r->state[0] = ((s0 << 24) | (s0 >> 40)) ^ s1 ^ (s1 << 16);
  r->state[1] = (s1 << 37) | (s1 >> 27);
  return result;
}

static void fc_sample_unique(uint64_t seed, size_t n, size_t k, uint8_t *visited_bits, size_t *out_indices)
{
  fc_xoroshiro_t prng;
  size_t produced = 0U, bytes = (n + 7U) >> 3;
  prng.state[0] = seed | 1ULL;
  prng.state[1] = (seed * 0x9e3779b97f4a7c15ULL) | 2ULL;
  memset(visited_bits, 0, bytes);
  if (k > n) k = n;
  while (produced < k) {
    uint64_t r = fc_xoroshiro_next(&prng);
    size_t idx = (size_t)(r % n), b = idx >> 3;
    uint8_t bit = (uint8_t)(1U << (idx & 7U));
    if ((visited_bits[b] & bit) == 0U) { visited_bits[b] |= bit; out_indices[produced++] = idx; }
  }
}

/* false-position (regula falsi) root finding for monotonic functions.
   Used inline by GCD probability calibration; see IntMult significance check. */
static double fc_false_position(double (*f)(double, void *), void *ctx,
                                     double lo, double hi, int max_iter, double tol)
{
  double f_lo = f(lo, ctx), f_hi = f(hi, ctx);
  int it;
  if ((f_lo > 0.0) == (f_hi > 0.0)) return (lo + hi) * 0.5;
  for (it = 0; it < max_iter; it++) {
    double mid = (lo * f_hi - hi * f_lo) / (f_hi - f_lo);
    double f_mid = f(mid, ctx);
    if (f_mid > -tol && f_mid < tol) return mid;
    if ((f_mid > 0.0) == (f_lo > 0.0)) { lo = mid; f_lo = f_mid; }
    else { hi = mid; f_hi = f_mid; }
  }
  return (lo + hi) * 0.5;
}

/* IntMult significance: solve p^3 + (1-p)^3/(G-1)^2 = target for p in [1/G,1]. */
typedef struct { double target_concentration, inv_gminus1_sq; } fc_im_sig_ctx_t;

static double fc_im_sig_eq(double p, void *ctx)
{
  fc_im_sig_ctx_t *c = (fc_im_sig_ctx_t *)ctx;
  double one_minus_p = 1.0 - p;
  return p * p * p + one_minus_p * one_minus_p * one_minus_p * c->inv_gminus1_sq
         - c->target_concentration;
}

static double fc_im_significance_threshold(int g, double target_concentration)
{
  fc_im_sig_ctx_t ctx;
  if (g < 2) return 0.5;
  ctx.target_concentration = target_concentration;
  ctx.inv_gminus1_sq = 1.0 / (double)((g - 1) * (g - 1));
  return fc_false_position(fc_im_sig_eq, &ctx, 1.0 / (double)g, 1.0, 32, 1e-6);
}

/* Order-N linear prediction. Cholesky-solved Toeplitz
 * normal equations. Tries orders {2, 4}; integer predict chain
 *   pred[i] = (sum w_q[j]*y[i-1-j] + bias_q) >> SCALE_LOG
 * is bit-exact at decode. Center-pivoted by sample median; "fixed-point" domain
 * (scale=2^52, cast to int64) used when sign-flips are high.
 *
 * Wire: [order:u8][scale_log:u8][res_width:u8][domain:u8][pivot:u64]
 *       [w_q[0..N]:i32][bias_q:i64][prefix y[0..N]:i64][zigzag residuals]. */

/* Toeplitz lag-sums R[tau] = Σ y[i]·y[i+tau], tau ∈ [0,order].
 * O(N·order) build vs naive O(N·order²); assumes wide-sense stationarity. */
static void fc_toeplitz_lagsums(const int64_t *y, size_t n, int order, double *R)
{
  int tau;
  size_t i;
  for (tau = 0; tau <= order; tau++) {
    size_t lag = (size_t)tau;
    double sum = 0.0;
    for (i = 0; i + lag < n; i++) sum += (double)y[i] * (double)y[i + lag];
    R[tau] = sum;
  }
}

static void fc_toeplitz_build_normal_eqs(const double *R, int order, double *A, double *b)
{
  int j, k;
  for (j = 0; j < order; j++) { b[j] = R[j + 1]; for (k = 0; k < order; k++) A[j * order + k] = R[(j > k) ? (j - k) : (k - j)]; }
}

/* Levinson-Durbin Toeplitz Yule-Walker solve, O(order²). Returns 0 on
 * non-positive prediction error (singular) → caller falls back to Cholesky. */
static int fc_levinson_durbin(const double *R, int order, double *w_out)
{
  double w[C_CONV_N_MAX_ORDER], w_prev[C_CONV_N_MAX_ORDER], e;
  int m, j;
  if (order < 1 || order > (int)C_CONV_N_MAX_ORDER || R[0] <= 0.0) return 0;
  e = R[0];
  w[0] = R[1] / e;
  e *= 1.0 - w[0] * w[0];
  for (m = 1; m < order; m++) {
    double k_m, inner = 0.0;
    if (e <= 0.0) return 0;
    for (j = 0; j < m; j++) inner += w[j] * R[m - j];
    k_m = (R[m + 1] - inner) / e;
    for (j = 0; j < m; j++) w_prev[j] = w[j];
    for (j = 0; j < m; j++) w[j] = w_prev[j] - k_m * w_prev[m - 1 - j];
    w[m] = k_m;
    e *= 1.0 - k_m * k_m;
  }
  for (j = 0; j < order; j++) w_out[j] = w[j];
  return 1;
}

/* Cholesky-Crout solve. Returns 0 if not positive definite. */
static int fc_cholesky_solve(double *A, double *b, double *x, int n)
{
  double L[C_CONV_N_MAX_ORDER][C_CONV_N_MAX_ORDER], y[C_CONV_N_MAX_ORDER];
  int i, j, k;
  if (n < 1 || n > (int)C_CONV_N_MAX_ORDER) return 0;
  for (j = 0; j < n; j++) {
    double sum = A[j * n + j], sqrt_sum;
    int it;
    for (k = 0; k < j; k++) sum -= L[j][k] * L[j][k];
    if (sum <= 0.0) return 0;
    sqrt_sum = sum;
    for (it = 0; it < 32; it++) sqrt_sum = 0.5 * (sqrt_sum + sum / sqrt_sum);
    L[j][j] = sqrt_sum;
    for (i = j + 1; i < n; i++) {
      double s = A[i * n + j];
      for (k = 0; k < j; k++) s -= L[i][k] * L[j][k];
      L[i][j] = s / L[j][j];
    }
  }
  for (i = 0; i < n; i++) {
    double s = b[i];
    for (k = 0; k < i; k++) s -= L[i][k] * y[k];
    y[i] = s / L[i][i];
  }
  for (i = n - 1; i >= 0; i--) {
    double s = y[i];
    for (k = i + 1; k < n; k++) s -= L[k][i] * x[k];
    x[i] = s / L[i][i];
  }
  return 1;
}

/* domain 0: float-ordered uint64 minus pivot, signed. domain 1: int(d * 2^52). */
static inline int64_t fc_conv_n_to_y(ull input_bits, ull pivot, int domain)
{
  double d, scaled;
  if (domain == 0) return (int64_t)(float_ordered(input_bits) - pivot);
  memcpy(&d, &input_bits, sizeof(d));
  scaled = d * (double)((int64_t)1 << 52);
  if (scaled >= (double)((int64_t)1 << 62)) scaled = (double)((int64_t)1 << 62);
  if (scaled <= -(double)((int64_t)1 << 62)) scaled = -(double)((int64_t)1 << 62);
  return (int64_t)scaled - (int64_t)pivot;
}

static inline ull fc_conv_n_from_y(int64_t y, ull pivot, int domain)
{
  if (domain == 0) {
    return float_unordered(pivot + (ull)y);
  } else {
    double d = (double)((int64_t)pivot + y) / (double)((int64_t)1 << 52);
    ull bits;
    memcpy(&bits, &d, sizeof(bits));
    return bits;
  }
}

static int64_t fc_conv_n_predict(const int32_t *w_q, int order, int64_t bias_q,
                                     const int64_t *y_hist)
{
  int64_t acc = bias_q;
  int j;
  for (j = 0; j < order; j++) acc += (int64_t)w_q[j] * y_hist[j];
  return acc >> C_CONV_N_SCALE_LOG;
}

static size_t cvn_enc(const ull *input, size_t num,
                                    unsigned char *out, size_t out_cap)
{
  /* Float-ordered domain only (domain=1 is non-lossless under |d|<1). */
  enum { CHOICE_COUNT = 8 };
  int choices_dom[CHOICE_COUNT]   = {0, 0, 0, 0, 0, 0, 0, 0};
  int choices_order[CHOICE_COUNT] = {2, 4, 6, 8, 12, 16, 24, 32};
  size_t best_size = (size_t)-1, i, c, header_min = 12U;
  if (num < 32U || out_cap < header_min) return (size_t)-1;
  for (c = 0; c < (size_t)CHOICE_COUNT; c++) {
    int domain = choices_dom[c], order = choices_order[c], j;
    ull pivot, max_zz = 0;
    int64_t y_hist[C_CONV_N_MAX_ORDER], bias_q;
    double A[C_CONV_N_MAX_ORDER * C_CONV_N_MAX_ORDER];
    double b[C_CONV_N_MAX_ORDER], w_d[C_CONV_N_MAX_ORDER], mean_y_d = 0.0;
    int32_t w_q[C_CONV_N_MAX_ORDER];
    size_t header_bytes, width, total;
    bw_t bw;
    if (domain == 1) {
      double d0; memcpy(&d0, &input[0], sizeof(d0));
      pivot = (ull)(int64_t)(d0 * (double)((int64_t)1 << 52));
    } else pivot = float_ordered(input[0]);
    {
      int valid = 1;
      int64_t *y_array = (int64_t *)malloc(num * sizeof(int64_t));
      double R[C_CONV_N_MAX_ORDER + 1];
      if (y_array == NULL) continue;
      for (i = 0; i < num; i++) {
        y_array[i] = fc_conv_n_to_y(input[i], pivot, domain);
        if (y_array[i] > C_CONV_N_Y_BOUND || y_array[i] < -C_CONV_N_Y_BOUND) { valid = 0; break; }
      }
      if (!valid) { free(y_array); continue; }
      fc_toeplitz_lagsums(y_array, num, order, R);
      fc_toeplitz_build_normal_eqs(R, order, A, b);
      mean_y_d = 0.0;
      for (i = (size_t)order; i < num; i++) mean_y_d += (double)y_array[i];
      free(y_array);
      if (!fc_levinson_durbin(R, order, w_d) && !fc_cholesky_solve(A, b, w_d, order)) continue;
    }
    /* quantization guard: refuse if |w| overflows Q-format. */
    {
      int abort_choice = 0;
      for (j = 0; j < order; j++) {
        double w_scaled = w_d[j] * (double)(1 << C_CONV_N_SCALE_LOG);
        if (w_scaled > (double)C_CONV_N_W_BOUND || w_scaled < (double)(-C_CONV_N_W_BOUND)) { abort_choice = 1; break; }
        w_q[j] = (int32_t)(w_scaled >= 0.0 ? w_scaled + 0.5 : w_scaled - 0.5);
      }
      if (abort_choice) continue;
    }
    {
      double mean = mean_y_d / (double)(num - (size_t)order);
      double leftover = (double)((int64_t)1 << C_CONV_N_SCALE_LOG), bias_d;
      for (j = 0; j < order; j++) leftover -= (double)w_q[j];
      bias_d = mean * leftover;
      if (bias_d > (double)((int64_t)1 << 56) || bias_d < -(double)((int64_t)1 << 56)) continue;
      bias_q = (int64_t)(bias_d >= 0.0 ? bias_d + 0.5 : bias_d - 0.5);
    }
    for (j = 0; j < order; j++) y_hist[j] = fc_conv_n_to_y(input[j], pivot, domain);
    for (i = (size_t)order; i < num; i++) {
      int64_t y_cur = fc_conv_n_to_y(input[i], pivot, domain);
      ull zz = zigzag64(y_cur - fc_conv_n_predict(w_q, order, bias_q, y_hist));
      if (zz > max_zz) max_zz = zz;
      for (j = 0; j + 1 < order; j++) y_hist[j] = y_hist[j + 1];
      y_hist[order - 1] = y_cur;
    }
    width = bits_required64(max_zz);
    if (width == 0U) width = 1U;
    if (width >= 60U) continue;
    header_bytes = 4U + 8U + (size_t)order * 4U + 8U + (size_t)order * 8U;
    total = header_bytes + (((num - (size_t)order) * width + 7U) >> 3);
    if (total >= best_size || total > out_cap) continue;
    out[0] = (unsigned char)order;
    out[1] = (unsigned char)C_CONV_N_SCALE_LOG;
    out[2] = (unsigned char)width;
    out[3] = (unsigned char)domain;
    {
      unsigned char *p = out + 4U;
      size_t b_off;
      store_u64_unaligned(p, pivot); p += 8;
      for (j = 0; j < order; j++) { st32_le(p, (uint32_t)w_q[j]); p += 4; }
      store_u64_unaligned(p, (ull)bias_q); p += 8;
      for (j = 0; j < order; j++) { store_u64_unaligned(p, (ull)fc_conv_n_to_y(input[j], pivot, domain)); p += 8; }
      b_off = (size_t)(p - out);
      bw_init(&bw, p, out_cap - b_off);
      for (j = 0; j < order; j++) y_hist[j] = fc_conv_n_to_y(input[j], pivot, domain);
      for (i = (size_t)order; i < num; i++) {
        int64_t y_cur = fc_conv_n_to_y(input[i], pivot, domain);
        bw_put(&bw, zigzag64(y_cur - fc_conv_n_predict(w_q, order, bias_q, y_hist)), width);
        for (j = 0; j + 1 < order; j++) y_hist[j] = y_hist[j + 1];
        y_hist[order - 1] = y_cur;
      }
      total = b_off + bw_bytes(&bw);
    }
    if (total < best_size) best_size = total;
  }
  return best_size;
}

static void cvn_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  int order, domain, j;
  size_t scale_log, width, header_bytes, i;
  ull pivot;
  int32_t w_q[C_CONV_N_MAX_ORDER];
  int64_t bias_q, y_hist[C_CONV_N_MAX_ORDER];
  br_t br;
  if (num == 0U || in_bytes < 4U) return;
  order = (int)in[0];
  if (order < 1 || order > (int)C_CONV_N_MAX_ORDER) return;
  scale_log = (size_t)in[1];
  width = (size_t)in[2];
  domain = (int)in[3];
  if (in_bytes < (size_t)(4U + 8U + (size_t)order * 4U + 8U + (size_t)order * 8U)) return;
  {
    const unsigned char *p = in + 4U;
    pivot = load_u64_unaligned(p);
    p += 8;
    for (j = 0; j < order; j++) { w_q[j] = (int32_t)ld32_le(p); p += 4; }
    bias_q = (int64_t)load_u64_unaligned(p);
    p += 8;
    for (j = 0; j < order && (size_t)j < num; j++) {
      y_hist[j] = (int64_t)load_u64_unaligned(p);
      out[j] = fc_conv_n_from_y(y_hist[j], pivot, domain);
      p += 8;
    }
    header_bytes = (size_t)(p - in);
  }
  if ((size_t)order >= num) return;
  br_init(&br, in + header_bytes, in_bytes - header_bytes);
  for (i = (size_t)order; i < num; i++) {
    int64_t pred = bias_q;
    int64_t residual;
    int64_t y_cur;
    for (j = 0; j < order; j++) pred += (int64_t)w_q[j] * y_hist[j];
    pred = pred >> scale_log;
    residual = unzigzag64(br_get(&br, width));
    y_cur = pred + residual;
    out[i] = fc_conv_n_from_y(y_cur, pivot, domain);
    for (j = 0; j + 1 < order; j++) y_hist[j] = y_hist[j + 1];
    y_hist[order - 1] = y_cur;
  }
}

/* ConvDouble (in value domain): order-4 linear pred on f64 values.
 * Weights transmitted as raw double bits; volatile forces identical eval order
 * encoder/decoder. Residual bitcast to int64 — bit-exact.
 * Wire: [order:u8][res_width:u8][bias:f64][w[0..N]:f64×N]
 *       [first N inputs:u64][zigzag-i64 residuals for i in [order,num)]. */
static double fc_predict_double_volatile(double bias, const double *w, int order, const double *y_hist)
{
  /* Volatile temporaries prevent the compiler from contracting w*y+bias into
     an FMA. FMA gives different results from separate mul+add, breaking
     the bit-exactness we rely on across encoder/decoder builds. */
  volatile double pred_v = bias;
  volatile double t;
  int j;
  for (j = 0; j < order; j++) {
    volatile double prod = w[j] * y_hist[j];
    t = pred_v;
    pred_v = t + prod;
  }
  return pred_v;
}

static size_t cvd_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  int order = C_CONV_DOUBLE_ORDER, j, k;
  double y_buf[C_CONV_DOUBLE_ORDER], y_hist[C_CONV_DOUBLE_ORDER];
  double A[C_CONV_DOUBLE_ORDER * C_CONV_DOUBLE_ORDER];
  double b[C_CONV_DOUBLE_ORDER], w[C_CONV_DOUBLE_ORDER], bias = 0.0, mean_y = 0.0;
  size_t header_bytes = 2U + 8U + (size_t)order * 8U + (size_t)order * 8U, i, width;
  ull max_zz = 0;
  bw_t bw;
  if (num < (size_t)(order + 16)) return (size_t)-1;
  if (header_bytes > out_cap) return (size_t)-1;
  for (j = 0; j < order; j++) memcpy(&y_buf[j], &input[j], sizeof(double));
  memset(A, 0, sizeof(A)); memset(b, 0, sizeof(b));
  for (i = (size_t)order; i < num; i++) {
    double y_cur;
    memcpy(&y_cur, &input[i], sizeof(double));
    if (!(y_cur == y_cur)) return (size_t)-1;
    for (j = 0; j < order; j++) {
      double yj = y_buf[order - 1 - j];
      b[j] += y_cur * yj;
      for (k = j; k < order; k++) A[j * order + k] += yj * y_buf[order - 1 - k];
    }
    mean_y += y_cur;
    for (j = 0; j + 1 < order; j++) y_buf[j] = y_buf[j + 1];
    y_buf[order - 1] = y_cur;
  }
  for (j = 0; j < order; j++) for (k = 0; k < j; k++) A[j * order + k] = A[k * order + j];
  if (!fc_cholesky_solve(A, b, w, order)) return (size_t)-1;
  {
    double mean = mean_y / (double)(num - (size_t)order), leftover = 1.0;
    for (j = 0; j < order; j++) leftover -= w[j];
    bias = mean * leftover;
  }
  for (j = 0; j < order; j++) memcpy(&y_hist[j], &input[j], sizeof(double));
  for (i = (size_t)order; i < num; i++) {
    double y_cur, pred, residual_d;
    int64_t residual_bits_signed;
    ull zz, rb, rbo;
    memcpy(&y_cur, &input[i], sizeof(double));
    pred = fc_predict_double_volatile(bias, w, order, y_hist);
    residual_d = y_cur - pred;
    /* float_ordered residual: small +/- magnitudes map near 0. */
    memcpy(&rb, &residual_d, sizeof(rb));
    rbo = float_ordered(rb);
    residual_bits_signed = (int64_t)(rbo - 0x8000000000000000ULL);
    /* Lossless guard: cancellation in (y_cur - pred) can lose precision; refuse if not bit-exact. */
    { volatile double pv = pred, rv = residual_d; double y_check = pv + rv;
      ull a, bv;
      memcpy(&a, &y_cur, sizeof(a)); memcpy(&bv, &y_check, sizeof(bv));
      if (a != bv) return (size_t)-1; }
    zz = zigzag64(residual_bits_signed);
    if (zz > max_zz) max_zz = zz;
    for (j = 0; j + 1 < order; j++) y_hist[j] = y_hist[j + 1];
    y_hist[order - 1] = y_cur;
  }
  width = bits_required64(max_zz);
  if (width == 0U) width = 1U;
  if (width >= 60U) return (size_t)-1;
  if ((header_bytes + (((num - (size_t)order) * width + 7U) >> 3)) > out_cap) return (size_t)-1;

  out[0] = (unsigned char)order;
  out[1] = (unsigned char)width;
  { ull bb; memcpy(&bb, &bias, sizeof(bb)); store_u64_unaligned(out + 2, bb); }
  for (j = 0; j < order; j++) { ull wb; memcpy(&wb, &w[j], sizeof(wb)); store_u64_unaligned(out + 10 + j * 8, wb); }
  for (j = 0; j < order; j++) store_u64_unaligned(out + 10 + (size_t)order * 8U + (size_t)j * 8U, input[j]);
  bw_init(&bw, out + header_bytes, out_cap - header_bytes);
  for (j = 0; j < order; j++) memcpy(&y_hist[j], &input[j], sizeof(double));
  for (i = (size_t)order; i < num; i++) {
    double y_cur;
    double pred;
    double residual_d;
    int64_t residual_bits_signed;
    memcpy(&y_cur, &input[i], sizeof(double));
    pred = fc_predict_double_volatile(bias, w, order, y_hist);
    residual_d = y_cur - pred;
    memcpy(&residual_bits_signed, &residual_d, sizeof(residual_bits_signed));
    bw_put(&bw, zigzag64(residual_bits_signed), width);
    for (j = 0; j + 1 < order; j++) y_hist[j] = y_hist[j + 1];
    y_hist[order - 1] = y_cur;
  }
  return header_bytes + bw_bytes(&bw);
}

static void cvd_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  int order, j;
  size_t width, header_bytes, i;
  double bias, w[C_CONV_DOUBLE_ORDER], y_hist[C_CONV_DOUBLE_ORDER];
  br_t br;
  if (num == 0U || in_bytes < 10U) return;
  order = (int)in[0];
  if (order != C_CONV_DOUBLE_ORDER) return;
  width = (size_t)in[1];
  {
    ull bias_bits = load_u64_unaligned(in + 2);
    memcpy(&bias, &bias_bits, sizeof(bias));
  }
  for (j = 0; j < order; j++) { ull wb = load_u64_unaligned(in + 10 + j * 8); memcpy(&w[j], &wb, sizeof(w[j])); }
  for (j = 0; j < order && (size_t)j < num; j++) {
    out[j] = load_u64_unaligned(in + 10 + (size_t)order * 8U + (size_t)j * 8U);
    memcpy(&y_hist[j], &out[j], sizeof(y_hist[j]));
  }
  header_bytes = 2U + 8U + (size_t)order * 8U + (size_t)order * 8U;
  if ((size_t)order >= num) return;
  br_init(&br, in + header_bytes, in_bytes - header_bytes);
  for (i = (size_t)order; i < num; i++) {
    double pred = fc_predict_double_volatile(bias, w, order, y_hist);
    int64_t residual_bits_signed = unzigzag64(br_get(&br, width));
    double residual_d;
    double y_cur;
    /* Mirror encoder's float_ordered residual encoding. */
    {
      ull rbo = (ull)residual_bits_signed + 0x8000000000000000ULL;
      ull rb = float_unordered(rbo);
      memcpy(&residual_d, &rb, sizeof(residual_d));
    }
    y_cur = pred + residual_d;
    memcpy(&out[i], &y_cur, sizeof(out[i]));
    for (j = 0; j + 1 < order; j++) y_hist[j] = y_hist[j + 1];
    y_hist[order - 1] = y_cur;
  }
}

/* ConvDoubleBP (on residuals): ConvDouble with bit-planed residual
 * stream (sign|exp|mant). Wire: [order:u8][reserved:u8][bias:f64][w[0..N]:f64]
 * [first N inputs:u64][sign_bytes:u32][exp_tans_bytes:u32][mant_bytes:u32]
 * [packed signs (1bpv)][tANS exp bytes (high 8 of 11)][raw 55-bit mantissas]. */
static size_t cvdbp_enc(const ull *input, size_t num,
                                            unsigned char *out, size_t out_cap)
{
  int order = C_CONV_DOUBLE_ORDER, j, k;
  double y_buf[C_CONV_DOUBLE_ORDER], y_hist[C_CONV_DOUBLE_ORDER];
  double A[C_CONV_DOUBLE_ORDER * C_CONV_DOUBLE_ORDER];
  double b[C_CONV_DOUBLE_ORDER], w[C_CONV_DOUBLE_ORDER], bias = 0.0, mean_y = 0.0;
  size_t fixed_header = 2U + 8U + (size_t)order * 8U + (size_t)order * 8U;
  size_t triple_header = 12U, i, sign_bytes, mant_bytes, tans_size, total, residual_count;
  unsigned char *p_sig, *p_exp, *p_man, *exp_enc_buf;
  uint8_t *exp_buf;
  bw_t bw_sig, bw_man;
  if (num < (size_t)(order + 16)) return (size_t)-1;
  residual_count = num - (size_t)order;
  if ((fixed_header + triple_header) > out_cap) return (size_t)-1;
  for (j = 0; j < order; j++) memcpy(&y_buf[j], &input[j], sizeof(double));
  memset(A, 0, sizeof(A)); memset(b, 0, sizeof(b));
  for (i = (size_t)order; i < num; i++) {
    double y_cur;
    memcpy(&y_cur, &input[i], sizeof(double));
    if (!(y_cur == y_cur)) return (size_t)-1;
    for (j = 0; j < order; j++) {
      double yj = y_buf[order - 1 - j];
      b[j] += y_cur * yj;
      for (k = j; k < order; k++) A[j * order + k] += yj * y_buf[order - 1 - k];
    }
    mean_y += y_cur;
    for (j = 0; j + 1 < order; j++) y_buf[j] = y_buf[j + 1];
    y_buf[order - 1] = y_cur;
  }
  for (j = 0; j < order; j++) for (k = 0; k < j; k++) A[j * order + k] = A[k * order + j];
  if (!fc_cholesky_solve(A, b, w, order)) return (size_t)-1;
  {
    double mean = mean_y / (double)residual_count, leftover = 1.0;
    for (j = 0; j < order; j++) leftover -= w[j];
    bias = mean * leftover;
  }
  /* Bitplane residuals into sign(1) + exp_high(8) + mant(55). */
  sign_bytes = (residual_count + 7U) >> 3;
  mant_bytes = ((residual_count * 55U) + 7U) >> 3;
  if ((fixed_header + triple_header + sign_bytes + mant_bytes + residual_count) > out_cap) return (size_t)-1;
  exp_buf = (uint8_t *)malloc(residual_count);
  exp_enc_buf = (unsigned char *)malloc(residual_count + 1024U);
  if (!exp_buf || !exp_enc_buf) { free(exp_buf); free(exp_enc_buf); return (size_t)-1; }
  for (j = 0; j < order; j++) memcpy(&y_hist[j], &input[j], sizeof(double));
  p_sig = out + fixed_header + triple_header;
  p_man = p_sig + sign_bytes;
  bw_init(&bw_sig, p_sig, sign_bytes);
  bw_init(&bw_man, p_man, mant_bytes);
  for (i = (size_t)order; i < num; i++) {
    double y_cur, pred, residual_d;
    ull rb, sign_bit, exp_bits, mant_bits;
    memcpy(&y_cur, &input[i], sizeof(double));
    pred = fc_predict_double_volatile(bias, w, order, y_hist);
    residual_d = y_cur - pred;
    memcpy(&rb, &residual_d, sizeof(rb));
    /* Bit-exact lossless guard (see cvd_enc). */
    { volatile double pv = pred, rv = residual_d; double y_check = pv + rv;
      ull a, bv;
      memcpy(&a, &y_cur, sizeof(a)); memcpy(&bv, &y_check, sizeof(bv));
      if (a != bv) { free(exp_buf); free(exp_enc_buf); return (size_t)-1; } }
    sign_bit = (rb >> 63) & 1ULL;
    exp_bits = (rb >> 52) & 0x7ffULL;
    mant_bits = rb & 0x000fffffffffffffULL;
    bw_put(&bw_sig, sign_bit, 1);
    exp_buf[i - (size_t)order] = (uint8_t)((exp_bits >> 3) & 0xffULL);
    bw_put(&bw_man, mant_bits | ((exp_bits & 0x7ULL) << 52), 55);
    for (j = 0; j + 1 < order; j++) y_hist[j] = y_hist[j + 1];
    y_hist[order - 1] = y_cur;
  }
  (void)bw_bytes(&bw_sig); (void)bw_bytes(&bw_man);
  tans_size = fc_ans_compress_bytes(exp_buf, residual_count, exp_enc_buf, residual_count + 1024U);
  if (tans_size == (size_t)-1 || tans_size >= residual_count) { free(exp_buf); free(exp_enc_buf); return (size_t)-1; }
  /* Layout: sign | tans-exp | mant. memmove mant past the tANS-encoded exp. */
  p_exp = p_sig + sign_bytes;
  memmove(p_exp + tans_size, p_exp, mant_bytes);
  memcpy(p_exp, exp_enc_buf, tans_size);
  out[0] = (unsigned char)order;
  out[1] = 0U;
  { ull bias_bits; memcpy(&bias_bits, &bias, sizeof(bias_bits)); store_u64_unaligned(out + 2, bias_bits); }
  for (j = 0; j < order; j++) { ull wb; memcpy(&wb, &w[j], sizeof(wb)); store_u64_unaligned(out + 10 + j * 8, wb); }
  for (j = 0; j < order; j++) store_u64_unaligned(out + 10 + (size_t)order * 8U + (size_t)j * 8U, input[j]);
  {
    unsigned char *p = out + fixed_header;
    st32_le(p, (uint32_t)sign_bytes);
    st32_le(p + 4, (uint32_t)tans_size);
    st32_le(p + 8, (uint32_t)mant_bytes);
  }
  total = fixed_header + triple_header + sign_bytes + tans_size + mant_bytes;
  free(exp_buf); free(exp_enc_buf);
  return total;
}

static void cvdbp_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  int order, j;
  double bias, w[C_CONV_DOUBLE_ORDER], y_hist[C_CONV_DOUBLE_ORDER];
  size_t fixed_header, triple_header = 12U, sign_bytes, tans_size, mant_bytes, residual_count, i;
  uint8_t *exp_buf;
  br_t br_sig, br_man;
  if (num == 0U || in_bytes < 14U) return;
  order = (int)in[0];
  if (order != C_CONV_DOUBLE_ORDER) return;
  {
    ull bias_bits = load_u64_unaligned(in + 2);
    memcpy(&bias, &bias_bits, sizeof(bias));
  }
  for (j = 0; j < order; j++) { ull wb = load_u64_unaligned(in + 10 + j * 8); memcpy(&w[j], &wb, sizeof(w[j])); }
  for (j = 0; j < order && (size_t)j < num; j++) {
    out[j] = load_u64_unaligned(in + 10 + (size_t)order * 8U + (size_t)j * 8U);
    memcpy(&y_hist[j], &out[j], sizeof(y_hist[j]));
  }
  fixed_header = 2U + 8U + (size_t)order * 8U + (size_t)order * 8U;
  if (in_bytes < (fixed_header + triple_header)) return;
  {
    const unsigned char *p = in + fixed_header;
    sign_bytes = (size_t)p[0] | ((size_t)p[1] << 8) | ((size_t)p[2] << 16) | ((size_t)p[3] << 24);
    tans_size  = (size_t)p[4] | ((size_t)p[5] << 8) | ((size_t)p[6] << 16) | ((size_t)p[7] << 24);
    mant_bytes = (size_t)p[8] | ((size_t)p[9] << 8) | ((size_t)p[10] << 16) | ((size_t)p[11] << 24);
  }
  if ((fixed_header + triple_header + sign_bytes + tans_size + mant_bytes) > in_bytes) return;
  if ((size_t)order >= num) return;
  residual_count = num - (size_t)order;
  exp_buf = (uint8_t *)malloc(residual_count);
  if (exp_buf == NULL) return;
  /* Decode tANS-encoded exp stream. */
  if (fc_ans_decode_bytes(in + fixed_header + triple_header + sign_bytes,
                             tans_size, residual_count, exp_buf) != residual_count) {
    free(exp_buf);
    return;
  }
  br_init(&br_sig, in + fixed_header + triple_header, sign_bytes);
  br_init(&br_man, in + fixed_header + triple_header + sign_bytes + tans_size, mant_bytes);
  for (i = (size_t)order; i < num; i++) {
    double pred;
    double residual_d;
    double y_cur;
    ull rb;
    ull sign_bit;
    ull exp_high;
    ull exp_low3_and_mant;
    pred = fc_predict_double_volatile(bias, w, order, y_hist);
    sign_bit = br_get(&br_sig, 1);
    exp_high = (ull)exp_buf[i - (size_t)order];
    exp_low3_and_mant = br_get(&br_man, 55);
    rb = (sign_bit << 63)
       | ((exp_high << 3) | ((exp_low3_and_mant >> 52) & 0x7ULL)) << 52
       | (exp_low3_and_mant & 0x000fffffffffffffULL);
    memcpy(&residual_d, &rb, sizeof(residual_d));
    y_cur = pred + residual_d;
    memcpy(&out[i], &y_cur, sizeof(out[i]));
    for (j = 0; j + 1 < order; j++) y_hist[j] = y_hist[j + 1];
    y_hist[order - 1] = y_cur;
  }
  free(exp_buf);
}

/* PAQ mixer. Mixes pred_A=y[i-1] and pred_B=2*y[i-1]-y[i-2] via
 * online-adapted w in [0,2^15]. Integer-only update keeps encoder/decoder w
 * bit-identical. y capped at 2^45 (w*y < 2^60 fits int64).
 *
 * Wire: [res_width:u8][reserved:7B][pivot:u64][ord[0]-pivot:i64][ord[1]-pivot:i64]
 *       [zigzag residuals for i in [2,num)]. */
#define C_PAQ_Y_BOUND ((int64_t)1 << 45)

static int64_t fc_paq_predict_int(int64_t y_prev, int64_t y_prev2, int32_t mix_w)
{
  /* pred = (w * y_prev + (2^15 - w) * (2*y_prev - y_prev2)) >> 15
         = (w * y_prev + (2^15 - w) * 2*y_prev - (2^15 - w) * y_prev2) >> 15
     We compute the two predictors separately then mix to avoid overflow. */
  int64_t pred_A = y_prev;
  int64_t pred_B = (y_prev << 1) - y_prev2;
  int64_t mixed = ((int64_t)mix_w * pred_A
                  + (C_PAQ_MIX_ONE - (int64_t)mix_w) * pred_B);
  return mixed >> C_PAQ_MIX_LOG;
}

static int32_t fc_paq_update_w(int32_t w, int64_t actual, int64_t pred_A, int64_t pred_B)
{
  /* Move w toward 2^15 if pred_A was closer; toward 0 if pred_B was closer. */
  int64_t err_A = actual - pred_A;
  int64_t err_B = actual - pred_B;
  uint64_t abs_A = (err_A < 0) ? (uint64_t)(-err_A) : (uint64_t)err_A;
  uint64_t abs_B = (err_B < 0) ? (uint64_t)(-err_B) : (uint64_t)err_B;
  int32_t new_w = w;
  if (abs_A < abs_B) {
    /* A wins — increase w toward MAX. */
    new_w = w + (int32_t)((C_PAQ_MIX_ONE - (int64_t)w) >> C_PAQ_LEARN_SHIFT);
  } else if (abs_B < abs_A) {
    new_w = w - (int32_t)((int64_t)w >> C_PAQ_LEARN_SHIFT);
  }
  if (new_w < 0) new_w = 0;
  if (new_w > (int32_t)C_PAQ_MIX_ONE) new_w = (int32_t)C_PAQ_MIX_ONE;
  return new_w;
}

static size_t mix_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  size_t i, width, header_bytes = 32U;
  ull pivot, max_zz = 0;
  int64_t y0, y1, y2;
  int32_t mix_w = (int32_t)(C_PAQ_MIX_ONE >> 1);
  bw_t bw;
  if (num < 16U) return (size_t)-1;
  if (header_bytes > out_cap) return (size_t)-1;
  pivot = float_ordered(input[0]);
  y0 = (int64_t)(float_ordered(input[0]) - pivot);  /* always 0 */
  y1 = (int64_t)(float_ordered(input[1]) - pivot);
  if (y1 > C_PAQ_Y_BOUND || y1 < -C_PAQ_Y_BOUND) return (size_t)-1;
  /* First pass: compute residuals + max_zz. */
  for (i = 2; i < num; i++) {
    int64_t pred_A;
    int64_t pred_B;
    int64_t pred;
    int64_t residual;
    ull zz;
    y2 = (int64_t)(float_ordered(input[i]) - pivot);
    if (y2 > C_PAQ_Y_BOUND || y2 < -C_PAQ_Y_BOUND) return (size_t)-1;
    pred_A = y1;
    pred_B = (y1 << 1) - y0;
    pred = fc_paq_predict_int(y1, y0, mix_w);
    residual = y2 - pred;
    zz = zigzag64(residual);
    if (zz > max_zz) max_zz = zz;
    mix_w = fc_paq_update_w(mix_w, y2, pred_A, pred_B);
    y0 = y1;
    y1 = y2;
  }
  width = bits_required64(max_zz);
  if (width == 0U) width = 1U;
  if (width >= 60U) return (size_t)-1;
  if ((header_bytes + (((num - 2U) * width + 7U) >> 3)) > out_cap) return (size_t)-1;
  out[0] = (unsigned char)width;
  out[1] = 0; out[2] = 0; out[3] = 0;
  out[4] = 0; out[5] = 0; out[6] = 0; out[7] = 0;
  store_u64_unaligned(out + 8, pivot);
  store_u64_unaligned(out + 16, (ull)(int64_t)(float_ordered(input[0]) - pivot));
  store_u64_unaligned(out + 24, (ull)(int64_t)(float_ordered(input[1]) - pivot));
  bw_init(&bw, out + header_bytes, out_cap - header_bytes);
  /* Second pass: encode residuals at chosen width. Re-run predictor + mixer
     since the state evolves identically as in the first pass. */
  mix_w = (int32_t)(C_PAQ_MIX_ONE >> 1);
  y0 = (int64_t)(float_ordered(input[0]) - pivot);
  y1 = (int64_t)(float_ordered(input[1]) - pivot);
  for (i = 2; i < num; i++) {
    int64_t pred_A;
    int64_t pred_B;
    int64_t pred;
    int64_t residual;
    y2 = (int64_t)(float_ordered(input[i]) - pivot);
    pred_A = y1;
    pred_B = (y1 << 1) - y0;
    pred = fc_paq_predict_int(y1, y0, mix_w);
    residual = y2 - pred;
    bw_put(&bw, zigzag64(residual), width);
    mix_w = fc_paq_update_w(mix_w, y2, pred_A, pred_B);
    y0 = y1;
    y1 = y2;
  }
  return header_bytes + bw_bytes(&bw);
}

static void mix_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t i, width, header_bytes = 32U;
  ull pivot;
  int64_t y0, y1;
  int32_t mix_w = (int32_t)(C_PAQ_MIX_ONE >> 1);
  br_t br;
  if (num == 0U || in_bytes < header_bytes) return;
  width = (size_t)in[0];
  pivot = load_u64_unaligned(in + 8);
  y0 = (int64_t)load_u64_unaligned(in + 16);
  y1 = (int64_t)load_u64_unaligned(in + 24);
  out[0] = float_unordered(pivot + (ull)y0);
  if (num == 1U) return;
  out[1] = float_unordered(pivot + (ull)y1);
  if (num == 2U) return;
  br_init(&br, in + header_bytes, in_bytes - header_bytes);
  for (i = 2; i < num; i++) {
    int64_t pred_A = y1;
    int64_t pred_B = (y1 << 1) - y0;
    int64_t pred = fc_paq_predict_int(y1, y0, mix_w);
    int64_t residual = unzigzag64(br_get(&br, width));
    int64_t y2 = pred + residual;
    out[i] = float_unordered(pivot + (ull)y2);
    mix_w = fc_paq_update_w(mix_w, y2, pred_A, pred_B);
    y0 = y1;
    y1 = y2;
  }
}

/* PAQ-4 mixer: 4 predictors {y[-1], 2y[-1]-y[-2], 3y[-1]-3y[-2]+y[-3],
 * (y[-1]+y[-2])>>1}, Q.13 weights summing to 2^13, integer-only update.
 * Wire: [res_width:u8][reserved:7B][pivot:u64][ord[0..2]-pivot:i64×3]
 *       [zigzag residuals for i in [3,num)]. */
#define C_PAQ4_Y_BOUND ((int64_t)1 << 44)
#define C_PAQ4_NPRED 4

static int64_t fc_paq4_predict_int(int64_t y_p1, int64_t y_p2, int64_t y_p3, const int32_t *w)
{
  int64_t pred[C_PAQ4_NPRED];
  int64_t mix = 0;
  int j;
  pred[0] = y_p1;
  pred[1] = (y_p1 << 1) - y_p2;
  pred[2] = 3 * y_p1 - 3 * y_p2 + y_p3;
  pred[3] = (y_p1 + y_p2) >> 1;
  for (j = 0; j < C_PAQ4_NPRED; j++) mix += (int64_t)w[j] * pred[j];
  return mix >> C_PAQ4_MIX_LOG;
}

static void fc_paq4_update_w(int32_t *w, int64_t actual,
                                  int64_t y_p1, int64_t y_p2, int64_t y_p3)
{
  int64_t pred[C_PAQ4_NPRED];
  uint64_t err[C_PAQ4_NPRED];
  int j;
  int best = 0;
  uint64_t best_err;
  pred[0] = y_p1;
  pred[1] = (y_p1 << 1) - y_p2;
  pred[2] = 3 * y_p1 - 3 * y_p2 + y_p3;
  pred[3] = (y_p1 + y_p2) >> 1;
  for (j = 0; j < C_PAQ4_NPRED; j++) { int64_t e = actual - pred[j]; err[j] = (e < 0) ? (uint64_t)(-e) : (uint64_t)e; }
  best_err = err[0];
  for (j = 1; j < C_PAQ4_NPRED; j++) if (err[j] < best_err) { best_err = err[j]; best = j; }
  /* Increase best, decrease others proportionally — keep sum = 2^13. */
  {
    int32_t increase = (int32_t)((C_PAQ4_MIX_ONE - (int64_t)w[best]) >> C_PAQ4_LEARN_SHIFT);
    int32_t decrease_total = increase;
    int32_t total_other = (int32_t)C_PAQ4_MIX_ONE - w[best];
    if (total_other == 0) return;
    /* Subtract decrease_total from non-best weights, distributed
       proportionally to current weight. */
    for (j = 0; j < C_PAQ4_NPRED; j++) {
      int64_t share;
      if (j == best) continue;
      share = ((int64_t)w[j] * (int64_t)decrease_total) / (int64_t)total_other;
      w[j] -= (int32_t)share;
      if (w[j] < 0) w[j] = 0;
    }
    w[best] = (int32_t)(C_PAQ4_MIX_ONE);
    for (j = 0; j < C_PAQ4_NPRED; j++) if (j != best) w[best] -= w[j];
    if (w[best] < 0) w[best] = 0;
  }
}

static size_t mix4_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  size_t i, width, header_bytes = 40U;
  ull pivot, max_zz = 0;
  int64_t y0, y1, y2, y3;
  int32_t w[C_PAQ4_NPRED];
  bw_t bw;
  if (num < 16U) return (size_t)-1;
  if (header_bytes > out_cap) return (size_t)-1;
  pivot = float_ordered(input[0]);
  y0 = (int64_t)(float_ordered(input[0]) - pivot);
  y1 = (int64_t)(float_ordered(input[1]) - pivot);
  y2 = (int64_t)(float_ordered(input[2]) - pivot);
  if (y1 > C_PAQ4_Y_BOUND || y1 < -C_PAQ4_Y_BOUND) return (size_t)-1;
  if (y2 > C_PAQ4_Y_BOUND || y2 < -C_PAQ4_Y_BOUND) return (size_t)-1;
  /* Equal initial weights summing to 2^13. */
  w[0] = w[1] = w[2] = (int32_t)(C_PAQ4_MIX_ONE >> 2);
  w[3] = (int32_t)(C_PAQ4_MIX_ONE) - w[0] - w[1] - w[2];

  for (i = 3; i < num; i++) {
    int64_t pred;
    int64_t residual;
    ull zz;
    y3 = (int64_t)(float_ordered(input[i]) - pivot);
    if (y3 > C_PAQ4_Y_BOUND || y3 < -C_PAQ4_Y_BOUND) return (size_t)-1;
    pred = fc_paq4_predict_int(y2, y1, y0, w);
    residual = y3 - pred;
    zz = zigzag64(residual);
    if (zz > max_zz) max_zz = zz;
    fc_paq4_update_w(w, y3, y2, y1, y0);
    y0 = y1; y1 = y2; y2 = y3;
  }
  width = bits_required64(max_zz);
  if (width == 0U) width = 1U;
  if (width >= 60U) return (size_t)-1;
  if ((header_bytes + (((num - 3U) * width + 7U) >> 3)) > out_cap) return (size_t)-1;
  out[0] = (unsigned char)width;
  memset(out + 1, 0, 7);
  store_u64_unaligned(out + 8, pivot);
  store_u64_unaligned(out + 16, (ull)(int64_t)(float_ordered(input[0]) - pivot));
  store_u64_unaligned(out + 24, (ull)(int64_t)(float_ordered(input[1]) - pivot));
  store_u64_unaligned(out + 32, (ull)(int64_t)(float_ordered(input[2]) - pivot));
  bw_init(&bw, out + header_bytes, out_cap - header_bytes);
  w[0] = w[1] = w[2] = (int32_t)(C_PAQ4_MIX_ONE >> 2);
  w[3] = (int32_t)(C_PAQ4_MIX_ONE) - w[0] - w[1] - w[2];
  y0 = (int64_t)(float_ordered(input[0]) - pivot);
  y1 = (int64_t)(float_ordered(input[1]) - pivot);
  y2 = (int64_t)(float_ordered(input[2]) - pivot);
  for (i = 3; i < num; i++) {
    int64_t pred;
    int64_t residual;
    y3 = (int64_t)(float_ordered(input[i]) - pivot);
    pred = fc_paq4_predict_int(y2, y1, y0, w);
    residual = y3 - pred;
    bw_put(&bw, zigzag64(residual), width);
    fc_paq4_update_w(w, y3, y2, y1, y0);
    y0 = y1; y1 = y2; y2 = y3;
  }
  return header_bytes + bw_bytes(&bw);
}

static void mix4_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t i, width, header_bytes = 40U;
  ull pivot;
  int64_t y0, y1, y2;
  int32_t w[C_PAQ4_NPRED];
  br_t br;
  if (num == 0U || in_bytes < header_bytes) return;
  width = (size_t)in[0];
  pivot = load_u64_unaligned(in + 8);
  y0 = (int64_t)load_u64_unaligned(in + 16);
  y1 = (int64_t)load_u64_unaligned(in + 24);
  y2 = (int64_t)load_u64_unaligned(in + 32);
  out[0] = float_unordered(pivot + (ull)y0);
  if (num >= 2U) out[1] = float_unordered(pivot + (ull)y1);
  if (num >= 3U) out[2] = float_unordered(pivot + (ull)y2);
  if (num <= 3U) return;
  w[0] = w[1] = w[2] = (int32_t)(C_PAQ4_MIX_ONE >> 2);
  w[3] = (int32_t)(C_PAQ4_MIX_ONE) - w[0] - w[1] - w[2];
  br_init(&br, in + header_bytes, in_bytes - header_bytes);
  for (i = 3; i < num; i++) {
    int64_t pred = fc_paq4_predict_int(y2, y1, y0, w);
    int64_t residual = unzigzag64(br_get(&br, width));
    int64_t y3 = pred + residual;
    out[i] = float_unordered(pivot + (ull)y3);
    fc_paq4_update_w(w, y3, y2, y1, y0);
    y0 = y1; y1 = y2; y2 = y3;
  }
}

/* FuzzyStrideANS: FuzzyStride with per-value tANS-coded widths.
 * Wire: [base:u64][stride:u64][tans_size:u32 LE][tANS widths]
 *       [bit-packed variable-width zigzag residuals]. */
static size_t fzsa_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  size_t i, total_width_bits = 0U, header_bytes = 20U, tans_size, total;
  ull base, stride, expected, *zz_buf;
  uint8_t *width_buf;
  unsigned char *tans_buf;
  bw_t bw;
  if (num < 32U) return (size_t)-1;
  if (header_bytes >= out_cap) return (size_t)-1;
  base = input[0];
  stride = (num > 1U) ? input[1] - input[0] : 0U;

  width_buf = (uint8_t *)malloc(num);
  zz_buf = (ull *)malloc(num * sizeof(ull));
  tans_buf = (unsigned char *)malloc(num + 1024U);
  if (width_buf == NULL || zz_buf == NULL || tans_buf == NULL) { free(width_buf); free(zz_buf); free(tans_buf); return (size_t)-1; }
  expected = base;
  for (i = 0; i < num; i++) {
    ull zz = zigzag64((long long)(input[i] - expected));
    size_t w = bits_required64(zz);
    width_buf[i] = (uint8_t)w;
    zz_buf[i] = zz;
    total_width_bits += w;
    expected += stride;
  }
  tans_size = fc_ans_compress_bytes(width_buf, num, tans_buf, num + 1024U);
  if (tans_size == (size_t)-1) { free(width_buf); free(zz_buf); free(tans_buf); return (size_t)-1; }
  total = header_bytes + tans_size + ((total_width_bits + 7U) >> 3);
  if (total > out_cap) { free(width_buf); free(zz_buf); free(tans_buf); return (size_t)-1; }
  store_u64_unaligned(out, base);
  store_u64_unaligned(out + 8, stride);
  st32_le(out + 16, (uint32_t)tans_size);
  memcpy(out + header_bytes, tans_buf, tans_size);
  bw_init(&bw, out + header_bytes + tans_size, out_cap - header_bytes - tans_size);
  for (i = 0; i < num; i++) if (width_buf[i] > 0U) bw_put(&bw, zz_buf[i], width_buf[i]);
  total = header_bytes + tans_size + bw_bytes(&bw);
  free(width_buf);
  free(zz_buf);
  free(tans_buf);
  return total;
}

static void fzsa_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  ull base, stride, expected;
  size_t tans_size, i;
  uint8_t *width_buf;
  br_t br;
  if (num == 0U || in_bytes < 20U) return;
  base = load_u64_unaligned(in);
  stride = load_u64_unaligned(in + 8);
  tans_size = (size_t)ld32_le(in + 16);
  if ((20U + tans_size) > in_bytes) return;
  width_buf = (uint8_t *)malloc(num);
  if (width_buf == NULL) return;
  if (fc_ans_decode_bytes(in + 20, tans_size, num, width_buf) != num) { free(width_buf); return; }
  br_init(&br, in + 20U + tans_size, in_bytes - 20U - tans_size);
  expected = base;
  for (i = 0; i < num; i++) {
    size_t w = (size_t)width_buf[i];
    ull zz = (w > 0U) ? br_get(&br, w) : 0ULL;
    out[i] = expected + (ull)unzigzag64(zz);
    expected += stride;
  }
  free(width_buf);
}

/* BWT + MTF + tANS on byte-transposed input.
 * Wire: [primary_index:i32 LE][bwt_size:u32 LE][tans_size:u32 LE][tANS bytes]. */
static size_t bwtmt_enc(const ull *input, size_t num, unsigned char *transposed,
                        unsigned char *bwt_buf, unsigned char *mtf_buf,
                        int *sa, int *rank, int *new_rank, unsigned char *out, size_t out_cap)
{
  size_t bytes = num * sizeof(ull), header_bytes = 12U, tans_size;
  int primary;
  if (bytes < 256U || bytes > C_BWT_MAX_BYTES) return (size_t)-1;
  if ((header_bytes + bytes) > out_cap) return (size_t)-1;
  byte_transpose8((const unsigned char *)(const void *)input, num, transposed);
  if (!bwt_encode(transposed, (int)bytes, bwt_buf, &primary, sa, rank, new_rank)) return (size_t)-1;
  fc_mtf_forward(bwt_buf, bytes, mtf_buf);
  tans_size = fc_ans_compress_bytes(mtf_buf, bytes, out + header_bytes, out_cap - header_bytes);
  if (tans_size == (size_t)-1) return (size_t)-1;
  st32_le(out, (uint32_t)primary);
  st32_le(out + 4, (uint32_t)bytes);
  st32_le(out + 8, (uint32_t)tans_size);
  return header_bytes + tans_size;
}

static void bwtmt_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t header_bytes = 12U, bwt_size, tans_size, bytes;
  int primary, *T;
  unsigned char *bwt_buf, *mtf_buf, *transposed;
  if (in_bytes < header_bytes) return;
  primary   = (int)ld32_le(in);
  bwt_size  = (size_t)ld32_le(in + 4);
  tans_size = (size_t)ld32_le(in + 8);
  bytes = num * sizeof(ull);
  if (bwt_size != bytes || tans_size > in_bytes - header_bytes) return;
  bwt_buf = (unsigned char *)malloc(bytes);
  mtf_buf = (unsigned char *)malloc(bytes);
  transposed = (unsigned char *)malloc(bytes);
  T = (int *)malloc(bytes * sizeof(int));
  if (bwt_buf == NULL || mtf_buf == NULL || transposed == NULL || T == NULL) goto cleanup;
  if (fc_ans_decode_bytes(in + header_bytes, tans_size, bytes, mtf_buf) != bytes) goto cleanup;
  fc_mtf_inverse(mtf_buf, bytes, bwt_buf);
  bwt_decode(bwt_buf, (int)bytes, primary, transposed, T);
  byte_untranspose8(transposed, num, (unsigned char *)(void *)out);
cleanup:
  free(bwt_buf);
  free(mtf_buf);
  free(transposed);
  free(T);
}

/* BWT_MTF_RC: BWT_MTF_TANS but with 3-bit-history context range coder.
 * Wire: [primary_index:i32 LE][bwt_size:u32 LE][rc_size:u32 LE][rc bytes]. */
static size_t bwtmrc_enc(const ull *input, size_t num, unsigned char *transposed,
                         unsigned char *bwt_buf, unsigned char *mtf_buf,
                         int *sa, int *rank, int *new_rank, unsigned char *out, size_t out_cap)
{
  size_t bytes = num * sizeof(ull), header_bytes = 12U, rc_size;
  int primary;
  if (bytes < 256U || bytes > C_BWT_MAX_BYTES) return (size_t)-1;
  if ((header_bytes + bytes) > out_cap) return (size_t)-1;
  byte_transpose8((const unsigned char *)(const void *)input, num, transposed);
  if (bytes <= C_BWT_DOUBLING_THRESHOLD) {
    if (!bwt_encode(transposed, (int)bytes, bwt_buf, &primary, sa, rank, new_rank)) return (size_t)-1;
  } else {
    primary = sais_cyclic_bwt(transposed, (int)bytes, bwt_buf);
    if (primary < 0) return (size_t)-1;
  }
  fc_mtf_forward(bwt_buf, bytes, mtf_buf);
  rc_size = fc_rc_compress_bytes(mtf_buf, bytes, out + header_bytes, out_cap - header_bytes);
  if (rc_size == (size_t)-1) return (size_t)-1;
  st32_le(out, (uint32_t)primary);
  st32_le(out + 4, (uint32_t)bytes);
  st32_le(out + 8, (uint32_t)rc_size);
  return header_bytes + rc_size;
}

static void bwtmrc_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t header_bytes = 12U, bwt_size, rc_size, bytes;
  int primary, *T;
  unsigned char *bwt_buf, *mtf_buf, *transposed;
  if (in_bytes < header_bytes) return;
  primary  = (int)ld32_le(in);
  bwt_size = (size_t)ld32_le(in + 4);
  rc_size  = (size_t)ld32_le(in + 8);
  bytes = num * sizeof(ull);
  if (bwt_size != bytes || rc_size > in_bytes - header_bytes) return;
  bwt_buf = (unsigned char *)malloc(bytes);
  mtf_buf = (unsigned char *)malloc(bytes);
  transposed = (unsigned char *)malloc(bytes);
  T = (int *)malloc(bytes * sizeof(int));
  if (bwt_buf == NULL || mtf_buf == NULL || transposed == NULL || T == NULL) goto cleanup;
  if (fc_rc_decompress_bytes(in + header_bytes, rc_size, bytes, mtf_buf) != bytes) goto cleanup;
  fc_mtf_inverse(mtf_buf, bytes, bwt_buf);
  bwt_decode(bwt_buf, (int)bytes, primary, transposed, T);
  byte_untranspose8(transposed, num, (unsigned char *)(void *)out);
cleanup:
  free(bwt_buf);
  free(mtf_buf);
  free(transposed);
  free(T);
}

/* MTF (Move-To-Front) byte transform: maintain a list of 256 byte values;
   for each input byte, output its rank in the list and move it to front.
   Strongly compressible local repetition becomes runs of 0s in the output.
   We apply it to the byte-transposed input before LZ, since transposed
   exponent planes have heavy repetition. */
static void fc_mtf_forward(const unsigned char *src, size_t n, unsigned char *dst)
{
  uint8_t list[256];
  size_t i, r;
  for (i = 0; i < 256U; i++) list[i] = (uint8_t)i;
  for (i = 0; i < n; i++) {
    uint8_t b = src[i];
    for (r = 0; r < 256U; r++) if (list[r] == b) break;
    dst[i] = (uint8_t)r;
    if (r > 0U) { memmove(list + 1, list, r); list[0] = b; }
  }
}

static void fc_mtf_inverse(const unsigned char *src, size_t n, unsigned char *dst)
{
  uint8_t list[256];
  size_t i;
  for (i = 0; i < 256U; i++) list[i] = (uint8_t)i;
  for (i = 0; i < n; i++) {
    uint8_t r = src[i];
    uint8_t b = list[r];
    dst[i] = b;
    if (r > 0U) { memmove(list + 1, list, r); list[0] = b; }
  }
}

static size_t mlz_enc(const ull *input, size_t num, unsigned char *transposed,
                      unsigned char *mtf_buf, unsigned char *out, size_t out_cap)
{
  size_t bytes = num * sizeof(ull), lz_size;
  if (bytes < 256U) return (size_t)-1;
  byte_transpose8((const unsigned char *)(const void *)input, num, transposed);
  fc_mtf_forward(transposed, bytes, mtf_buf);
  lz_size = lz_enc(mtf_buf, bytes, out, out_cap);
  if (lz_size > bytes) return (size_t)-1;
  return lz_size;
}

static void mlz_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t bytes = num * sizeof(ull);
  unsigned char *mtf_buf = (unsigned char *)malloc(bytes);
  unsigned char *transposed = (unsigned char *)malloc(bytes);
  if (mtf_buf == NULL || transposed == NULL) goto cleanup;
  lz_dec(in, in_bytes, mtf_buf, bytes);
  fc_mtf_inverse(mtf_buf, bytes, transposed);
  byte_untranspose8(transposed, num, (unsigned char *)(void *)out);
cleanup:
  free(mtf_buf);
  free(transposed);
}

/* ConvNBinned: ConvN with per-value width residuals (DeltaBinned style).
 * Wire: [order:u8][scale_log:u8][reserved:u16][pivot:u64]
 *       [w[0..N]:i32 Q.SCALE_LOG][bias_q:i64][prefix y[0..N]:i64]
 *       [tans_size:u32 LE][tANS widths][packed variable-width residuals]. */
static size_t cvnb_enc(const ull *input, size_t num,
                                          unsigned char *out, size_t out_cap)
{
  enum { CHOICE_COUNT = 8 };
  int choices_order[CHOICE_COUNT] = {2, 4, 6, 8, 12, 16, 24, 32};
  size_t best_size = (size_t)-1, i, c;
  if (num < 32U) return (size_t)-1;
  for (c = 0; c < (size_t)CHOICE_COUNT; c++) {
    int order = choices_order[c], j, valid;
    ull pivot, *zz_buf;
    int64_t y_hist[C_CONV_N_MAX_ORDER], bias_q;
    double A[C_CONV_N_MAX_ORDER * C_CONV_N_MAX_ORDER];
    double b[C_CONV_N_MAX_ORDER], w_d[C_CONV_N_MAX_ORDER], mean_y_d = 0.0;
    int32_t w_q[C_CONV_N_MAX_ORDER];
    size_t residual_count, fixed_header, tans_size, total_residual_bits = 0U, total;
    uint8_t *width_buf;
    unsigned char *tans_buf;
    bw_t bw;
    if ((size_t)order >= num) continue;
    pivot = float_ordered(input[0]);
    valid = 1;
    {
      int64_t *y_array = (int64_t *)malloc(num * sizeof(int64_t));
      double R[C_CONV_N_MAX_ORDER + 1];
      if (y_array == NULL) continue;
      for (i = 0; i < num; i++) {
        y_array[i] = (int64_t)(float_ordered(input[i]) - pivot);
        if (y_array[i] > C_CONV_N_Y_BOUND || y_array[i] < -C_CONV_N_Y_BOUND) { valid = 0; break; }
      }
      if (!valid) { free(y_array); continue; }
      fc_toeplitz_lagsums(y_array, num, order, R);
      fc_toeplitz_build_normal_eqs(R, order, A, b);
      mean_y_d = 0.0;
      for (i = (size_t)order; i < num; i++) mean_y_d += (double)y_array[i];
      free(y_array);
      if (!fc_levinson_durbin(R, order, w_d) && !fc_cholesky_solve(A, b, w_d, order)) continue;
    }
    {
      int abort_choice = 0;
      for (j = 0; j < order; j++) {
        double w_scaled = w_d[j] * (double)(1 << C_CONV_N_SCALE_LOG);
        if (w_scaled > (double)C_CONV_N_W_BOUND || w_scaled < (double)(-C_CONV_N_W_BOUND)) { abort_choice = 1; break; }
        w_q[j] = (int32_t)(w_scaled >= 0.0 ? w_scaled + 0.5 : w_scaled - 0.5);
      }
      if (abort_choice) continue;
    }
    {
      double mean = mean_y_d / (double)(num - (size_t)order);
      double leftover = (double)((int64_t)1 << C_CONV_N_SCALE_LOG), bias_d;
      for (j = 0; j < order; j++) leftover -= (double)w_q[j];
      bias_d = mean * leftover;
      if (bias_d > (double)((int64_t)1 << 56) || bias_d < -(double)((int64_t)1 << 56)) continue;
      bias_q = (int64_t)(bias_d >= 0.0 ? bias_d + 0.5 : bias_d - 0.5);
    }
    residual_count = num - (size_t)order;
    width_buf = (uint8_t *)malloc(residual_count);
    zz_buf = (ull *)malloc(residual_count * sizeof(ull));
    tans_buf = (unsigned char *)malloc(residual_count + 1024U);
    if (!width_buf || !zz_buf || !tans_buf) { free(width_buf); free(zz_buf); free(tans_buf); continue; }
    for (j = 0; j < order; j++) y_hist[j] = (int64_t)(float_ordered(input[j]) - pivot);
    for (i = (size_t)order; i < num; i++) {
      int64_t y_cur = (int64_t)(float_ordered(input[i]) - pivot);
      int64_t pred = fc_conv_n_predict(w_q, order, bias_q, y_hist);
      ull zz = zigzag64(y_cur - pred);
      size_t w = bits_required64(zz);
      width_buf[i - (size_t)order] = (uint8_t)w;
      zz_buf[i - (size_t)order] = zz;
      total_residual_bits += w;
      for (j = 0; j + 1 < order; j++) y_hist[j] = y_hist[j + 1];
      y_hist[order - 1] = y_cur;
    }
    tans_size = fc_ans_compress_bytes(width_buf, residual_count, tans_buf, residual_count + 1024U);
    if (tans_size == (size_t)-1) { free(width_buf); free(zz_buf); free(tans_buf); continue; }
    fixed_header = 4U + 8U + (size_t)order * 4U + 8U + (size_t)order * 8U;
    total = fixed_header + 4U + tans_size + ((total_residual_bits + 7U) >> 3);
    if (total >= best_size || total > out_cap) { free(width_buf); free(zz_buf); free(tans_buf); continue; }
    out[0] = (unsigned char)order;
    out[1] = (unsigned char)C_CONV_N_SCALE_LOG;
    out[2] = 0; out[3] = 0;
    {
      unsigned char *p = out + 4;
      store_u64_unaligned(p, pivot); p += 8;
      for (j = 0; j < order; j++) { st32_le(p, (uint32_t)w_q[j]); p += 4; }
      store_u64_unaligned(p, (ull)bias_q); p += 8;
      for (j = 0; j < order; j++) { store_u64_unaligned(p, (ull)(int64_t)(float_ordered(input[j]) - pivot)); p += 8; }
      st32_le(p, (uint32_t)tans_size); p += 4;
      memcpy(p, tans_buf, tans_size); p += tans_size;
      bw_init(&bw, p, out_cap - (size_t)(p - out));
      for (i = 0; i < residual_count; i++) { size_t w = width_buf[i]; if (w > 0U) bw_put(&bw, zz_buf[i], w); }
      total = (size_t)(p - out) + bw_bytes(&bw);
    }
    free(width_buf); free(zz_buf); free(tans_buf);
    if (total < best_size) best_size = total;
  }
  return best_size;
}

static void cvnb_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  int order, j;
  size_t scale_log, fixed_header, tans_size, i, residual_count;
  ull pivot;
  int32_t w_q[C_CONV_N_MAX_ORDER];
  int64_t bias_q, y_hist[C_CONV_N_MAX_ORDER];
  uint8_t *width_buf;
  br_t br;
  if (num == 0U || in_bytes < 4U) return;
  order = (int)in[0];
  if (order < 1 || order > (int)C_CONV_N_MAX_ORDER) return;
  scale_log = (size_t)in[1];
  fixed_header = 4U + 8U + (size_t)order * 4U + 8U + (size_t)order * 8U;
  if (in_bytes < (fixed_header + 4U)) return;
  {
    const unsigned char *p = in + 4;
    pivot = load_u64_unaligned(p);
    p += 8;
    for (j = 0; j < order; j++) { w_q[j] = (int32_t)ld32_le(p); p += 4; }
    bias_q = (int64_t)load_u64_unaligned(p);
    p += 8;
    for (j = 0; j < order && (size_t)j < num; j++) {
      y_hist[j] = (int64_t)load_u64_unaligned(p);
      out[j] = float_unordered(pivot + (ull)y_hist[j]);
      p += 8;
    }
    tans_size = (size_t)ld32_le(p); p += 4;
    if ((size_t)order >= num) return;
    residual_count = num - (size_t)order;
    width_buf = (uint8_t *)malloc(residual_count);
    if (width_buf == NULL) return;
    if (fc_ans_decode_bytes(p, tans_size, residual_count, width_buf) != residual_count) { free(width_buf); return; }
    p += tans_size;
    br_init(&br, p, in_bytes - (size_t)(p - in));
  }
  for (i = (size_t)order; i < num; i++) {
    size_t w = (size_t)width_buf[i - (size_t)order];
    int64_t pred = bias_q;
    int64_t residual;
    int64_t y_cur;
    for (j = 0; j < order; j++) pred += (int64_t)w_q[j] * y_hist[j];
    pred = pred >> scale_log;
    residual = (w > 0U) ? unzigzag64(br_get(&br, w)) : 0;
    y_cur = pred + residual;
    out[i] = float_unordered(pivot + (ull)y_cur);
    for (j = 0; j + 1 < order; j++) y_hist[j] = y_hist[j + 1];
    y_hist[order - 1] = y_cur;
  }
  free(width_buf);
}

/* ConvNDPBinned: ConvN + DP-optimal bin partitioning on residuals.
 * Wire: [order:u8][scale_log:u8][reserved:u16][pivot:u64]
 *       [w[0..N]:i32][bias_q:i64][prefix y[0..N]:i64]
 *       [K:u8][bin_max_widths:u8×K][tans_size:u32 LE]
 *       [tANS bin_ids][packed variable-width residuals]. */
static size_t cvndp_enc(const ull *input, size_t num,
                                            unsigned char *out, size_t out_cap)
{
  enum { CHOICE_COUNT = 8 };
  int choices_order[CHOICE_COUNT] = {2, 4, 6, 8, 12, 16, 24, 32};
  size_t best_size = (size_t)-1, i, c;
  if (num < 32U) return (size_t)-1;
  for (c = 0; c < (size_t)CHOICE_COUNT; c++) {
    int order = choices_order[c], j, valid;
    ull pivot, *zz_buf;
    int64_t y_hist[C_CONV_N_MAX_ORDER], bias_q;
    double A[C_CONV_N_MAX_ORDER * C_CONV_N_MAX_ORDER];
    double b[C_CONV_N_MAX_ORDER], w_d[C_CONV_N_MAX_ORDER], mean_y_d = 0.0;
    int32_t w_q[C_CONV_N_MAX_ORDER];
    size_t residual_count, fixed_header, tans_size, total_residual_bits = 0U, total, k, best_k, w;
    uint8_t *width_buf, *bin_buf, bin_max_width[C_DP_BIN_MAX];
    unsigned char *tans_buf;
    bw_t bw;
    uint32_t hist[C_DP_WIDTH_BUCKETS];
    size_t prefix_count[C_DP_WIDTH_BUCKETS + 1], boundaries[C_DP_BIN_MAX + 1];
    double dp[C_DP_BIN_MAX][C_DP_WIDTH_BUCKETS], best_cost;
    int prev_split[C_DP_BIN_MAX][C_DP_WIDTH_BUCKETS];
    if ((size_t)order >= num) continue;
    pivot = float_ordered(input[0]);
    valid = 1;
    {
      int64_t *y_array = (int64_t *)malloc(num * sizeof(int64_t));
      double R[C_CONV_N_MAX_ORDER + 1];
      if (y_array == NULL) continue;
      for (i = 0; i < num; i++) {
        y_array[i] = (int64_t)(float_ordered(input[i]) - pivot);
        if (y_array[i] > C_CONV_N_Y_BOUND || y_array[i] < -C_CONV_N_Y_BOUND) { valid = 0; break; }
      }
      if (!valid) { free(y_array); continue; }
      fc_toeplitz_lagsums(y_array, num, order, R);
      fc_toeplitz_build_normal_eqs(R, order, A, b);
      mean_y_d = 0.0;
      for (i = (size_t)order; i < num; i++) mean_y_d += (double)y_array[i];
      free(y_array);
      if (!fc_levinson_durbin(R, order, w_d) && !fc_cholesky_solve(A, b, w_d, order)) continue;
    }
    {
      int abort_choice = 0;
      for (j = 0; j < order; j++) {
        double w_scaled = w_d[j] * (double)(1 << C_CONV_N_SCALE_LOG);
        if (w_scaled > (double)C_CONV_N_W_BOUND || w_scaled < (double)(-C_CONV_N_W_BOUND)) { abort_choice = 1; break; }
        w_q[j] = (int32_t)(w_scaled >= 0.0 ? w_scaled + 0.5 : w_scaled - 0.5);
      }
      if (abort_choice) continue;
    }
    {
      double mean = mean_y_d / (double)(num - (size_t)order);
      double leftover = (double)((int64_t)1 << C_CONV_N_SCALE_LOG), bias_d;
      for (j = 0; j < order; j++) leftover -= (double)w_q[j];
      bias_d = mean * leftover;
      if (bias_d > (double)((int64_t)1 << 56) || bias_d < -(double)((int64_t)1 << 56)) continue;
      bias_q = (int64_t)(bias_d >= 0.0 ? bias_d + 0.5 : bias_d - 0.5);
    }
    residual_count = num - (size_t)order;
    width_buf = (uint8_t *)malloc(residual_count);
    zz_buf = (ull *)malloc(residual_count * sizeof(ull));
    bin_buf = (uint8_t *)malloc(residual_count);
    tans_buf = (unsigned char *)malloc(residual_count + 1024U);
    if (!width_buf || !zz_buf || !bin_buf || !tans_buf) { continue; }

    memset(hist, 0, sizeof(hist));
    for (j = 0; j < order; j++) y_hist[j] = (int64_t)(float_ordered(input[j]) - pivot);
    for (i = (size_t)order; i < num; i++) {
      int64_t y_cur = (int64_t)(float_ordered(input[i]) - pivot);
      ull zz = zigzag64(y_cur - fc_conv_n_predict(w_q, order, bias_q, y_hist));
      size_t wi = bits_required64(zz);
      if (wi >= C_DP_WIDTH_BUCKETS) wi = C_DP_WIDTH_BUCKETS - 1U;
      width_buf[i - (size_t)order] = (uint8_t)wi; zz_buf[i - (size_t)order] = zz;
      hist[wi]++;
      for (j = 0; j + 1 < order; j++) y_hist[j] = y_hist[j + 1];
      y_hist[order - 1] = y_cur;
    }
    prefix_count[0] = 0;
    for (w = 0; w < C_DP_WIDTH_BUCKETS; w++) prefix_count[w + 1] = prefix_count[w] + hist[w];
    for (i = 0; i < C_DP_WIDTH_BUCKETS; i++) {
      dp[0][i] = (double)i * (double)prefix_count[i + 1];
      prev_split[0][i] = -1;
    }
    for (k = 1; k < C_DP_BIN_MAX; k++) for (i = 0; i < C_DP_WIDTH_BUCKETS; i++) {
      double best = 1e30;
      int best_j = -1, jp;
      for (jp = 0; jp < (int)i; jp++) {
        double total_cost = dp[k - 1][jp] + (double)i * (double)(prefix_count[i + 1] - prefix_count[jp + 1]);
        if (total_cost < best) { best = total_cost; best_j = jp; }
      }
      dp[k][i] = best; prev_split[k][i] = best_j;
    }
    best_k = 0; best_cost = 1e30;
    for (k = 0; k < C_DP_BIN_MAX; k++) {
      double total_bits = dp[k][C_DP_WIDTH_BUCKETS - 1U]
                        + (double)residual_count * (double)fc_fast_log2f((float)(k + 1U))
                        + (double)((k + 1U) * 8U + 13U);
      if (total_bits < best_cost) { best_cost = total_bits; best_k = k; }
    }
    {
      int cur = (int)C_DP_WIDTH_BUCKETS - 1;
      boundaries[best_k + 1U] = (size_t)cur;
      for (k = best_k; k > 0U; k--) { cur = prev_split[k][(size_t)cur]; boundaries[k] = (size_t)cur; }
      boundaries[0] = (size_t)-1;
    }
    for (k = 0; k <= best_k; k++) bin_max_width[k] = (uint8_t)boundaries[k + 1U];
    for (i = 0; i < residual_count; i++) {
      size_t wi = width_buf[i], b_idx;
      for (b_idx = 0; b_idx <= best_k; b_idx++) if (wi <= bin_max_width[b_idx]) { bin_buf[i] = (uint8_t)b_idx; break; }
    }
    total_residual_bits = 0U;
    for (i = 0; i < residual_count; i++) total_residual_bits += bin_max_width[bin_buf[i]];
    tans_size = fc_ans_compress_bytes(bin_buf, residual_count, tans_buf, residual_count + 1024U);
    if (tans_size == (size_t)-1) { continue; }
    fixed_header = 4U + 8U + (size_t)order * 4U + 8U + (size_t)order * 8U;
    total = fixed_header + 1U + (best_k + 1U) + 4U + tans_size + ((total_residual_bits + 7U) >> 3);
    if (total >= best_size || total > out_cap) { continue; }
    out[0] = (unsigned char)order;
    out[1] = (unsigned char)C_CONV_N_SCALE_LOG;
    out[2] = 0; out[3] = 0;
    {
      unsigned char *p = out + 4;
      size_t off;
      store_u64_unaligned(p, pivot); p += 8;
      for (j = 0; j < order; j++) { st32_le(p, (uint32_t)w_q[j]); p += 4; }
      store_u64_unaligned(p, (ull)bias_q); p += 8;
      for (j = 0; j < order; j++) { store_u64_unaligned(p, (ull)(int64_t)(float_ordered(input[j]) - pivot)); p += 8; }
      *p++ = (unsigned char)(best_k + 1U);
      for (k = 0; k <= best_k; k++) *p++ = bin_max_width[k];
      st32_le(p, (uint32_t)tans_size); p += 4;
      memcpy(p, tans_buf, tans_size); p += tans_size;
      off = (size_t)(p - out);
      bw_init(&bw, p, out_cap - off);
      for (i = 0; i < residual_count; i++) { size_t bin_w = bin_max_width[bin_buf[i]]; if (bin_w > 0U) bw_put(&bw, zz_buf[i], bin_w); }
      total = off + bw_bytes(&bw);
    }
    free(width_buf); free(zz_buf); free(bin_buf); free(tans_buf);
    if (total < best_size) best_size = total;
  }
  return best_size;
}

static void cvndp_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  int order, j;
  size_t scale_log, fixed_header, k_count, tans_size, residual_count, i, k;
  ull pivot;
  int32_t w_q[C_CONV_N_MAX_ORDER];
  int64_t bias_q, y_hist[C_CONV_N_MAX_ORDER];
  uint8_t bin_max_width[C_DP_BIN_MAX], *bin_buf;
  br_t br;
  if (num == 0U || in_bytes < 4U) return;
  order = (int)in[0];
  if (order < 1 || order > (int)C_CONV_N_MAX_ORDER) return;
  scale_log = (size_t)in[1];
  fixed_header = 4U + 8U + (size_t)order * 4U + 8U + (size_t)order * 8U;
  if (in_bytes < (fixed_header + 1U)) return;
  {
    const unsigned char *p = in + 4;
    pivot = load_u64_unaligned(p);
    p += 8;
    for (j = 0; j < order; j++) { w_q[j] = (int32_t)ld32_le(p); p += 4; }
    bias_q = (int64_t)load_u64_unaligned(p);
    p += 8;
    for (j = 0; j < order && (size_t)j < num; j++) {
      y_hist[j] = (int64_t)load_u64_unaligned(p);
      out[j] = float_unordered(pivot + (ull)y_hist[j]);
      p += 8;
    }
    k_count = (size_t)*p++;
    if (k_count == 0U || k_count > C_DP_BIN_MAX) return;
    for (k = 0; k < k_count; k++) bin_max_width[k] = *p++;
    tans_size = (size_t)ld32_le(p); p += 4;
    if ((size_t)order >= num) return;
    residual_count = num - (size_t)order;
    bin_buf = (uint8_t *)malloc(residual_count);
    if (bin_buf == NULL) return;
    if (fc_ans_decode_bytes(p, tans_size, residual_count, bin_buf) != residual_count) {
      free(bin_buf);
      return;
    }
    p += tans_size;
    br_init(&br, p, in_bytes - (size_t)(p - in));
  }
  for (i = (size_t)order; i < num; i++) {
    size_t bin_id = (size_t)bin_buf[i - (size_t)order];
    size_t bin_w;
    int64_t pred = bias_q;
    int64_t residual;
    int64_t y_cur;
    if (bin_id >= k_count) { free(bin_buf); return; }
    bin_w = (size_t)bin_max_width[bin_id];
    for (j = 0; j < order; j++) pred += (int64_t)w_q[j] * y_hist[j];
    pred = pred >> scale_log;
    residual = (bin_w > 0U) ? unzigzag64(br_get(&br, bin_w)) : 0;
    y_cur = pred + residual;
    out[i] = float_unordered(pivot + (ull)y_cur);
    for (j = 0; j + 1 < order; j++) y_hist[j] = y_hist[j + 1];
    y_hist[order - 1] = y_cur;
  }
  free(bin_buf);
}

/* SignConv: split signs from |magnitudes|, ConvN the magnitudes.
 * Wire: [sign_bytes:u32 LE][conv_bytes:u32 LE][packed signs (MSB-first)]
 *       [ConvN magnitudes]. */
static size_t sgc_enc(const ull *input, size_t num, ull *mag_buf, unsigned char *conv_buf,
                      unsigned char *out, size_t out_cap)
{
  size_t header_bytes = 8U, sign_bytes = (num + 7U) >> 3, conv_size, i;
  bw_t bw;
  if (num < 32U) return (size_t)-1;
  if ((header_bytes + sign_bytes) >= out_cap) return (size_t)-1;
  for (i = 0; i < num; i++) mag_buf[i] = input[i] & 0x7fffffffffffffffULL;
  conv_size = cvn_enc(mag_buf, num, conv_buf, out_cap - header_bytes - sign_bytes);
  if (conv_size == (size_t)-1) return (size_t)-1;
  bw_init(&bw, out + header_bytes, sign_bytes);
  for (i = 0; i < num; i++) bw_put(&bw, (input[i] >> 63) & 1ULL, 1);
  (void)bw_bytes(&bw);
  st32_le(out, (uint32_t)sign_bytes);
  st32_le(out + 4, (uint32_t)conv_size);
  memcpy(out + header_bytes + sign_bytes, conv_buf, conv_size);
  return header_bytes + sign_bytes + conv_size;
}

static void sgc_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t header_bytes = 8U, sign_bytes, conv_size, i;
  br_t br;
  if (num == 0U || in_bytes < header_bytes) return;
  sign_bytes = (size_t)ld32_le(in);
  conv_size  = (size_t)ld32_le(in + 4);
  if ((header_bytes + sign_bytes + conv_size) > in_bytes) return;
  cvn_dec(in + header_bytes + sign_bytes, conv_size, num, out);
  br_init(&br, in + header_bytes, sign_bytes);
  for (i = 0; i < num; i++) {
    ull s = br_get(&br, 1);
    out[i] = (out[i] & 0x7fffffffffffffffULL) | (s << 63);
  }
}

/* PRED4: 4-way FCM + 2-way DFCM + DDFCM = 7 predictors.
 * Tag byte: pred_id in top 3 bits, bcode in next 3 bits.
 *   pred_id 0..3 = FCM slot 0..3 (0 = MRU, 3 = LRU)
 *   pred_id 4..5 = DFCM slot 0..1
 *   pred_id 6   = DDFCM (acceleration)
 *   pred_id 7   = reserved → FCM slot 0
 * FCM indexed by (hash & ~3) + j; with predsize 64K → 2MB FCM/worker. */
static size_t pred4_enc(const ull *input, size_t num, size_t predsizem1,
                        ull *fcm, ull *dfcm, unsigned char *out)
{
  size_t i, hash = 0, dhash = 0, code_bytes = num, data = code_bytes;
  ull lastval = 0, laststride = 0, prevstride = 0, pred_dd = 0, pred_f0 = 0, pred_f1 = 0, pred_f2 = 0, pred_f3 = 0, pred_d0 = 0, pred_d1 = 0;
  size_t fcm_count = 0U, dfcm_count = 0U;
  int track_ok = pred_track_grow(num + 1U);
  if (!track_ok) {
    memset(fcm,  0, (predsizem1 + 1U) * sizeof(ull));
    memset(dfcm, 0, (predsizem1 + 1U) * sizeof(ull));
  }
  memset(out, 0, code_bytes);

  for (i = 0; i < num; i++) {
    ull val = input[i], best, stride;
    ull xor_f0 = val ^ pred_f0, xor_f1 = val ^ pred_f1, xor_f2 = val ^ pred_f2, xor_f3 = val ^ pred_f3;
    ull xor_d0 = val ^ pred_d0, xor_d1 = val ^ pred_d1, xor_dd;
    int code = 0, pred_id = 0, bcode, bytes;
    size_t j, base, dbase;
    pred_dd = lastval + laststride + (laststride - prevstride);
    xor_dd = val ^ pred_dd;
    best = xor_f0;
    if (xor_f1 < best) { best = xor_f1; pred_id = 1; }
    if (xor_f2 < best) { best = xor_f2; pred_id = 2; }
    if (xor_f3 < best) { best = xor_f3; pred_id = 3; }
    if (xor_d0 < best) { best = xor_d0; pred_id = 4; }
    if (xor_d1 < best) { best = xor_d1; pred_id = 5; }
    if (xor_dd < best) { best = xor_dd; pred_id = 6; }
    stride = val - lastval;
    prevstride = laststride;
    laststride = stride;
    lastval = val;

    base = hash & ~(size_t)3U;
    fcm[base + 3U] = fcm[base + 2U];
    fcm[base + 2U] = fcm[base + 1U];
    fcm[base + 1U] = fcm[base];
    fcm[base] = val;
    if (track_ok) g_pred_touched_fcm[fcm_count++] = (uint32_t)base;
    hash = fc_crc32_u64(val) & predsizem1;
    base = hash & ~(size_t)3U;
    pred_f0 = fcm[base]; pred_f1 = fcm[base + 1U]; pred_f2 = fcm[base + 2U]; pred_f3 = fcm[base + 3U];
    dbase = dhash & ~(size_t)1U;
    dfcm[dbase + 1U] = dfcm[dbase];
    dfcm[dbase] = stride;
    if (track_ok) g_pred_touched_dfcm[dfcm_count++] = (uint32_t)dbase;
    dhash = fc_crc32_u64(stride) & predsizem1;
    dbase = dhash & ~(size_t)1U;
    pred_d0 = val + dfcm[dbase]; pred_d1 = val + dfcm[dbase + 1U];
    bcode = fc_bcode(best);
    bytes = bcode + (bcode >> 2);
    code = (pred_id << 3) | bcode;
    out[i] = (unsigned char)code;
    store_u64_unaligned(out + data, best);
    data += (size_t)bytes;
    (void)j;
  }
  if (track_ok) {
    for (i = 0; i < fcm_count; i++) { size_t b = (size_t)g_pred_touched_fcm[i]; _mm256_storeu_si256((__m256i *)(void *)&fcm[b], _mm256_setzero_si256()); }
    for (i = 0; i < dfcm_count; i++) { size_t b = (size_t)g_pred_touched_dfcm[i]; _mm_storeu_si128((__m128i *)(void *)&dfcm[b], _mm_setzero_si128()); }
  }
  return data;
}

static void pred4_dec(const unsigned char *in, size_t in_bytes, size_t num,
                      size_t predsizem1, ull *fcm, ull *dfcm, ull *out)
{
  size_t i, hash = 0, dhash = 0, code_bytes = num, data = code_bytes;
  ull lastval = 0, laststride = 0, pred_dd = 0, pred_f0 = 0, pred_f1 = 0, pred_f2 = 0, pred_f3 = 0, pred_d0 = 0, pred_d1 = 0;
  size_t fcm_count = 0U, dfcm_count = 0U;
  int track_ok = pred_track_grow(num + 1U);
  (void)in_bytes;
  if (!track_ok) {
    memset(fcm,  0, (predsizem1 + 1U) * sizeof(ull));
    memset(dfcm, 0, (predsizem1 + 1U) * sizeof(ull));
  }

  for (i = 0; i < num; i++) {
    int code = in[i], bcode = code & 0x7, pred_id = (code >> 3) & 0x7, bytes = bcode + (bcode >> 2);
    ull val = 0, stride, preds[8];
    size_t j, base, dbase;
    for (j = 0; j < (size_t)bytes; j++) val |= ((ull)in[data++]) << (j * 8U);
    preds[0] = pred_f0; preds[1] = pred_f1; preds[2] = pred_f2; preds[3] = pred_f3;
    preds[4] = pred_d0; preds[5] = pred_d1; preds[6] = pred_dd; preds[7] = pred_f0;
    val ^= preds[(unsigned)pred_id & 7U];

    stride = val - lastval;
    pred_dd = val + stride + (stride - laststride);
    laststride = stride;

    base = hash & ~(size_t)3U;
    fcm[base + 3U] = fcm[base + 2U];
    fcm[base + 2U] = fcm[base + 1U];
    fcm[base + 1U] = fcm[base];
    fcm[base] = val;
    if (track_ok) g_pred_touched_fcm[fcm_count++] = (uint32_t)base;
    hash = fc_crc32_u64(val) & predsizem1;
    base = hash & ~(size_t)3U;
    pred_f0 = fcm[base]; pred_f1 = fcm[base + 1U]; pred_f2 = fcm[base + 2U]; pred_f3 = fcm[base + 3U];
    dbase = dhash & ~(size_t)1U;
    dfcm[dbase + 1U] = dfcm[dbase];
    dfcm[dbase] = stride;
    if (track_ok) g_pred_touched_dfcm[dfcm_count++] = (uint32_t)dbase;
    dhash = fc_crc32_u64(stride) & predsizem1;
    dbase = dhash & ~(size_t)1U;
    pred_d0 = val + dfcm[dbase]; pred_d1 = val + dfcm[dbase + 1U];
    lastval = val;
    out[i] = val;
  }
  if (track_ok) {
    for (i = 0; i < fcm_count; i++) { size_t b = (size_t)g_pred_touched_fcm[i]; _mm256_storeu_si256((__m256i *)(void *)&fcm[b], _mm256_setzero_si256()); }
    for (i = 0; i < dfcm_count; i++) { size_t b = (size_t)g_pred_touched_dfcm[i]; _mm_storeu_si128((__m128i *)(void *)&dfcm[b], _mm_setzero_si128()); }
  }
}

/* FloatMult: each value = q_i * B (B arbitrary float).
 * Wire: [B:f64][zigzag_q_delta_width:u8][q[0]:i64][packed zigzag q deltas]. */

/* Bit-test for ±0.0 — avoids the V550 epsilon-vs-exact issue: we genuinely
   need to know if `base` is the IEEE zero bit pattern, since dividing by it
   would produce inf/NaN. */
static inline int double_is_zero(double d)
{
  ull bits;
  memcpy(&bits, &d, sizeof(bits));
  return ((bits & 0x7fffffffffffffffULL) == 0ULL) ? 1 : 0;
}

static int float_mult_check(double base, double d, long long *q_out)
{
  double scaled, back;
  long long q;
  ull a, b;
  if (double_is_zero(base)) return 0;
  scaled = d / base;
  if ((scaled < -9223372036854774784.0) || (scaled > 9223372036854774784.0)) return 0;
  q = (long long)(scaled >= 0.0 ? scaled + 0.5 : scaled - 0.5);
  back = (double)q * base;
  memcpy(&a, &back, sizeof(a));
  memcpy(&b, &d, sizeof(b));
  if (a != b) return 0;
  *q_out = q;
  return 1;
}

static size_t fmul_enc(const ull *input, size_t num, unsigned char *out, size_t out_cap)
{
  enum { FM_PROBE_VALUES = 64, FM_HEADER_BYTES = 17 };
  double base = 0.0;
  size_t i, probe_n, width;
  long long q = 0, first_q = 0, prev_q = 0;
  ull max_zz;
  bw_t bw;

  if (num < 2U) return (size_t)-1;
  if (out_cap < FM_HEADER_BYTES) return (size_t)-1;

  probe_n = (num < FM_PROBE_VALUES) ? num : FM_PROBE_VALUES;
  for (i = 0; i < probe_n; i++) {
    double d;
    double abs_d;
    memcpy(&d, &input[i], sizeof(d));
    abs_d = (d < 0.0) ? -d : d;
    if (abs_d > 0.0 && (double_is_zero(base) || (abs_d < base))) base = abs_d;
  }
  if (double_is_zero(base)) return (size_t)-1;

  for (i = 0; i < num; i++) {
    double d;
    memcpy(&d, &input[i], sizeof(d));
    if (!float_mult_check(base, d, &q)) return (size_t)-1;
  }

  max_zz = 0;
  {
    double d0;
    memcpy(&d0, &input[0], sizeof(d0));
    (void)float_mult_check(base, d0, &first_q);
  }
  prev_q = first_q;
  for (i = 1; i < num; i++) {
    double d;
    long long qi = 0;
    ull zz;
    memcpy(&d, &input[i], sizeof(d));
    (void)float_mult_check(base, d, &qi);
    zz = zigzag64(qi - prev_q);
    if (zz > max_zz) max_zz = zz;
    prev_q = qi;
  }
  width = bits_required64(max_zz);
  if (width == 0U) width = 1U;

  if ((FM_HEADER_BYTES + (((num - 1U) * width) + 7U) / 8U) > out_cap) return (size_t)-1;

  {
    ull base_bits;
    memcpy(&base_bits, &base, sizeof(base_bits));
    store_u64_unaligned(out, base_bits);
  }
  out[8] = (unsigned char)width;
  store_u64_unaligned(out + 9, (ull)first_q);
  bw_init(&bw, out + FM_HEADER_BYTES, out_cap - FM_HEADER_BYTES);
  prev_q = first_q;
  for (i = 1; i < num; i++) {
    double d;
    long long qi = 0;
    memcpy(&d, &input[i], sizeof(d));
    (void)float_mult_check(base, d, &qi);
    bw_put(&bw, zigzag64(qi - prev_q), width);
    prev_q = qi;
  }
  return FM_HEADER_BYTES + bw_bytes(&bw);
}

static void fmul_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  enum { FM_HEADER_BYTES = 17 };
  ull base_bits = load_u64_unaligned(in);
  size_t width = (size_t)in[8], i;
  long long prev_q = (long long)load_u64_unaligned(in + 9);
  double base, d;
  br_t br;
  memcpy(&base, &base_bits, sizeof(base));
  d = (double)prev_q * base;
  memcpy(&out[0], &d, sizeof(d));
  br_init(&br, in + FM_HEADER_BYTES, in_bytes - FM_HEADER_BYTES);
  for (i = 1; i < num; i++) {
    ull zz = br_get(&br, width);
    prev_q += unzigzag64(zz);
    d = (double)prev_q * base;
    memcpy(&out[i], &d, sizeof(d));
  }
}

/* FCM_RLE: FCM with run-length encoding for perfect predictions.
 * Wire: [first:u64], then records: byte&0x80==0 ⇒ (byte+1) perfect runs;
 * byte&0x80==1 ⇒ bcode in low 3 bits, bcode bytes of XOR residual follow. */
static size_t fcmrle_enc(const ull *input, size_t num, unsigned char *scratch, unsigned char *out, size_t out_cap)
{
  ull *fcm_table = (ull *)(void *)scratch;
  size_t hash = 0;
  size_t i;
  size_t op = 0;
  size_t run = 0;

  if (num == 0U) return 0U;
  if (out_cap < sizeof(ull)) return (size_t)-1;
  memset(fcm_table, 0, C_FCM_RLE_HASH_SIZE * sizeof(ull));
  store_u64_unaligned(out, input[0]);
  op = sizeof(ull);
  fcm_table[hash] = input[0];
  hash = fc_crc32_u64(input[0]) & C_FCM_RLE_HASH_MASK;

  for (i = 1; i < num; i++) {
    ull val = input[i];
    ull pred = fcm_table[hash];
    ull x = val ^ pred;
    if (x == 0U) {
      run++;
      if (run >= (C_FCM_RLE_RUN_MAX + 1U)) {
        if ((op + 1U) > out_cap) return (size_t)-1;
        out[op++] = (unsigned char)(C_FCM_RLE_RUN_MAX);
        run = 0U;
      }
    } else {
      int bcode, bytes, j;
      if (run > 0U) {
        if ((op + 1U) > out_cap) return (size_t)-1;
        out[op++] = (unsigned char)(run - 1U);
        run = 0U;
      }
      bcode = fc_bcode(x);
      bytes = bcode + (bcode >> 2);
      if ((op + 1U + (size_t)bytes) > out_cap) return (size_t)-1;
      out[op++] = (unsigned char)(0x80U | (unsigned int)bcode);
      for (j = 0; j < bytes; j++) out[op++] = (unsigned char)(x >> ((unsigned int)j * BITS_PER_BYTE));
    }
    fcm_table[hash] = val;
    hash = fc_crc32_u64(val) & C_FCM_RLE_HASH_MASK;
  }
  if (run > 0U) {
    if ((op + 1U) > out_cap) return (size_t)-1;
    out[op++] = (unsigned char)(run - 1U);
  }
  return op;
}

static void fcmrle_dec(const unsigned char *in, size_t in_bytes, size_t num, unsigned char *scratch, ull *out)
{
  ull *fcm_table = (ull *)(void *)scratch;
  size_t hash = 0, i = 1, ip = sizeof(ull);
  if (num == 0U) return;
  memset(fcm_table, 0, C_FCM_RLE_HASH_SIZE * sizeof(ull));
  out[0] = load_u64_unaligned(in);
  fcm_table[hash] = out[0];
  hash = fc_crc32_u64(out[0]) & C_FCM_RLE_HASH_MASK;
  while ((i < num) && (ip < in_bytes)) {
    unsigned char tag = in[ip++];
    if ((tag & 0x80U) == 0U) {
      size_t run_len = (size_t)tag + 1U;
      size_t end = i + run_len;
      if (end > num) end = num;
      while (i < end) {
        ull val = fcm_table[hash];
        out[i] = val;
        fcm_table[hash] = val;
        hash = fc_crc32_u64(val) & C_FCM_RLE_HASH_MASK;
        i++;
      }
    } else {
      int bcode = (int)(tag & 0x07U), bytes = bcode + (bcode >> 2), j;
      ull x = 0, val;
      for (j = 0; j < bytes; j++) {
        if (ip >= in_bytes) return;
        x |= (ull)in[ip++] << ((unsigned int)j * BITS_PER_BYTE);
      }
      val = fcm_table[hash] ^ x;
      out[i] = val;
      fcm_table[hash] = val;
      hash = fc_crc32_u64(val) & C_FCM_RLE_HASH_MASK;
      i++;
    }
  }
}

/* Dictionary: ≤256 distinct values mapped to {1,2,4,8}-bit indices.
 * Wire: [count-1:u8][idx_width:u8][dict[0..count]:u64][packed indices]. */
static size_t dict_enc(const ull *input, size_t num, unsigned char *scratch, unsigned char *out, size_t out_cap)
{
  /* scratch layout: [hash_table:u16×HASH_SIZE][dict:u64×MAX_ENTRIES][indices:u8×num] */
  const size_t hash_bytes = C_DICT_HASH_SIZE * sizeof(uint16_t);
  const size_t dict_bytes = C_DICT_MAX_ENTRIES * sizeof(ull);
  uint16_t *hash_slot = (uint16_t *)(void *)scratch;
  ull *dict = (ull *)(void *)(scratch + hash_bytes);
  uint8_t *indices = (uint8_t *)(scratch + hash_bytes + dict_bytes);
  size_t dict_count = 0U, i, index_width, header_bytes, payload_bits, payload_bytes;
  bw_t bw;

  if (num == 0U) return 0U;
  memset(hash_slot, 0, C_DICT_HASH_SIZE * sizeof(uint16_t));

  for (i = 0; i < num; i++) {
    ull v = input[i];
    size_t h = fc_crc32_u64(v) & C_DICT_HASH_MASK;
    while (hash_slot[h] != 0U) {
      uint16_t slot = hash_slot[h];
      if (dict[slot - 1U] == v) {
        indices[i] = (uint8_t)(slot - 1U);
        break;
      }
      h = (h + 1U) & C_DICT_HASH_MASK;
    }
    if (hash_slot[h] == 0U) {
      if (dict_count >= C_DICT_MAX_ENTRIES) return (size_t)-1;
      dict[dict_count] = v;
      hash_slot[h] = (uint16_t)(dict_count + 1U);
      indices[i] = (uint8_t)dict_count;
      dict_count++;
    }
  }

  /* Pick the smallest index width that fits dict_count distinct entries. */
  index_width = (dict_count <= 2U) ? 1U : (dict_count <= 4U) ? 2U : (dict_count <= 16U) ? 4U : (size_t)BITS_PER_BYTE;

  header_bytes = 2U + (dict_count * sizeof(ull));
  payload_bits = num * index_width;
  payload_bytes = (payload_bits + 7U) / 8U;
  if ((header_bytes + payload_bytes) > out_cap) return (size_t)-1;

  out[0] = (unsigned char)(dict_count - 1U);
  out[1] = (unsigned char)index_width;
  for (i = 0; i < dict_count; i++) store_u64_unaligned(out + 2U + (i * sizeof(ull)), dict[i]);
  bw_init(&bw, out + header_bytes, out_cap - header_bytes);
  for (i = 0; i < num; i++) bw_put(&bw, (ull)indices[i], index_width);
  return header_bytes + bw_bytes(&bw);
}

static void dict_dec(const unsigned char *in, size_t in_bytes, size_t num, ull *out)
{
  size_t dict_count = (size_t)in[0] + 1U, index_width = (size_t)in[1];
  size_t header_bytes = 2U + (dict_count * sizeof(ull)), i;
  ull dict[C_DICT_MAX_ENTRIES];
  br_t br;
  for (i = 0; i < dict_count; i++) dict[i] = load_u64_unaligned(in + 2U + (i * sizeof(ull)));
  br_init(&br, in + header_bytes, in_bytes - header_bytes);
  for (i = 0; i < num; i++) {
    size_t idx = (size_t)br_get(&br, index_width);
    if (idx >= dict_count) idx = 0U;
    out[i] = dict[idx];
  }
}

/* Heuristic block-feature probe: scans up to 256 leading values
   and reports flags indicating which modes have any chance of winning. The
   compressor uses these to skip modes that cannot possibly compress this
   block, saving CPU without any ratio loss. */
typedef struct {
  uint64_t distinct_count, exp_range, sign_flips;
  int all_castable_to_float32, has_decimal_pattern, looks_like_repeats;
} blk_feats_t;

static void probe_block_features(const ull *input, size_t num, blk_feats_t *out)
{
  enum { PROBE_MAX_VALUES = 256, DISTINCT_HASH_SIZE = 1024U, DISTINCT_HASH_MASK = DISTINCT_HASH_SIZE - 1U };
  size_t probe_n = (num < PROBE_MAX_VALUES) ? num : PROBE_MAX_VALUES;
  size_t i, distinct = 0U, consec_eq = 0U, signs = 0U;
  size_t min_exp = 2047U, max_exp = 0U, decimal_fits = 0U, prev_sign = 0U;
  uint16_t hash_slot[DISTINCT_HASH_SIZE];
  ull seen_buf[PROBE_MAX_VALUES];
  int castable = 1;
  out->distinct_count = 0U; out->exp_range = 0U; out->sign_flips = 0U;
  out->all_castable_to_float32 = 0; out->has_decimal_pattern = 0; out->looks_like_repeats = 0;
  if (probe_n == 0U) return;

  memset(hash_slot, 0, sizeof(hash_slot));
  for (i = 0; i < probe_n; i++) {
    ull v = input[i];
    size_t exp_field = (size_t)((v >> 52U) & 0x7ffULL);
    size_t sign = (size_t)(v >> 63U);
    /* distinct count via linear-probe hash */
    size_t h = fc_crc32_u64(v) & DISTINCT_HASH_MASK;
    while (hash_slot[h] != 0U) {
      if (seen_buf[hash_slot[h] - 1U] == v) break;
      h = (h + 1U) & DISTINCT_HASH_MASK;
    }
    if (hash_slot[h] == 0U) { seen_buf[distinct] = v; hash_slot[h] = (uint16_t)(distinct + 1U); distinct++; }
    if (i > 0U && input[i] == input[i - 1U]) consec_eq++;
    if (i > 0U && sign != prev_sign) signs++;
    prev_sign = sign;
    if (exp_field < min_exp) min_exp = exp_field;
    if (exp_field > max_exp) max_exp = exp_field;
    if (castable) {
      double d, round_trip;
      ull a, b;
      memcpy(&d, &v, sizeof(d));
      round_trip = (double)(float)d;
      memcpy(&a, &round_trip, sizeof(a)); memcpy(&b, &d, sizeof(b));
      if (a != b) castable = 0;
    }
    {
      static const double scales[] = {1.0, 10.0, 100.0, 1000.0, 10000.0, 1000000.0};
      double d;
      size_t k;
      memcpy(&d, &v, sizeof(d));
      for (k = 0; k < sizeof(scales) / sizeof(scales[0]); k++) {
        double scaled = d * scales[k], back;
        long long q;
        ull a, b;
        if (scaled < -9223372036854774784.0 || scaled > 9223372036854774784.0) continue;
        q = (long long)(scaled >= 0.0 ? scaled + 0.5 : scaled - 0.5);
        back = (double)q / scales[k];
        memcpy(&a, &back, sizeof(a)); memcpy(&b, &d, sizeof(b));
        if (a == b) { decimal_fits++; break; }
      }
    }
  }
  out->distinct_count = distinct;
  out->exp_range = (max_exp >= min_exp) ? (max_exp - min_exp) : 0U;
  out->sign_flips = signs;
  out->all_castable_to_float32 = castable;
  out->has_decimal_pattern = (decimal_fits * 5U >= probe_n * 4U) ? 1 : 0;
  out->looks_like_repeats = ((consec_eq * 2U) > probe_n) ? 1 : 0;
}

/* ML mode predictor: single-layer linear classifier over
 * blk_feats_t + 2 indicators; score < threshold ⇒ skip mode. */
#define C_ML_NUM_FEATURES 8U
#define C_ML_NUM_MODES_SCORED 33U

typedef struct {
  float distinct_frac, exp_range_norm, sign_flip_frac, castable, decimal, repeats, low_distinct, bias;
} ml_feats_t;

static void fc_ml_features(const blk_feats_t *bf, size_t num, ml_feats_t *ml)
{
  float fnum = (num > 0U) ? (float)num : 1.0f;
  ml->distinct_frac = (float)bf->distinct_count / fnum;
  ml->exp_range_norm = (float)bf->exp_range / 64.0f;
  ml->sign_flip_frac = (float)bf->sign_flips / fnum;
  ml->castable = bf->all_castable_to_float32 ? 1.0f : 0.0f;
  ml->decimal = bf->has_decimal_pattern ? 1.0f : 0.0f;
  ml->repeats = bf->looks_like_repeats ? 1.0f : 0.0f;
  ml->low_distinct = (bf->distinct_count < 64U) ? 1.0f : 0.0f;
  ml->bias = 1.0f;
}

/* Hand-tuned linear-classifier weights, indexed by M_*. */
static const float fc_ml_weights[C_ML_NUM_MODES_SCORED][C_ML_NUM_FEATURES] = {
  /* features:    distinct  exp_rng sign_flp castab decim repeats low_dist bias */
  [M_PRED]            = { -2.0f,   0.0f,  0.0f,   0.0f,  0.0f,  0.0f,    0.0f, 1.0f },
  [M_CONST]          = { -10.0f,  0.0f,  0.0f,   0.0f,  0.0f,  3.0f,    1.0f, 0.0f },
  [M_STRIDE]         = { -2.0f,   0.0f, -1.0f,   0.0f,  0.0f,  0.0f,    0.5f, 1.0f },
  [M_XORZ]        = { -1.0f,  -1.0f, -0.5f,   0.0f,  0.0f, -0.5f,    0.0f, 1.0f },
  [M_LZ]             = { -1.0f,   0.0f,  0.0f,   0.0f,  0.0f,  1.0f,    1.0f, 1.0f },
  [M_FLOAT32]        = {  0.0f,   0.0f,  0.0f,   3.0f,  0.0f,  0.0f,    0.0f, 0.0f },
  [M_ORDERED_DELTA]  = { -1.0f,  -2.0f, -1.0f,   0.0f,  0.0f, -1.0f,    0.0f, 1.0f },
  [M_FUZZY_STRIDE]   = { -1.0f,  -2.0f, -1.0f,   0.0f,  0.0f, -1.0f,    0.0f, 1.0f },
  [M_ALP]            = {  0.0f,   0.0f,  0.0f,   0.0f,  3.0f,  0.0f,    0.0f, 0.0f },
  [M_TRAILING_ZERO_BP] = { 0.0f,  0.0f,  0.0f,   0.0f,  0.0f,  0.0f,    0.0f, 1.0f },
  [M_XOR128]       = { -1.0f,   0.0f,  0.0f,   0.0f,  0.0f,  1.0f,    0.5f, 0.5f },
  [M_BYTE_TRANSPOSE] = {  0.0f,   0.0f,  0.0f,   0.0f,  0.0f,  1.0f,    0.5f, 0.5f },
  [M_LSB_STRIP]      = {  0.0f,   0.0f,  0.0f,   0.0f,  0.0f,  0.0f,    0.0f, 1.0f },
  [M_LOOKBACK_DELTA] = { -1.0f,  -1.0f, -0.5f,   0.0f,  0.0f, -0.5f,    0.0f, 1.0f },
  [M_FLOAT_MULT]     = {  0.0f,   0.0f,  0.0f,   0.0f,  0.0f,  0.0f,    0.0f, 0.5f },
  [M_FCM_RLE]        = { -2.0f,   0.0f,  0.0f,   0.0f,  0.0f,  3.0f,    1.0f, 0.0f },
  [M_DICT]           = { -3.0f,   0.0f,  0.0f,   0.0f,  0.0f,  2.0f,    2.0f, 0.0f },
  [M_DELTA2]         = { -1.0f,  -2.0f,  0.0f,   0.0f,  0.0f, -1.0f,    0.0f, 1.0f },
  [M_BITPLANE]       = {  0.0f,  -1.0f, -0.5f,   0.0f,  0.0f, -1.0f,    0.0f, 0.5f },
  [M_INT_MULT]       = { -1.0f,   0.0f,  0.0f,   0.0f,  1.0f,  0.0f,    0.5f, 0.5f },
  [M_CONV1]          = { -1.0f,  -2.0f, -1.0f,   0.0f,  0.0f, -1.0f,    0.0f, 1.0f },
  [M_PRED_TANS]       = { -2.0f,   0.0f,  0.0f,   0.0f,  0.0f,  0.0f,    0.0f, 1.0f },
  [M_PRED2]           = { -2.0f,   0.0f,  0.0f,   0.0f,  0.0f,  0.0f,    0.0f, 1.0f },
  [M_PRED_ADAPTIVE]   = { -3.0f,   0.0f,  0.0f,   0.0f,  0.0f,  1.0f,    1.5f, 0.5f },
  [M_VITERBI]        = { -1.0f,   0.0f,  0.0f,   0.0f,  0.0f,  0.0f,    0.0f, 1.0f },
  [M_DELTA_BINNED]   = { -1.0f,  -1.0f, -0.5f,   0.0f,  0.0f, -0.5f,    0.0f, 1.0f },
  [M_PRED_RC]         = { -2.0f,   0.0f,  0.0f,   0.0f,  0.0f,  0.0f,    0.0f, 1.0f },
  [M_PRED_INTERLEAVED] = { -1.0f,  0.0f,  0.0f,   0.0f,  0.0f,  0.0f,    0.0f, 1.0f },
  [M_BWT]            = { -3.0f,   0.0f,  0.0f,   0.0f,  0.0f,  2.0f,    1.5f, 0.0f },
  [M_LZ_DICT]        = { -1.0f,   0.0f,  0.0f,   0.0f,  0.0f,  1.0f,    1.0f, 1.0f },
};

/* SGD-style online adaptation (encoder-only; decoder unaffected). */
#define C_ML_SKIP_THRESHOLD (-2.5f)
#define C_ML_LEARN_RATE 0.01f
#define C_ML_WEIGHT_DECAY 0.001f
static __thread float g_ml_weights_adapt[C_ML_NUM_MODES_SCORED][C_ML_NUM_FEATURES];
static __thread int   g_ml_weights_initialized = 0;

static void fc_ml_init_adaptive_weights(void)
{
  size_t m, f;
  if (g_ml_weights_initialized) return;
  for (m = 0; m < C_ML_NUM_MODES_SCORED; m++)
    for (f = 0; f < C_ML_NUM_FEATURES; f++) g_ml_weights_adapt[m][f] = fc_ml_weights[m][f];
  g_ml_weights_initialized = 1;
}

static float fc_ml_score_adaptive(const ml_feats_t *ml, int mode)
{
  const float *w;
  if (mode < 0 || mode >= (int)C_ML_NUM_MODES_SCORED) return 0.0f;
  fc_ml_init_adaptive_weights();
  w = g_ml_weights_adapt[mode];
  return ml->distinct_frac * w[0] + ml->exp_range_norm * w[1] + ml->sign_flip_frac * w[2]
       + ml->castable * w[3] + ml->decimal * w[4] + ml->repeats * w[5]
       + ml->low_distinct * w[6] + ml->bias * w[7];
}

static void fc_ml_observe_winner(const ml_feats_t *ml, int winning_mode)
{
  size_t m;
  float feat[C_ML_NUM_FEATURES];
  if (winning_mode < 0 || winning_mode >= (int)C_ML_NUM_MODES_SCORED) return;
  fc_ml_init_adaptive_weights();
  feat[0] = ml->distinct_frac; feat[1] = ml->exp_range_norm; feat[2] = ml->sign_flip_frac; feat[3] = ml->castable;
  feat[4] = ml->decimal; feat[5] = ml->repeats; feat[6] = ml->low_distinct; feat[7] = ml->bias;
  for (m = 0; m < C_ML_NUM_MODES_SCORED; m++) {
    size_t f;
    float scale = (m == (size_t)winning_mode) ? C_ML_LEARN_RATE : -C_ML_LEARN_RATE * 0.05f;
    for (f = 0; f < C_ML_NUM_FEATURES; f++) {
      g_ml_weights_adapt[m][f] += scale * feat[f];
      g_ml_weights_adapt[m][f] *= 1.0f - C_ML_WEIGHT_DECAY;
    }
  }
}

static int fc_ml_should_skip(const ml_feats_t *ml, int mode)
{
  return fc_ml_score_adaptive(ml, mode) < C_ML_SKIP_THRESHOLD;
}

static size_t blk_enc(const ull *input, size_t num, size_t predsizem1, ull *fcm, ull *dfcm, unsigned char *scratch, unsigned char *out)
{
  enum {
    EXTRA_SLOT_ORDERED_DELTA = 1, EXTRA_SLOT_FUZZY_STRIDE = 2, EXTRA_SLOT_ALP = 3,
    EXTRA_SLOT_TZBP = 4, EXTRA_SLOT_XOR128 = 5
  };
  enum {
    MODE_TMP_BYTE_TRANSPOSE_OUT = 0, MODE_TMP_BYTE_TRANSPOSE_TMP = 1,
    MODE_TMP_LSB_STRIP_OUT = 2, MODE_TMP_LSB_STRIP_SCRATCH = 3,
    MODE_TMP_LOOKBACK_OUT = 4, MODE_TMP_FLOAT_MULT_OUT = 5,
    MODE_TMP_FCM_RLE_OUT = 6, MODE_TMP_FCM_RLE_TABLE = 7,
    MODE_TMP_DICT_OUT = 8, MODE_TMP_DICT_SCRATCH = 9,
    MODE_TMP_DELTA2_OUT = 10, MODE_TMP_BITPLANE_OUT = 11,
    MODE_TMP_INT_MULT_OUT = 12, MODE_TMP_CONV1_OUT = 13,
    MODE_TMP_PREDTANS_OUT = 14, MODE_TMP_PREDTANS_fc = 15,
    MODE_TMP_PRED2_OUT = 16, MODE_TMP_PREDA_OUT = 17, MODE_TMP_PREDA_SCRATCH = 18,
    MODE_TMP_VITERBI_OUT = 19, MODE_TMP_VITERBI_PRED = 20, MODE_TMP_VITERBI_OD = 21,
    MODE_TMP_DELTA_BINNED_OUT = 22, MODE_TMP_PREDRC_OUT = 23, MODE_TMP_PREDRC_fc = 24,
    MODE_TMP_INTERLEAVED_OUT = 25, MODE_TMP_INTERLEAVED_SUB = 26, MODE_TMP_INTERLEAVED_PRED = 27,
    MODE_TMP_BWT_OUT = 28, MODE_TMP_BWT_TRANSPOSED = 29, MODE_TMP_BWT_BUF = 30,
    MODE_TMP_LZ_DICT_OUT = 31, MODE_TMP_LZ_DICT_COMBINED = 32, MODE_TMP_CONV_N_OUT = 33,
    MODE_TMP_SIGN_CONV_OUT = 34, MODE_TMP_SIGN_CONV_MAG = 35, MODE_TMP_SIGN_CONV_CONVBUF = 36,
    MODE_TMP_CONV_DOUBLE_OUT = 37, MODE_TMP_MTF_LZ_OUT = 38,
    MODE_TMP_MTF_LZ_TRANSPOSED = 39, MODE_TMP_MTF_LZ_BUF = 40,
    MODE_TMP_CONV_DOUBLE_BP_OUT = 41, MODE_TMP_CONV_N_BINNED_OUT = 42,
    MODE_TMP_PREDSI_OUT = 43, MODE_TMP_PREDSI_SUB = 44, MODE_TMP_PREDSI_fc = 45,
    MODE_TMP_FUZZY_ANS_OUT = 46, MODE_TMP_PAQ_MIXER_OUT = 47, MODE_TMP_PAQ4_MIXER_OUT = 48,
    MODE_TMP_BWT_MTF_TANS_OUT = 49, MODE_TMP_BWT_MTF_TANS_T = 50,
    MODE_TMP_BWT_MTF_TANS_BWT = 51, MODE_TMP_BWT_MTF_TANS_MTF = 52,
    MODE_TMP_PRED4_OUT = 53, MODE_TMP_DELTA_DP_BIN_OUT = 54, MODE_TMP_CONV_N_DP_BIN_OUT = 55,
    MODE_TMP_ELF_OUT = 56, MODE_TMP_LZ_SPLIT_OUT = 57,
    MODE_TMP_BWT_MTF_RC_OUT = 58, MODE_TMP_BWT_MTF_RC_T = 59,
    MODE_TMP_BWT_MTF_RC_BWT = 60, MODE_TMP_BWT_MTF_RC_MTF = 61
  };
#define C_SLOT(base, n) ((base) + ((size_t)(n) * raw_bytes) + ((size_t)(n) * 1024U))
#define C_EXPENSIVE_MODE_RATIO_DENOM 4U
#define TRY(M, EXPR, PAYLOAD) do { \
  struct timespec __t0, __t1; clock_gettime(CLOCK_MONOTONIC, &__t0); \
  sz = (EXPR); \
  clock_gettime(CLOCK_MONOTONIC, &__t1); \
  long long __ds = (long long)__t1.tv_sec - (long long)__t0.tv_sec; \
  long long __dn = (long long)__t1.tv_nsec - (long long)__t0.tv_nsec; \
  long long __delta = __ds * 1000000000LL + __dn; \
  unsigned long __ns = (__delta < 0) ? 0UL : (unsigned long)__delta; \
  __atomic_fetch_add(&fc_enc_mode_time_ns[(M)&63], __ns, __ATOMIC_RELAXED); \
  __atomic_fetch_add(&fc_enc_mode_calls[(M)&63], 1UL, __ATOMIC_RELAXED); \
  if (sz != (size_t)-1 && sz < best_size) { best_mode = (M); best_size = sz; best_payload = (PAYLOAD); } \
} while (0)
  const size_t raw_bytes = (size_t)num * sizeof(ull);
  unsigned char *xz_buf = scratch + raw_bytes + 1024;
  size_t xorz_cap = raw_bytes + ((size_t)num * 2) + 1024;
  unsigned char *lz = xz_buf + xorz_cap;
  unsigned char *extra = lz + raw_bytes + 1024;
  unsigned char *mode_tmp = C_SLOT(extra, EXTRA_SLOT_XOR128);
  unsigned char *best_payload = scratch;
  size_t best_size;
  int best_mode = M_PRED;
  ull stride = 0;
  size_t sz;
  blk_feats_t feats;
  ml_feats_t ml_feats;

  probe_block_features(input, num, &feats);
  fc_ml_features(&feats, num, &ml_feats);

  /* Fast structural tests first: a hit lets us skip every expensive mode. */
  if (block_is_constant_avx2(input, num)) {
    best_mode = M_CONST;
    best_size = 8;
    store_u64_unaligned(best_payload, input[0]);
    out[0] = (unsigned char)best_mode;
    avx2_copy(out + 1, best_payload, best_size);
    return best_size + 1;
  }
  if (block_is_stride(input, num, &stride)) {
    best_mode = M_STRIDE;
    best_size = 16;
    store_u64_unaligned(best_payload, input[0]);
    store_u64_unaligned(best_payload + 8, stride);
    out[0] = (unsigned char)best_mode;
    avx2_copy(out + 1, best_payload, best_size);
    return best_size + 1;
  }

  best_size = pred_enc(input, num, predsizem1, fcm, dfcm, best_payload);
  /* Capture pred_enc output for reuse by PRED_TANS/PRED_RC: best_payload is `scratch`,
   * which is not overwritten by xorz_enc/lz_enc/f32_enc/etc. (those use other buffers). */
  size_t cached_pred_fc_size = best_size;
  unsigned char *cached_pred_buf = best_payload;

  /* High-entropy gate: predictor ratio < 8/8.4 ⇒ skip xz_buf, lz, and heavies. */
  {
    int high_entropy = (best_size * 5U) >= ((size_t)num * 42U);
    if (!high_entropy) {
      /* LZ wins when distinct values are very few (dict-like). looks_like_repeats
       * (long consec_eq runs) usually loses to PRED_TANS instead. */
      if (feats.distinct_count < 32U) {
        TRY(M_XORZ, xorz_enc(input, num, xz_buf, xorz_cap), xz_buf);
        TRY(M_LZ, lz_enc((const unsigned char *)(const void *)input, raw_bytes, lz, raw_bytes + 512), lz);
      }
    }
    if (feats.all_castable_to_float32 && !feats.looks_like_repeats && f32_enc(input, num, extra)) {
      sz = (size_t)num * sizeof(float);
      if (sz < best_size) { best_mode = M_FLOAT32; best_size = sz; best_payload = extra; }
    }
    if (high_entropy) goto finalize;
  }

  /* Smooth-data gate: exp range ≤30 + low sign-flips + non-repetitive. */
  if (feats.exp_range <= 30U && (feats.sign_flips * 4U) <= (num < 256U ? num : 256U) && !feats.looks_like_repeats) {
    TRY(M_ORDERED_DELTA, ord_delta_enc(input, num, C_SLOT(extra, EXTRA_SLOT_ORDERED_DELTA), raw_bytes + 1024), C_SLOT(extra, EXTRA_SLOT_ORDERED_DELTA));
    /* FUZZY_STRIDE only when ORDERED_DELTA didn't already win AND data is barely compressed. */
    if (best_mode != M_ORDERED_DELTA && best_size * 5U > raw_bytes * 4U) TRY(M_FUZZY_STRIDE,  fzs_enc(input, num, C_SLOT(extra, EXTRA_SLOT_FUZZY_STRIDE), raw_bytes + 1024), C_SLOT(extra, EXTRA_SLOT_FUZZY_STRIDE));
  }
  if (feats.has_decimal_pattern)
    TRY(M_ALP, alp_enc(input, num, C_SLOT(extra, EXTRA_SLOT_ALP), raw_bytes + 1024), C_SLOT(extra, EXTRA_SLOT_ALP));
  /* TRAILING_ZERO_BP: needs many trailing-zero residuals AND no other mode has won well yet. */
  if ((feats.exp_range <= 30U || feats.looks_like_repeats) && best_size * 2U > raw_bytes) TRY(M_TRAILING_ZERO_BP, tzbp_enc(input, num, C_SLOT(extra, EXTRA_SLOT_TZBP), raw_bytes + 1024), C_SLOT(extra, EXTRA_SLOT_TZBP));

  /* Run the predictor-band winners EARLY so subsequent never-winners can gate
   * cleanly on `best_mode == M_PRED_TANS`. PRED_TANS / PRED_RC / DELTA_DP_BINNED
   * are the most common winners on real workloads. */
  /* PRED_TANS: reuse cached pred_enc output (saves a full pred_enc call). */
  { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_PREDTANS_OUT); TRY(M_PRED_TANS, predT_enc_cached(input, num, predsizem1, fcm, dfcm, cached_pred_buf, cached_pred_fc_size, NULL, p, raw_bytes + 1024), p); }
  if (feats.exp_range <= 30U && !feats.looks_like_repeats) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_DELTA_DP_BIN_OUT); TRY(M_DELTA_DP_BINNED, ddp_enc(input, num, p, raw_bytes + 1024), p); }

  /* Heavy modes only in middle ratio band: skip if already very compressed
     or essentially incompressible. */
  if (best_size * 16U <= raw_bytes * 15U && best_size * C_EXPENSIVE_MODE_RATIO_DENOM > raw_bytes) {
    /* XOR128: helps when low-bit XOR patterns repeat; gated by repetition signal. */
    if (feats.looks_like_repeats || feats.distinct_count < 200U) TRY(M_XOR128, xor128_enc(input, num, C_SLOT(extra, EXTRA_SLOT_XOR128), raw_bytes + 1024), C_SLOT(extra, EXTRA_SLOT_XOR128));
    /* ELF: smooth-data delta-of-exponent; only when data is smooth AND no other delta mode dominates. */
    if (feats.exp_range <= 30U && !feats.looks_like_repeats && best_mode != M_PRED_TANS && best_mode != M_DELTA_DP_BINNED && best_mode != M_ORDERED_DELTA && best_mode != M_ALP) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_ELF_OUT); TRY(M_ELF, elf_enc(input, num, p, raw_bytes + 1024), p); }
    /* LZ_SPLIT/BYTE_TRANSPOSE: byte-level redundancy. */
    if (feats.looks_like_repeats || feats.distinct_count < 200U) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_LZ_SPLIT_OUT); TRY(M_LZ_SPLIT, lzs_enc((const unsigned char *)(const void *)input, raw_bytes, p, raw_bytes + 1024), p); }
    if (feats.looks_like_repeats || feats.distinct_count < 200U) TRY(M_BYTE_TRANSPOSE, byte_xpose_enc(input, num, mode_tmp + raw_bytes + 1024, mode_tmp, raw_bytes + 1024), mode_tmp);
    /* LSB_STRIP: useful when low bits look like noise; rare on smooth or repetitive data. */
    if (!feats.looks_like_repeats && feats.distinct_count >= 200U && best_mode != M_PRED_TANS && best_mode != M_DELTA_DP_BINNED && best_mode != M_ORDERED_DELTA && best_mode != M_ALP) { unsigned char *p_out = mode_tmp + (raw_bytes * 2) + 2048; TRY(M_LSB_STRIP, lsb_enc(input, num, predsizem1, fcm, dfcm, mode_tmp + (raw_bytes * 3) + 3072, p_out, raw_bytes + 1024), p_out); }
    if (feats.looks_like_repeats || feats.distinct_count < 200U) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_LOOKBACK_OUT); TRY(M_LOOKBACK_DELTA, lbd_enc(input, num, p, raw_bytes + 1024), p); }
    { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_FLOAT_MULT_OUT); TRY(M_FLOAT_MULT, fmul_enc(input, num, p, raw_bytes + 1024), p); }
    if (feats.looks_like_repeats || feats.distinct_count <= 64U) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_FCM_RLE_OUT), *t = C_SLOT(mode_tmp, MODE_TMP_FCM_RLE_TABLE); TRY(M_FCM_RLE, fcmrle_enc(input, num, t, p, raw_bytes + 1024), p); }
    if (feats.distinct_count <= 64U) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_DICT_OUT), *scr = C_SLOT(mode_tmp, MODE_TMP_DICT_SCRATCH); TRY(M_DICT, dict_enc(input, num, scr, p, raw_bytes + 1024), p); }
    if (feats.exp_range <= 30U && (feats.sign_flips * 4U) <= (num < 256U ? num : 256U) && !feats.looks_like_repeats && best_mode != M_PRED_TANS && best_mode != M_DELTA_DP_BINNED && best_mode != M_ORDERED_DELTA && best_mode != M_ALP) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_DELTA2_OUT); TRY(M_DELTA2, d2_enc(input, num, p, raw_bytes + 1024), p); }
    if ((feats.sign_flips * 4U) <= (num < 256U ? num : 256U) && !feats.looks_like_repeats && best_mode != M_PRED_TANS && best_mode != M_DELTA_DP_BINNED && best_mode != M_ORDERED_DELTA && best_mode != M_ALP) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_BITPLANE_OUT); TRY(M_BITPLANE, bp_enc(input, num, p, raw_bytes + 1024), p); }
    { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_INT_MULT_OUT); TRY(M_INT_MULT, imul_enc(input, num, p, raw_bytes + 1024), p); }
    if (feats.exp_range <= 30U && !feats.looks_like_repeats && best_mode != M_PRED_TANS && best_mode != M_DELTA_DP_BINNED && best_mode != M_ORDERED_DELTA && best_mode != M_ALP) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_CONV_N_OUT); TRY(M_CONV_N, cvn_enc(input, num, p, raw_bytes + 1024), p); }
    if (feats.sign_flips > 0U) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_SIGN_CONV_OUT), *cv = C_SLOT(mode_tmp, MODE_TMP_SIGN_CONV_CONVBUF); ull *mag = (ull *)(void *)C_SLOT(mode_tmp, MODE_TMP_SIGN_CONV_MAG); TRY(M_SIGN_CONV, sgc_enc(input, num, mag, cv, p, raw_bytes + 1024), p); }
    if (feats.exp_range <= 30U && !feats.looks_like_repeats && best_mode != M_PRED_TANS && best_mode != M_DELTA_DP_BINNED && best_mode != M_ORDERED_DELTA && best_mode != M_ALP) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_CONV_DOUBLE_OUT); TRY(M_CONV_DOUBLE, cvd_enc(input, num, p, raw_bytes + 1024), p); }
    /* MTF_LZ benefits from byte-level repetition (post-MTF). Gate by feature. */
    if (feats.looks_like_repeats || feats.distinct_count < 200U) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_MTF_LZ_OUT), *t = C_SLOT(mode_tmp, MODE_TMP_MTF_LZ_TRANSPOSED), *b = C_SLOT(mode_tmp, MODE_TMP_MTF_LZ_BUF); TRY(M_MTF_LZ, mlz_enc(input, num, t, b, p, raw_bytes + 1024), p); }
    /* CONV_DOUBLE_BP works on smooth signals; gate on smoothness. */
    if (feats.exp_range <= 30U && !feats.looks_like_repeats && best_mode != M_PRED_TANS && best_mode != M_DELTA_DP_BINNED && best_mode != M_ORDERED_DELTA && best_mode != M_ALP) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_CONV_DOUBLE_BP_OUT); TRY(M_CONV_DOUBLE_BP, cvdbp_enc(input, num, p, raw_bytes + 1024), p); }
    if (feats.exp_range <= 30U && !feats.looks_like_repeats && best_mode != M_PRED_TANS && best_mode != M_DELTA_DP_BINNED && best_mode != M_ORDERED_DELTA && best_mode != M_ALP) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_CONV_N_BINNED_OUT); TRY(M_CONV_N_BINNED, cvnb_enc(input, num, p, raw_bytes + 1024), p); }
    if (feats.exp_range <= 30U && !feats.looks_like_repeats && best_mode != M_PRED_TANS && best_mode != M_DELTA_DP_BINNED && best_mode != M_ORDERED_DELTA && best_mode != M_ALP) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_CONV_N_DP_BIN_OUT); TRY(M_CONV_N_DP_BINNED, cvndp_enc(input, num, p, raw_bytes + 1024), p); }

    if (feats.exp_range <= 30U && (feats.sign_flips * 4U) <= (num < 256U ? num : 256U) && !feats.looks_like_repeats && best_mode != M_PRED_TANS && best_mode != M_DELTA_DP_BINNED && best_mode != M_ORDERED_DELTA && best_mode != M_ALP) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_FUZZY_ANS_OUT); TRY(M_FUZZY_STRIDE_ANS, fzsa_enc(input, num, p, raw_bytes + 1024), p); }
    /* PAQ mixers are slow and rarely win when a simpler mode has already
     * gotten the block below 50% of raw — gate to recover encoder throughput
     * on easily-compressible blocks without losing ratio on hard ones. */
    if (feats.exp_range <= 30U && !feats.looks_like_repeats && best_mode != M_PRED_TANS && best_mode != M_DELTA_DP_BINNED && best_mode != M_ORDERED_DELTA && best_mode != M_ALP && best_mode != M_PRED_RC) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_PAQ_MIXER_OUT); TRY(M_PAQ_MIXER, mix_enc(input, num, p, raw_bytes + 1024), p); }
    if (feats.exp_range <= 30U && !feats.looks_like_repeats && best_mode != M_PRED_TANS && best_mode != M_DELTA_DP_BINNED && best_mode != M_ORDERED_DELTA && best_mode != M_ALP && best_mode != M_PRED_RC) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_PAQ4_MIXER_OUT); TRY(M_PAQ4_MIXER, mix4_enc(input, num, p, raw_bytes + 1024), p); }
    if (feats.exp_range <= 30U && (feats.sign_flips * 4U) <= (num < 256U ? num : 256U) && !feats.looks_like_repeats) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_CONV1_OUT); TRY(M_CONV1, conv1_enc(input, num, p, raw_bytes + 1024), p); }
    /* PRED_TANS already tried earlier; skip duplicate. */
    { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_PRED2_OUT); sz = pred2_enc(input, num, predsizem1, fcm, dfcm, p); if (sz < best_size) { best_mode = M_PRED2; best_size = sz; best_payload = p; } }
    { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_PRED4_OUT); sz = pred4_enc(input, num, predsizem1, fcm, dfcm, p); if (sz < best_size) { best_mode = M_PRED4; best_size = sz; best_payload = p; } }
    if (feats.distinct_count < 4096U) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_PREDA_OUT), *scr = C_SLOT(mode_tmp, MODE_TMP_PREDA_SCRATCH); TRY(M_PRED_ADAPTIVE, predA_enc(input, num, fcm, dfcm, scr, p, raw_bytes + 1024), p); }
    if (num >= (2U * C_VITERBI_SUB_VALUES)) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_VITERBI_OUT), *fc_buf = C_SLOT(mode_tmp, MODE_TMP_VITERBI_PRED), *od = C_SLOT(mode_tmp, MODE_TMP_VITERBI_OD); TRY(M_VITERBI, vit_enc(input, num, predsizem1, fcm, dfcm, fc_buf, od, p, raw_bytes + 1024), p); }
    if (feats.exp_range <= 30U && !feats.looks_like_repeats && best_mode != M_PRED_TANS && best_mode != M_DELTA_DP_BINNED && best_mode != M_ORDERED_DELTA && best_mode != M_ALP) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_DELTA_BINNED_OUT); TRY(M_DELTA_BINNED, db_enc(input, num, p, raw_bytes + 1024), p); }
    /* DELTA_DP_BINNED already tried earlier; skip duplicate. */
    /* PRED_RC: reuse cached pred_enc output. */
    { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_PREDRC_OUT); TRY(M_PRED_RC, predRC_enc_cached(input, num, predsizem1, fcm, dfcm, cached_pred_buf, cached_pred_fc_size, NULL, p, raw_bytes + 1024), p); }
    /* PRED_INTERLEAVED: only as a last resort — when even simple predictor variants
     * are barely compressing (best_size still > 80% of raw). */
    if (best_mode != M_PRED_TANS && best_mode != M_PRED_RC && best_mode != M_DELTA_DP_BINNED && best_size * 5U > raw_bytes * 4U) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_INTERLEAVED_OUT), *fc_buf = C_SLOT(mode_tmp, MODE_TMP_INTERLEAVED_PRED); ull *sub = (ull *)(void *)C_SLOT(mode_tmp, MODE_TMP_INTERLEAVED_SUB); TRY(M_PRED_INTERLEAVED, predI_enc(input, num, predsizem1, fcm, dfcm, sub, fc_buf, p, raw_bytes + 1024), p); }
    /* PRED_SIMD_INTERLEAVED: same last-resort gating. */
    if (best_mode != M_PRED_TANS && best_mode != M_PRED_RC && best_mode != M_PRED_INTERLEAVED && best_mode != M_DELTA_DP_BINNED && best_size * 5U > raw_bytes * 4U) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_PREDSI_OUT); TRY(M_PRED_SIMD_INTERLEAVED, predSI_enc(input, num, predsizem1, p, raw_bytes + 1024), p); }
    /* LZ_DICT: seed LZ hash with synthetic dict of common floats — only useful when
     * data has dictionary-like structure (low distinct count). */
    if (feats.looks_like_repeats || feats.distinct_count < 200U) { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_LZ_DICT_OUT), *comb = C_SLOT(mode_tmp, MODE_TMP_LZ_DICT_COMBINED); TRY(M_LZ_DICT, lzd_enc(input, num, comb, p, raw_bytes + 1024), p); }
    /* BWT + variants: gated on size + structural redundancy. */
    if (raw_bytes <= C_BWT_MAX_BYTES && (feats.looks_like_repeats || feats.distinct_count < 256U) && !fc_ml_should_skip(&ml_feats, M_BWT)) {
      unsigned char *bwt_o = C_SLOT(mode_tmp, MODE_TMP_BWT_OUT), *bwt_t = C_SLOT(mode_tmp, MODE_TMP_BWT_TRANSPOSED), *bwt_b = C_SLOT(mode_tmp, MODE_TMP_BWT_BUF);
      int *sa_arr = (int *)malloc(raw_bytes * sizeof(int)), *rk_arr = (int *)malloc(raw_bytes * sizeof(int)), *new_rk = (int *)malloc(raw_bytes * sizeof(int));
      if (sa_arr && rk_arr && new_rk) {
        TRY(M_BWT, bwt_enc(input, num, bwt_t, bwt_b, sa_arr, rk_arr, new_rk, bwt_o, raw_bytes + 1024), bwt_o);
        { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_BWT_MTF_TANS_OUT), *t = C_SLOT(mode_tmp, MODE_TMP_BWT_MTF_TANS_T), *b = C_SLOT(mode_tmp, MODE_TMP_BWT_MTF_TANS_BWT), *m = C_SLOT(mode_tmp, MODE_TMP_BWT_MTF_TANS_MTF); TRY(M_BWT_MTF_TANS, bwtmt_enc(input, num, t, b, m, sa_arr, rk_arr, new_rk, p, raw_bytes + 1024), p); }
        { unsigned char *p = C_SLOT(mode_tmp, MODE_TMP_BWT_MTF_RC_OUT), *t = C_SLOT(mode_tmp, MODE_TMP_BWT_MTF_RC_T), *b = C_SLOT(mode_tmp, MODE_TMP_BWT_MTF_RC_BWT), *m = C_SLOT(mode_tmp, MODE_TMP_BWT_MTF_RC_MTF); TRY(M_BWT_MTF_RC, bwtmrc_enc(input, num, t, b, m, sa_arr, rk_arr, new_rk, p, raw_bytes + 1024), p); }
      }
      free(sa_arr); free(rk_arr); free(new_rk);
    }
  }

finalize:
  if (raw_bytes < best_size) {
    best_mode = M_RAW;
    best_size = raw_bytes;
    best_payload = (unsigned char *)(void *)(uintptr_t)input;
  }

  out[0] = (unsigned char)best_mode;
  avx2_copy(out + 1, best_payload, best_size);
  fc_ml_observe_winner(&ml_feats, best_mode);
  __atomic_fetch_add(&fc_enc_mode_wins[best_mode & 63], 1UL, __ATOMIC_RELAXED);
  if (getenv("C_DEBUG_MODES")) fprintf(stderr, "[fc] block num=%zu mode=%d size=%zu\n", num, best_mode, best_size);
  return best_size + 1;
#undef TRY
}

unsigned long fc_dec_mode_hist[64] = {0};
unsigned long fc_enc_mode_time_ns[64] = {0};
unsigned long fc_enc_mode_calls[64] = {0};
unsigned long fc_enc_mode_wins[64] = {0};
void fc_dec_mode_hist_reset(void){for(int i=0;i<64;i++)fc_dec_mode_hist[i]=0;}
const char *fc_mode_name(int mode){
  static const char *names[64]={
    "PRED","CONST","STRIDE","XORZ","LZ","RAW","FLOAT32","ORDERED_DELTA",
    "FUZZY_STRIDE","ALP","TRAILING_ZERO_BP","BYTE_TRANSPOSE","?12","XOR128",
    "?14","LSB_STRIP","LOOKBACK_DELTA","FLOAT_MULT","FCM_RLE","DICT","DELTA2",
    "BITPLANE","INT_MULT","CONV1","PRED_TANS","PRED2","PRED_ADAPTIVE","VITERBI",
    "DELTA_BINNED","PRED_RC","PRED_INTERLEAVED","BWT","LZ_DICT","CONV_N",
    "SIGN_CONV","CONV_DOUBLE","MTF_LZ","CONV_DOUBLE_BP","CONV_N_BINNED",
    "PRED_SIMD_INTERLEAVED","FUZZY_STRIDE_ANS","PAQ_MIXER","PAQ4_MIXER",
    "BWT_MTF_TANS","PRED4","DELTA_DP_BINNED","CONV_N_DP_BINNED","ELF",
    "LZ_SPLIT","BWT_MTF_RC","?50","?51","?52","?53","?54","?55","?56","?57",
    "?58","?59","?60","?61","?62","?63"
  };
  if(mode<0||mode>=64)return "?";
  return names[mode];
}

static void blk_dec(const unsigned char *input, size_t input_bytes, size_t num, size_t predsizem1, ull *fcm, ull *dfcm, ull *out)
{
  int mode = input[0];
  if((unsigned)mode<64)__atomic_fetch_add(&fc_dec_mode_hist[mode],1UL,__ATOMIC_RELAXED);
  const unsigned char *payload = input + 1;
  size_t payload_bytes = input_bytes - 1;
  size_t i;
  switch (mode) {
    case M_CONST: {
      ull value = load_u64_unaligned(payload);
      for (i = 0; i < num; i++) out[i] = value;
      break;
    }
    case M_STRIDE: {
      ull value = load_u64_unaligned(payload);
      ull stride = load_u64_unaligned(payload + 8);
      for (i = 0; i < num; i++) {
        out[i] = value;
        value += stride;
      }
      break;
    }
    case M_XORZ:             xorz_dec(payload, payload_bytes, num, out); break;
    case M_LZ:               lz_dec(payload, payload_bytes, (unsigned char *)(void *)out, num * sizeof(ull)); break;
    case M_RAW:              avx2_copy(out, payload, num * sizeof(ull)); break;
    case M_FLOAT32:          f32_dec(payload, num, out); break;
    case M_ORDERED_DELTA:    ord_delta_dec(payload, payload_bytes, num, out); break;
    case M_FUZZY_STRIDE:     fzs_dec(payload, payload_bytes, num, out); break;
    case M_ALP:              alp_dec(payload, payload_bytes, num, out); break;
    case M_TRAILING_ZERO_BP: tzbp_dec(payload, payload_bytes, num, out); break;
    case M_XOR128:           xor128_dec(payload, payload_bytes, num, out); break;
    case M_BYTE_TRANSPOSE:   byte_xpose_dec(payload, payload_bytes, num, out); break;
    case M_LSB_STRIP:        lsb_dec(payload, payload_bytes, num, predsizem1, fcm, dfcm, out); break;
    case M_LOOKBACK_DELTA:   lbd_dec(payload, payload_bytes, num, out); break;
    case M_FLOAT_MULT:       fmul_dec(payload, payload_bytes, num, out); break;
    case M_FCM_RLE:          fcmrle_dec(payload, payload_bytes, num, (unsigned char *)(void *)fcm, out); break;
    case M_DICT:             dict_dec(payload, payload_bytes, num, out); break;
    case M_DELTA2:           d2_dec(payload, payload_bytes, num, out); break;
    case M_BITPLANE:         bp_dec(payload, payload_bytes, num, out); break;
    case M_INT_MULT:         imul_dec(payload, payload_bytes, num, out); break;
    case M_CONV1:            conv1_dec(payload, payload_bytes, num, out); break;
    case M_PRED2:            pred2_dec(payload, payload_bytes, num, predsizem1, fcm, dfcm, out); break;
    case M_PRED4:            pred4_dec(payload, payload_bytes, num, predsizem1, fcm, dfcm, out); break;
    case M_DELTA_DP_BINNED:  ddp_dec(payload, payload_bytes, num, out); break;
    case M_CONV_N_DP_BINNED: cvndp_dec(payload, payload_bytes, num, out); break;
    case M_ELF:              elf_dec(payload, payload_bytes, num, out); break;
    case M_LZ_SPLIT:         lzs_dec(payload, payload_bytes, (unsigned char *)(void *)out, num * sizeof(ull)); break;
    case M_BWT_MTF_RC:       bwtmrc_dec(payload, payload_bytes, num, out); break;
    case M_PRED_ADAPTIVE:    predA_dec(payload, payload_bytes, num, fcm, dfcm, out); break;
    case M_VITERBI:          vit_dec(payload, payload_bytes, num, predsizem1, fcm, dfcm, out); break;
    case M_DELTA_BINNED:     db_dec(payload, payload_bytes, num, out); break;
    case M_BWT:              bwt_dec(payload, payload_bytes, num, out); break;
    case M_LZ_DICT:          lzd_dec(payload, payload_bytes, num, out); break;
    case M_CONV_N:           cvn_dec(payload, payload_bytes, num, out); break;
    case M_SIGN_CONV:        sgc_dec(payload, payload_bytes, num, out); break;
    case M_CONV_DOUBLE:      cvd_dec(payload, payload_bytes, num, out); break;
    case M_MTF_LZ:           mlz_dec(payload, payload_bytes, num, out); break;
    case M_CONV_DOUBLE_BP:   cvdbp_dec(payload, payload_bytes, num, out); break;
    case M_CONV_N_BINNED:    cvnb_dec(payload, payload_bytes, num, out); break;
    case M_FUZZY_STRIDE_ANS: fzsa_dec(payload, payload_bytes, num, out); break;
    case M_PAQ_MIXER:        mix_dec(payload, payload_bytes, num, out); break;
    case M_PAQ4_MIXER:       mix4_dec(payload, payload_bytes, num, out); break;
    case M_BWT_MTF_TANS:     bwtmt_dec(payload, payload_bytes, num, out); break;
    case M_PRED_INTERLEAVED: {
      ull *sub = (ull *)malloc(num * sizeof(ull));
      if (sub) { predI_dec(payload, payload_bytes, num, predsizem1, fcm, dfcm, sub, out); free(sub); }
      break;
    }
    case M_PRED_SIMD_INTERLEAVED: {
      ull *sub = (ull *)malloc(num * sizeof(ull));
      if (sub) { predSI_dec(payload, payload_bytes, num, predsizem1, fcm, dfcm, sub, out); free(sub); }
      break;
    }
    case M_PRED_RC: {
      unsigned char *tmp = (unsigned char *)malloc(num * 9U + 64U);
      if (tmp) { predRC_dec(payload, payload_bytes, num, predsizem1, fcm, dfcm, tmp, out); free(tmp); }
      break;
    }
    case M_PRED_TANS: {
      unsigned char *tmp = (unsigned char *)malloc(num * 9U + 64U);
      if (tmp) { predT_dec(payload, payload_bytes, num, predsizem1, fcm, dfcm, tmp, out); free(tmp); }
      break;
    }
    case M_PRED: default: pred_dec(payload, payload_bytes, num, predsizem1, fcm, dfcm, out); break;
  }
}

static inline size_t stream_read(void *buf, size_t sz, size_t items, const void *src, size_t bytes, size_t *cur)
{
  if (sz == 0U || *cur > bytes) return 0U;
  size_t avail = (bytes - *cur) / sz;
  size_t n = items < avail ? items : avail;
  memcpy(buf, (const char *)src + *cur, n * sz);
  *cur += n * sz;
  return n;
}

static inline size_t stream_write(const void *buf, size_t sz, size_t items, void *dst, size_t *cur)
{
  memcpy((char *)dst + *cur, buf, sz * items);
  *cur += sz * items;
  return items;
}

static size_t ceq_probe_chunk_values(const unsigned char *src, size_t bytes_left)
{
  uint16_t hist[256];
  size_t probe = bytes_left < C_ENTROPY_PROBE_BYTES ? bytes_left : C_ENTROPY_PROBE_BYTES;
  size_t i;
  size_t unique = 0U;
  size_t target;
  memset(hist, 0, sizeof(hist));
  for (i = 0U; i < probe; i++) {
    if (hist[src[i]] == 0U) unique++;
    if (hist[src[i]] != 65535U) hist[src[i]]++;
  }
  target = C_QUANTUM_BYTES + (((256U - unique) * (C_QUANTUM_MAX_BYTES - C_QUANTUM_BYTES)) / 256U);
  target -= target % C_QUANTUM_BYTES;
  if (target < C_QUANTUM_BYTES) target = C_QUANTUM_BYTES;
  if (target > C_QUANTUM_MAX_BYTES) target = C_QUANTUM_MAX_BYTES;
  if (target > bytes_left) target = bytes_left;
  target -= target & 7U;
  if (target == 0U) target = bytes_left & ~(size_t)7U;
  return target / sizeof(ull);
}

static void *al_alloc(size_t size, size_t factor)
{
  void *buf = NULL;
  if (posix_memalign(&buf, ALIGNSIZE, size * factor) != 0) abort();
  memset(buf, 0, size * factor);
  return buf;
}

static size_t clamp_threads(int threads, size_t jobs)
{
  size_t n = (threads <= 0) ? 1U : (size_t)threads;
  if (n > jobs) n = jobs;
  if (n == 0U) n = 1U;
  return n;
}

static int fc_auto_threads(void)
{
  int64_t n = (int64_t)sysconf(_SC_NPROCESSORS_ONLN);
  if (n <= (int64_t)0) return 1;
  if (n > (int64_t)128) return 128;
  return (int)n;
}

static void *fc_compress_worker(void *arg)
{
  pctx_t *ctx = (pctx_t *)arg;
  ull *fcm = (ull *)al_alloc((size_t)ctx->predsizem1 + 1U, sizeof(ull));
  ull *dfcm = (ull *)al_alloc((size_t)ctx->predsizem1 + 1U, sizeof(ull));
  unsigned char *scratch = (unsigned char *)al_alloc(C_QUANTUM_MAX_BYTES * 80U + 4096U, 1U);
  unsigned char *block_out = (unsigned char *)al_alloc(C_QUANTUM_MAX_BYTES + (C_QUANTUM_MAX_BYTES >> 1) + 4096U, 1U);
  for (;;) {
    size_t job_index;
    job_t *job;
    if (pthread_mutex_lock(&ctx->lock) != 0) break;
    job_index = ctx->next_job;
    if (job_index < ctx->job_count) ctx->next_job++;
    (void)pthread_mutex_unlock(&ctx->lock);
    if (job_index >= ctx->job_count) break;
    job = &ctx->jobs[job_index];
    if ((fcm != NULL) && (dfcm != NULL) && (scratch != NULL) && (block_out != NULL)) {
      size_t compressed = blk_enc(ctx->input + job->in_value_offset,
                                                (size_t)job->values,
                                                ctx->predsizem1,
                                                fcm,
                                                dfcm,
                                                scratch,
                                                block_out);
      job->compressed = (unsigned char *)malloc(compressed);
      if (job->compressed != NULL) {
        avx2_copy(job->compressed, block_out, compressed);
        job->compressed_bytes = (uint32_t)compressed;
        job->ok = 1;
      }
    }
  }
  free(fcm);
  free(dfcm);
  free(scratch);
  free(block_out);
  return NULL;
}

static void *fc_decompress_worker(void *arg)
{
  pctx_t *ctx = (pctx_t *)arg;
  /* Allocate fcm at max(predsizem1+1, C_FCM_RLE_HASH_SIZE) so the same
     buffer can serve both predictor's variable-size predictor and FcmRle's fixed
     32KB scratch without a second allocation. */
  size_t fcm_entries = (size_t)ctx->predsizem1 + 1U;
  if (fcm_entries < C_FCM_RLE_HASH_SIZE) fcm_entries = C_FCM_RLE_HASH_SIZE;
  ull *fcm = (ull *)al_alloc(fcm_entries, sizeof(ull));
  ull *dfcm = (ull *)al_alloc((size_t)ctx->predsizem1 + 1U, sizeof(ull));
  for (;;) {
    size_t job_index;
    job_t *job;
    if (pthread_mutex_lock(&ctx->lock) != 0) break;
    job_index = ctx->next_job;
    if (job_index < ctx->job_count) ctx->next_job++;
    (void)pthread_mutex_unlock(&ctx->lock);
    if (job_index >= ctx->job_count) break;
    job = &ctx->jobs[job_index];
    if ((fcm != NULL) && (dfcm != NULL)) {
      blk_dec(ctx->compressed_stream + job->in_value_offset,
                              job->compressed_bytes,
                              (size_t)job->values,
                              ctx->predsizem1,
                              fcm,
                              dfcm,
                              (ull *)(void *)(ctx->output + job->out_byte_offset));
      job->ok = 1;
    }
  }
  free(fcm);
  free(dfcm);
  return NULL;
}

size_t fc_enc(const void *in_stream, size_t in_bytes, void *out_stream, fc_cfg cfg)
{
  int predsizelg2 = cfg.p, threads = cfg.t;
  size_t out_cursor = 0, in_values = in_bytes >> 3, pos = 0, job_count = 0U, job_cap, i, thread_count, predsizem1;
  uint8_t pred_lg2;
  hdr_t hdr;
  job_t *jobs;
  pthread_t *worker;
  pctx_t ctx;
  (void)cfg.c;
  if (!in_stream || !out_stream || (in_bytes & 7U)) return 0U;
  if (predsizelg2 < 10) predsizelg2 = 10;
  if (predsizelg2 > 16) predsizelg2 = 16;
  pred_lg2 = (uint8_t)predsizelg2;
  predsizem1 = ((size_t)1U << pred_lg2) - 1U;

  memset(&hdr, 0, sizeof(hdr));
  hdr.magic = C_MAGIC;
  hdr.original_bytes = (uint64_t)in_bytes;
  hdr.quantum_bytes = C_QUANTUM_BYTES;
  hdr.predsizelg2 = pred_lg2;
  stream_write(&hdr, sizeof(hdr), 1, out_stream, &out_cursor);
  job_cap = (in_bytes / C_QUANTUM_BYTES) + 64U;
  jobs = (job_t *)calloc(job_cap, sizeof(*jobs));
  if (!jobs) return 0U;

  while (pos < in_values) {
    size_t remain = in_values - pos;
    size_t planned = ceq_probe_chunk_values((const unsigned char *)in_stream + pos * sizeof(ull), remain * sizeof(ull));
    size_t block_values = planned ? planned : remain;
    if (job_count == job_cap) {
      size_t new_cap = job_cap * 2U;
      job_t *new_jobs = (job_t *)realloc(jobs, new_cap * sizeof(*jobs));
      if (!new_jobs) { free(jobs); return 0U; }
      memset(new_jobs + job_cap, 0, (new_cap - job_cap) * sizeof(*jobs));
      jobs = new_jobs; job_cap = new_cap;
    }
    jobs[job_count].in_value_offset = pos;
    jobs[job_count].values = (uint32_t)block_values;
    pos += block_values; job_count++;
  }

  thread_count = clamp_threads(threads, job_count);
  worker = (pthread_t *)calloc(thread_count, sizeof(*worker));
  if (!worker) { free(jobs); return 0U; }
  memset(&ctx, 0, sizeof(ctx));
  ctx.input = (const ull *)in_stream;
  ctx.jobs = jobs;
  ctx.job_count = job_count;
  ctx.predsizem1 = predsizem1;
  if (pthread_mutex_init(&ctx.lock, NULL) != 0) { free(worker); free(jobs); return 0U; }
  for (i = 0U; i < thread_count; i++)
    if (pthread_create(&worker[i], NULL, fc_compress_worker, &ctx) != 0) { thread_count = i; break; }
  for (i = 0U; i < thread_count; i++) (void)pthread_join(worker[i], NULL);
  (void)pthread_mutex_destroy(&ctx.lock);
  for (i = 0U; i < job_count; i++) {
    bh_t bh;
    if (jobs[i].ok == 0) { out_cursor = 0U; break; }
    bh.values = (uint32_t)jobs[i].values;
    bh.compressed_bytes = (uint32_t)jobs[i].compressed_bytes;
    stream_write(&bh, sizeof(bh), 1, out_stream, &out_cursor);
    stream_write(jobs[i].compressed, 1, jobs[i].compressed_bytes, out_stream, &out_cursor);
  }
  for (i = 0U; i < job_count; i++) free(jobs[i].compressed);
  free(worker); free(jobs);
  return out_cursor;
}

size_t fc_dec(const void *in_stream, size_t in_bytes, void *out_stream)
{
  size_t in_cursor = 0, out_cursor = 0, job_count = 0U, job_cap = 64U, i, thread_count, predsizem1;
  hdr_t hdr;
  job_t *jobs;
  pthread_t *worker;
  pctx_t ctx;

  if (!in_stream || !out_stream) return 0U;
  if (stream_read(&hdr, sizeof(hdr), 1, in_stream, in_bytes, &in_cursor) != 1U) return 0U;
  if (hdr.magic != C_MAGIC || hdr.predsizelg2 < 10U || hdr.predsizelg2 > 16U) return 0U;
  predsizem1 = ((size_t)1U << hdr.predsizelg2) - 1U;
  jobs = (job_t *)calloc(job_cap, sizeof(*jobs));
  if (!jobs) return 0U;

  while (out_cursor < hdr.original_bytes) {
    bh_t bh;
    if (stream_read(&bh, sizeof(bh), 1, in_stream, in_bytes, &in_cursor) != 1U) { free(jobs); return 0U; }
    if ((size_t)bh.compressed_bytes > in_bytes - in_cursor ||
        (size_t)bh.values * sizeof(ull) > hdr.original_bytes - out_cursor) { free(jobs); return 0U; }
    if (job_count == job_cap) {
      size_t new_cap = job_cap * 2U;
      job_t *new_jobs = (job_t *)realloc(jobs, new_cap * sizeof(*jobs));
      if (!new_jobs) { free(jobs); return 0U; }
      memset(new_jobs + job_cap, 0, (new_cap - job_cap) * sizeof(*jobs));
      jobs = new_jobs; job_cap = new_cap;
    }
    jobs[job_count].in_value_offset = in_cursor;
    jobs[job_count].out_byte_offset = out_cursor;
    jobs[job_count].values = bh.values;
    jobs[job_count].compressed_bytes = bh.compressed_bytes;
    in_cursor += (size_t)bh.compressed_bytes;
    out_cursor += (size_t)bh.values * sizeof(ull);
    job_count++;
  }
  if (out_cursor != hdr.original_bytes) { free(jobs); return 0U; }

  thread_count = clamp_threads(fc_auto_threads(), job_count);
  worker = (pthread_t *)calloc(thread_count, sizeof(*worker));
  if (!worker) { free(jobs); return 0U; }
  memset(&ctx, 0, sizeof(ctx));
  ctx.compressed_stream = (const unsigned char *)in_stream;
  ctx.output = (unsigned char *)out_stream;
  ctx.jobs = jobs;
  ctx.job_count = job_count;
  ctx.predsizem1 = predsizem1;
  if (pthread_mutex_init(&ctx.lock, NULL) != 0) { free(worker); free(jobs); return 0U; }
  for (i = 0U; i < thread_count; i++)
    if (pthread_create(&worker[i], NULL, fc_decompress_worker, &ctx) != 0) { thread_count = i; break; }
  for (i = 0U; i < thread_count; i++) (void)pthread_join(worker[i], NULL);
  (void)pthread_mutex_destroy(&ctx.lock);
  for (i = 0U; i < job_count; i++)
    if (jobs[i].ok == 0) { out_cursor = 0U; break; }
  free(worker); free(jobs);
  return out_cursor;
}

const char fc_ver[] = "fc 1.56";