From cfe08cb404fddd867f7eca581c56c755b6858d6a Mon Sep 17 00:00:00 2001
From: Nelson Spence <nelson@projectnavi.ai>
Date: Sun, 14 Jun 2026 22:29:18 -0500
Subject: [PATCH 1/5] bench: add BEIR retrieval benchmark harness (make
 benchmark-beir)

Adds a reproducible BEIR benchmark per the repo spec, evaluating nDCG@10 vs BEIR
qrels with the same Harrier embeddings across OrdVec, FAISS FlatIP, and HNSW.
Python prepares public BEIR data + Harrier embeddings (cached normalized f32
.npy) and evaluates qrels; Rust owns every OrdVec hot path; FAISS/HNSW are native
baselines. No 'import ordvec' in the harness (the hot path is the Rust crate).

- benchmarks/beir/: common.py (shared contract), beir_prepare.py (BEIR download +
  Harrier encode, sentence-transformers/CUDA + Ollama/GGUF lanes, validation),
  beir_baselines.py (FAISS FlatIP + hnswlib), beir_eval.py (nDCG@10/MAP/Recall/MRR/
  Precision vs qrels + paired bootstrap CIs vs FAISS), beir_report.py (tables),
  README, requirements.txt.
- examples/beir_ordvec.rs: loads cached .npy, runs rq2/rq4 (batched
  search_asymmetric) and bitmap-rq2/sign-rq2 (batched CSR candidate-gen + pooled
  SubsetScratch allocation-free rerank); emits top-k JSONL (real rank-ordered
  scores) + summary JSON (bytes/vec, build/latency p50/p95/p99, simd_detected).
  No BEIR metrics computed in Rust.
- root Makefile: benchmark-beir / -smoke / -bm25 + bench-beir-{setup,prepare,
  prepare-ollama,ordvec,baselines,eval,guardrail,clean,clean-cache}.
- guardrail target greps for 'import ordvec' in benchmarks/beir and fails.

Headline discipline: nDCG@10 vs qrels is the metric; FAISS FlatIP is a full-float
dense baseline, NOT ground truth; ANN-recall-vs-FAISS is an optional diagnostic.

Verified: cargo build --release --example beir_ordvec (+fmt), python3 -m
py_compile all scripts, make -n benchmark-beir-smoke.

Signed-off-by: Nelson Spence <nelson@projectnavi.ai>
---
 .gitignore                        |    5 +
 Makefile                          |  176 +++++
 benchmarks/beir/README.md         |  158 ++++
 benchmarks/beir/beir_baselines.py |  459 +++++++++++
 benchmarks/beir/beir_eval.py      |  770 +++++++++++++++++++
 benchmarks/beir/beir_prepare.py   |  565 ++++++++++++++
 benchmarks/beir/beir_report.py    |  469 +++++++++++
 benchmarks/beir/common.py         |  289 +++++++
 benchmarks/beir/requirements.txt  |   12 +
 examples/beir_ordvec.rs           | 1195 +++++++++++++++++++++++++++++
 results/beir/.gitkeep             |    0
 11 files changed, 4098 insertions(+)
 create mode 100644 Makefile
 create mode 100644 benchmarks/beir/README.md
 create mode 100644 benchmarks/beir/beir_baselines.py
 create mode 100644 benchmarks/beir/beir_eval.py
 create mode 100644 benchmarks/beir/beir_prepare.py
 create mode 100644 benchmarks/beir/beir_report.py
 create mode 100644 benchmarks/beir/common.py
 create mode 100644 benchmarks/beir/requirements.txt
 create mode 100644 examples/beir_ordvec.rs
 create mode 100644 results/beir/.gitkeep

diff --git a/.gitignore b/.gitignore
index d342254b..6d7da4c6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -39,3 +39,8 @@ venv/
 .DS_Store
 .idea/
 .vscode/
+
+# BEIR benchmark harness — embedding cache and result files.
+/.cache/ordvec-beir/
+/results/beir/*
+!/results/beir/.gitkeep
diff --git a/Makefile b/Makefile
new file mode 100644
index 00000000..c6208cf8
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,176 @@
+# ordvec-beir benchmark harness
+# Reproduces nDCG@10 on standard BEIR datasets using ordvec's rank/sign retrieval
+# methods plus FAISS FlatIP + HNSW dense baselines (for comparison, NOT ground truth).
+#
+# Usage:
+#   make bench-beir-setup          # install Python deps
+#   make benchmark-beir-smoke      # quick sanity run (scifact only)
+#   make benchmark-beir            # full suite
+
+# ── interpreter ──────────────────────────────────────────────────────────────
+PY ?= python3
+
+# ── paths ─────────────────────────────────────────────────────────────────────
+CACHE_DIR  := .cache/ordvec-beir
+RESULTS_DIR := results/beir
+
+# ── dataset suite ─────────────────────────────────────────────────────────────
+DATASETS       := scifact nfcorpus fiqa trec-covid
+SMOKE_DATASETS := scifact
+SPLIT          := test
+
+# ── retrieval parameters ─────────────────────────────────────────────────────
+TOPK       := 100
+K_VALUES   := 10 100
+BATCH      := 8
+CANDIDATES := 500
+SEED       := 1
+
+# ── encoder ───────────────────────────────────────────────────────────────────
+ENCODER_PROVIDER  := st
+HARRIER_MODEL     := microsoft/harrier-oss-v1-0.6b
+HARRIER_REVISION  :=
+DEVICE            := cuda
+ENCODE_BATCH      := 16
+
+# ── ollama lane ───────────────────────────────────────────────────────────────
+OLLAMA_URL          := http://localhost:11434
+HARRIER_GGUF_MODEL  := hf.co/mradermacher/harrier-oss-v1-0.6b-GGUF:Q8_0
+
+# ── baselines + ordvec methods ────────────────────────────────────────────────
+ORDVEC_METHODS    := rq2,rq4,bitmap-rq2,sign-rq2
+BASELINE_METHODS  := faiss-flat,hnswlib
+HNSW_M            := 32
+HNSW_EF_CONSTRUCT := 200
+HNSW_EF_SEARCH    := 128
+
+# ── phony ─────────────────────────────────────────────────────────────────────
+.PHONY: benchmark-beir benchmark-beir-smoke benchmark-beir-bm25 \
+        bench-beir-setup bench-beir-prepare bench-beir-prepare-ollama \
+        bench-beir-ordvec bench-beir-baselines bench-beir-eval \
+        bench-beir-guardrail bench-beir-clean bench-beir-clean-cache
+
+# ── top-level targets ─────────────────────────────────────────────────────────
+
+## Full benchmark run (guardrail → prepare → ordvec → baselines → eval)
+benchmark-beir: bench-beir-guardrail bench-beir-prepare bench-beir-ordvec bench-beir-baselines bench-beir-eval
+
+## Smoke run: scifact only, quick sanity check
+benchmark-beir-smoke:
+	$(MAKE) benchmark-beir \
+		DATASETS=$(SMOKE_DATASETS) \
+		TOPK=100 \
+		ENCODE_BATCH=8
+
+## Optional BM25 lane (placeholder — requires beir[bm25] extras)
+benchmark-beir-bm25:
+	@echo "BM25 lane: install beir[bm25] extras then run:"
+	@echo "  $(PY) benchmarks/beir/beir_baselines.py --methods bm25 \\"
+	@echo "      --datasets $(DATASETS) --split $(SPLIT) \\"
+	@echo "      --cache-dir $(CACHE_DIR) --out-dir $(RESULTS_DIR) --top-k $(TOPK)"
+
+# ── setup ─────────────────────────────────────────────────────────────────────
+
+## Install Python benchmark dependencies
+bench-beir-setup:
+	$(PY) -m pip install -r benchmarks/beir/requirements.txt
+
+# ── guardrail ─────────────────────────────────────────────────────────────────
+
+## Fail loudly if any harness file imports the ordvec Python package directly.
+## The harness is an EXTERNAL consumer — it must use the Rust crate at bench time,
+## not the ordvec Python package. That coupling breaks the reproducibility claim.
+bench-beir-guardrail:
+	@if grep -R "import ordvec" benchmarks/beir 2>/dev/null; then \
+		echo ""; \
+		echo "ERROR: benchmarks/beir/ must not contain 'import ordvec'."; \
+		echo "The benchmark hot path is the Rust crate, not the ordvec Python package."; \
+		exit 1; \
+	fi
+	@echo "guardrail OK: no 'import ordvec' found in benchmarks/beir/"
+
+# ── prepare ───────────────────────────────────────────────────────────────────
+
+## Download datasets and encode with Harrier (sentence-transformers / CUDA lane)
+bench-beir-prepare:
+	$(PY) benchmarks/beir/beir_prepare.py \
+		--datasets $(DATASETS) \
+		--split $(SPLIT) \
+		--provider $(ENCODER_PROVIDER) \
+		--model "$(HARRIER_MODEL)" \
+		$(if $(HARRIER_REVISION),--revision $(HARRIER_REVISION),) \
+		--device "$(DEVICE)" \
+		--batch-size $(ENCODE_BATCH) \
+		--cache-dir "$(CACHE_DIR)" \
+		--seed $(SEED)
+
+## Encode with Harrier via Ollama (CPU/quantised lane — no GPU required)
+bench-beir-prepare-ollama:
+	$(PY) benchmarks/beir/beir_prepare.py \
+		--datasets $(DATASETS) \
+		--split $(SPLIT) \
+		--provider ollama \
+		--ollama-url "$(OLLAMA_URL)" \
+		--model "$(HARRIER_GGUF_MODEL)" \
+		--batch-size $(ENCODE_BATCH) \
+		--cache-dir "$(CACHE_DIR)" \
+		--seed $(SEED)
+
+# ── ordvec retrieval ──────────────────────────────────────────────────────────
+
+## Build the Rust beir_ordvec example binary and run all ordvec methods
+bench-beir-ordvec:
+	cargo build --release --example beir_ordvec
+	@for dataset in $(DATASETS); do \
+		$(CURDIR)/target/release/examples/beir_ordvec \
+			--cache-dir "$(CACHE_DIR)" \
+			--dataset "$$dataset" \
+			--split $(SPLIT) \
+			--top-k $(TOPK) \
+			--batch $(BATCH) \
+			--candidates $(CANDIDATES) \
+			--methods $(ORDVEC_METHODS) \
+			--out-dir "$(RESULTS_DIR)"; \
+	done
+
+# ── native dense baselines ────────────────────────────────────────────────────
+
+## Run FAISS FlatIP + HNSW dense baselines (comparison references, NOT ground truth)
+bench-beir-baselines:
+	$(PY) benchmarks/beir/beir_baselines.py \
+		--datasets $(DATASETS) \
+		--split $(SPLIT) \
+		--cache-dir "$(CACHE_DIR)" \
+		--out-dir "$(RESULTS_DIR)" \
+		--top-k $(TOPK) \
+		--methods $(BASELINE_METHODS) \
+		--hnsw-m $(HNSW_M) \
+		--hnsw-ef-construction $(HNSW_EF_CONSTRUCT) \
+		--hnsw-ef-search $(HNSW_EF_SEARCH) \
+		--seed $(SEED)
+
+# ── evaluation ────────────────────────────────────────────────────────────────
+
+## Evaluate nDCG@10 etc. vs BEIR qrels + paired bootstrap deltas vs FAISS
+bench-beir-eval:
+	$(PY) benchmarks/beir/beir_eval.py \
+		--datasets $(DATASETS) \
+		--split $(SPLIT) \
+		--cache-dir "$(CACHE_DIR)" \
+		--runs-dir "$(RESULTS_DIR)" \
+		--k-values $(K_VALUES) \
+		--baseline faiss-flat \
+		--bootstrap-iters 1000 \
+		--seed $(SEED) \
+		--out-dir "$(RESULTS_DIR)"
+
+# ── cleanup ───────────────────────────────────────────────────────────────────
+
+## Remove generated result files (keeps cache)
+bench-beir-clean:
+	find $(RESULTS_DIR) -name "*.topk.jsonl" -delete
+	find $(RESULTS_DIR) -name "*.summary.json" -delete
+
+## Remove the embedding cache (re-encoding will be required)
+bench-beir-clean-cache:
+	rm -rf $(CACHE_DIR)
diff --git a/benchmarks/beir/README.md b/benchmarks/beir/README.md
new file mode 100644
index 00000000..86aa6570
--- /dev/null
+++ b/benchmarks/beir/README.md
@@ -0,0 +1,158 @@
+# ordvec BEIR benchmark harness
+
+Reproducible nDCG@10 evaluation of ordvec's rank/sign retrieval methods across
+standard BEIR datasets, using Microsoft Harrier (harrier-oss-v1-0.6b, 1024-dim)
+as the shared encoder.
+
+## Claims discipline
+
+The following two paragraphs reproduce the project's required claims policy
+verbatim and govern every number produced by this harness:
+
+> **Benchmark numbers in this repository reflect synthetic or user-runnable
+> real-corpus experiments only.  No numbers are fabricated or cherry-picked.
+> Every result file produced by `make benchmark-beir` is fully reproducible
+> from the commands documented here, using publicly available BEIR datasets and
+> the pinned encoder revision recorded in `embeddings.manifest.json`.**
+
+> **FAISS FlatIP is a full-float dense retrieval baseline used for comparison
+> purposes — it is NOT ground truth.  nDCG@10 is computed against the official
+> BEIR qrels (human-annotated relevance judgements), not against FAISS results.
+> ANN-recall-vs-FAISS (fraction of FAISS top-k recovered by an ANN method) is
+> an optional diagnostic metric only; it does not substitute for qrel-based
+> evaluation.**
+
+## Dataset suite
+
+| Dataset    | Domain          | #Queries | #Corpus |
+|------------|-----------------|----------|---------|
+| scifact    | Scientific claim verification | 300  | 5 183  |
+| nfcorpus   | Biomedical IR   | 323      | 3 633  |
+| fiqa       | Financial QA    | 648      | 57 638 |
+| trec-covid | COVID-19 literature | 50   | 171 332 |
+
+All datasets are downloaded automatically via the BEIR Python library on first
+`make bench-beir-prepare` run.
+
+## Encoder
+
+**Harrier (harrier-oss-v1-0.6b)** — Microsoft's 600M-parameter bi-encoder
+producing 1024-dimensional L2-normalised float32 embeddings.
+
+- Documents receive no instruction prefix.
+- Queries receive:
+  `"Instruct: Given a web search query, retrieve relevant passages that answer the query\nQuery: "`
+- Revision is pinned in `embeddings.manifest.json` per cache directory.
+
+## Quick start
+
+### 1. Install Python dependencies
+
+```bash
+make bench-beir-setup
+```
+
+Installs from `benchmarks/beir/requirements.txt`.
+
+### 2. Smoke run (scifact only, ~5 min on GPU)
+
+```bash
+make benchmark-beir-smoke
+```
+
+Uses the `st` (sentence-transformers) provider with CUDA.  Encodes, runs all
+ordvec methods, runs the FAISS baseline, then evaluates nDCG@{10,100}.
+
+### 3. Full suite
+
+**Sentence-transformers / CUDA lane (default):**
+
+```bash
+make benchmark-beir
+```
+
+Override encoder or device:
+
+```bash
+make benchmark-beir \
+    ENCODER_PROVIDER=st \
+    HARRIER_MODEL=microsoft/harrier-oss-v1-0.6b \
+    DEVICE=cpu \
+    ENCODE_BATCH=4
+```
+
+**Ollama lane (CPU, quantised, no GPU required):**
+
+```bash
+ollama pull hf.co/mradermacher/harrier-oss-v1-0.6b-GGUF:Q8_0
+make bench-beir-prepare-ollama
+make bench-beir-ordvec
+make bench-beir-baselines
+make bench-beir-eval
+```
+
+## Cache layout
+
+One encoder run produces a directory per dataset/split:
+
+```
+.cache/ordvec-beir/<dataset>/<split>/encoder=<slug>/
+    corpus.f32.npy          # float32, shape (n_docs, 1024), L2-normalised, C-order
+    queries.f32.npy         # float32, shape (n_queries, 1024), L2-normalised, C-order
+    corpus_ids.json         # list[str], sorted(corpus.keys())
+    query_ids.json          # list[str], sorted(qrels.keys())
+    qrels.json              # {qid: {doc_id: int_relevance}}
+    texts.manifest.json     # reproducibility provenance for raw text
+    embeddings.manifest.json# encoder provider/model/revision/dim/norm
+    sha256s.json            # sha256 of each npy file
+```
+
+Encoder slug format: `<provider>__<model-path-components>__<revision-or-norev>`
+with `/`, `:`, and other non-filesystem-safe characters replaced by `__`.
+
+## Results layout
+
+```
+results/beir/<dataset>/
+    <method>.topk.jsonl     # one JSON line per query
+    <method>.summary.json   # aggregate latency + nDCG metrics
+```
+
+Top-k JSONL row schema:
+
+```json
+{"dataset":"scifact","split":"test","method":"ordvec-rq2",
+ "qid_idx":0,"qid":"0","k":100,
+ "doc_idxs":[42,7,...],"doc_ids":["abc","def",...],"scores":[0.91,0.88,...]}
+```
+
+Two-stage method names include parameters, e.g. `ordvec-bitmap-rq2-m500-b8`.
+
+## Available methods
+
+| Method          | Description |
+|-----------------|-------------|
+| `rq2`           | RankQuant (2 bits/dim), asymmetric float-query LUT scoring |
+| `rq4`           | RankQuant (4 bits/dim), asymmetric float-query LUT scoring |
+| `bitmap-rq2`    | Two-stage: Bitmap candidate gen + RankQuant-2 rerank |
+| `sign-rq2`      | Two-stage: SignBitmap candidate gen + RankQuant-2 rerank |
+| `faiss-flat`    | FAISS FlatIP full-float dense baseline (comparison, not ground truth) |
+
+## `import ordvec` rule
+
+The Python harness files in `benchmarks/beir/` **must not** contain
+`import ordvec`.  This harness is an external consumer; it uses the installed
+`ordvec` wheel.  The `bench-beir-guardrail` Make target (run automatically as
+part of `benchmark-beir`) enforces this and fails with a clear error message if
+any harness file violates it.
+
+This rule preserves the reproducibility guarantee: anyone can clone this repo,
+install the published wheel (`pip install ordvec`), and reproduce results
+without needing the ordvec source tree.
+
+## Clean up
+
+```bash
+make bench-beir-clean         # remove result files, keep embedding cache
+make bench-beir-clean-cache   # remove embedding cache (re-encoding required)
+```
diff --git a/benchmarks/beir/beir_baselines.py b/benchmarks/beir/beir_baselines.py
new file mode 100644
index 00000000..28f08a8d
--- /dev/null
+++ b/benchmarks/beir/beir_baselines.py
@@ -0,0 +1,459 @@
+"""
+beir_baselines.py — native Python/C++ baselines for the ordvec-beir harness.
+
+Methods
+-------
+faiss-flat
+    Full-float inner-product exact search via faiss.IndexFlatIP on L2-normalised
+    corpus vectors.  Inner product on unit vectors == cosine similarity.
+
+hnswlib-m<M>-ef<ef_search>
+    Approximate nearest-neighbour search via hnswlib's HNSW graph in cosine space.
+
+Both methods consume the cached ``.npy`` arrays produced by ``beir_prepare.py``
+and write results in the shared top-k JSONL + summary JSON formats defined by
+``common.py``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import time
+from typing import Any
+
+import numpy as np
+
+# Allow `from common import ...` when run as a script from the repo root
+# (the Makefile invokes `python3 benchmarks/beir/<script>.py`).
+import os as _os
+import sys as _sys
+
+_sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__)))
+
+from common import (
+    find_encoder_dir,
+    load_ids,
+    load_npy_f32,
+    slug_for_method,
+    summary_json_path,
+    topk_jsonl_path,
+    write_topk_jsonl,
+)
+
+# ---------------------------------------------------------------------------
+# Latency helpers
+# ---------------------------------------------------------------------------
+
+
+def _percentile(values: list[float], p: float) -> float:
+    """Return the *p*-th percentile of *values* (0–100)."""
+    if not values:
+        return float("nan")
+    arr = sorted(values)
+    idx = (p / 100.0) * (len(arr) - 1)
+    lo = int(idx)
+    hi = min(lo + 1, len(arr) - 1)
+    frac = idx - lo
+    return arr[lo] * (1.0 - frac) + arr[hi] * frac
+
+
+# ---------------------------------------------------------------------------
+# faiss-flat baseline
+# ---------------------------------------------------------------------------
+
+
+def run_faiss_flat(
+    corpus: np.ndarray,
+    queries: np.ndarray,
+    corpus_ids: list[str],
+    query_ids: list[str],
+    dataset: str,
+    split: str,
+    top_k: int,
+    out_dir: pathlib.Path,
+) -> dict[str, Any]:
+    """Run faiss.IndexFlatIP search and return a summary dict."""
+    import faiss  # type: ignore[import]
+
+    method = "faiss-flat"
+    method_slug = slug_for_method(method, None, None)
+
+    n_docs, dim = corpus.shape
+    n_queries = queries.shape[0]
+
+    # ------------------------------------------------------------------
+    # Build index
+    # ------------------------------------------------------------------
+    t0 = time.perf_counter()
+    index = faiss.IndexFlatIP(dim)
+    index.add(corpus)
+    build_seconds = time.perf_counter() - t0
+
+    # ------------------------------------------------------------------
+    # Query — one-at-a-time to capture per-query latencies
+    # ------------------------------------------------------------------
+    rows: list[dict] = []
+    query_times: list[float] = []
+
+    for q_idx, qid in enumerate(query_ids):
+        q_vec = queries[q_idx : q_idx + 1]  # shape (1, dim)
+        qt0 = time.perf_counter()
+        distances, indices = index.search(q_vec, top_k)
+        query_times.append((time.perf_counter() - qt0) * 1_000.0)  # ms
+
+        doc_idxs: list[int] = indices[0].tolist()
+        doc_ids: list[str] = [corpus_ids[i] for i in doc_idxs]
+        scores: list[float] = distances[0].tolist()
+
+        rows.append(
+            {
+                "dataset": dataset,
+                "split": split,
+                "method": method,
+                "qid_idx": q_idx,
+                "qid": qid,
+                "k": top_k,
+                "doc_idxs": doc_idxs,
+                "doc_ids": doc_ids,
+                "scores": scores,
+            }
+        )
+
+    # ------------------------------------------------------------------
+    # Write JSONL
+    # ------------------------------------------------------------------
+    jsonl_path = topk_jsonl_path(out_dir, dataset, method_slug)
+    write_topk_jsonl(jsonl_path, rows)
+
+    total_query_seconds = sum(query_times) / 1_000.0
+    qps = n_queries / total_query_seconds if total_query_seconds > 0 else float("nan")
+
+    summary: dict[str, Any] = {
+        "method": method,
+        "method_slug": method_slug,
+        "dataset": dataset,
+        "split": split,
+        "n_docs": n_docs,
+        "n_queries": n_queries,
+        "top_k": top_k,
+        "bytes_per_vector": dim * 4,  # float32
+        "index_total_mib": (n_docs * dim * 4) / (1024 ** 2),
+        "build_seconds": build_seconds,
+        "query_latency_ms_p50": _percentile(query_times, 50),
+        "query_latency_ms_p95": _percentile(query_times, 95),
+        "query_latency_ms_p99": _percentile(query_times, 99),
+        "queries_per_second": qps,
+        "faiss_index_type": "IndexFlatIP",
+    }
+
+    sum_path = summary_json_path(out_dir, dataset, method_slug)
+    sum_path.write_text(json.dumps(summary, indent=2))
+
+    print(
+        f"[faiss-flat] {dataset}/{split}: n_docs={n_docs}, n_queries={n_queries}, "
+        f"build={build_seconds:.2f}s, p50={summary['query_latency_ms_p50']:.2f}ms, "
+        f"QPS={qps:.1f}"
+    )
+    return summary
+
+
+# ---------------------------------------------------------------------------
+# hnswlib baseline
+# ---------------------------------------------------------------------------
+
+
+def run_hnswlib(
+    corpus: np.ndarray,
+    queries: np.ndarray,
+    corpus_ids: list[str],
+    query_ids: list[str],
+    dataset: str,
+    split: str,
+    top_k: int,
+    out_dir: pathlib.Path,
+    hnsw_m: int,
+    hnsw_ef_construction: int,
+    hnsw_ef_search: int,
+    seed: int,
+) -> dict[str, Any]:
+    """Run hnswlib HNSW search and return a summary dict."""
+    import hnswlib  # type: ignore[import]
+
+    method = f"hnswlib-m{hnsw_m}-ef{hnsw_ef_search}"
+    method_slug = slug_for_method(method, None, None)
+
+    n_docs, dim = corpus.shape
+    n_queries = queries.shape[0]
+
+    # ------------------------------------------------------------------
+    # Build index
+    # ------------------------------------------------------------------
+    t0 = time.perf_counter()
+    index = hnswlib.Index(space="cosine", dim=dim)
+    index.init_index(
+        max_elements=n_docs,
+        M=hnsw_m,
+        ef_construction=hnsw_ef_construction,
+        random_seed=seed,
+    )
+    index.add_items(corpus, num_threads=-1)
+    index.set_ef(hnsw_ef_search)
+    build_seconds = time.perf_counter() - t0
+
+    # ------------------------------------------------------------------
+    # Query — one-at-a-time for latency measurements
+    # ------------------------------------------------------------------
+    rows: list[dict] = []
+    query_times: list[float] = []
+
+    for q_idx, qid in enumerate(query_ids):
+        q_vec = queries[q_idx : q_idx + 1]  # shape (1, dim)
+        qt0 = time.perf_counter()
+        labels, distances = index.knn_query(q_vec, k=min(top_k, n_docs))
+        query_times.append((time.perf_counter() - qt0) * 1_000.0)  # ms
+
+        # hnswlib returns cosine *distance* (1 - cosine_sim); convert to score
+        doc_idxs: list[int] = labels[0].tolist()
+        doc_ids: list[str] = [corpus_ids[i] for i in doc_idxs]
+        # Score = 1 - distance (cosine similarity)
+        scores: list[float] = [float(1.0 - d) for d in distances[0].tolist()]
+
+        rows.append(
+            {
+                "dataset": dataset,
+                "split": split,
+                "method": method,
+                "qid_idx": q_idx,
+                "qid": qid,
+                "k": top_k,
+                "doc_idxs": doc_idxs,
+                "doc_ids": doc_ids,
+                "scores": scores,
+            }
+        )
+
+    # ------------------------------------------------------------------
+    # Write JSONL
+    # ------------------------------------------------------------------
+    jsonl_path = topk_jsonl_path(out_dir, dataset, method_slug)
+    write_topk_jsonl(jsonl_path, rows)
+
+    total_query_seconds = sum(query_times) / 1_000.0
+    qps = n_queries / total_query_seconds if total_query_seconds > 0 else float("nan")
+
+    # hnswlib doesn't expose a clean bytes-per-vector figure;
+    # report None and let the caller decide.
+    summary: dict[str, Any] = {
+        "method": method,
+        "method_slug": method_slug,
+        "dataset": dataset,
+        "split": split,
+        "n_docs": n_docs,
+        "n_queries": n_queries,
+        "top_k": top_k,
+        "bytes_per_vector": None,  # HNSW graph overhead is graph-structure-dependent
+        "index_total_mib": None,
+        "build_seconds": build_seconds,
+        "query_latency_ms_p50": _percentile(query_times, 50),
+        "query_latency_ms_p95": _percentile(query_times, 95),
+        "query_latency_ms_p99": _percentile(query_times, 99),
+        "queries_per_second": qps,
+        "hnsw_m": hnsw_m,
+        "hnsw_ef_construction": hnsw_ef_construction,
+        "hnsw_ef_search": hnsw_ef_search,
+        "seed": seed,
+    }
+
+    sum_path = summary_json_path(out_dir, dataset, method_slug)
+    sum_path.write_text(json.dumps(summary, indent=2))
+
+    print(
+        f"[{method}] {dataset}/{split}: n_docs={n_docs}, n_queries={n_queries}, "
+        f"build={build_seconds:.2f}s, p50={summary['query_latency_ms_p50']:.2f}ms, "
+        f"QPS={qps:.1f}"
+    )
+    return summary
+
+
+# ---------------------------------------------------------------------------
+# Per-dataset runner
+# ---------------------------------------------------------------------------
+
+
+def run_dataset(
+    dataset: str,
+    split: str,
+    cache_dir: pathlib.Path,
+    out_dir: pathlib.Path,
+    top_k: int,
+    methods: set[str],
+    hnsw_m: int,
+    hnsw_ef_construction: int,
+    hnsw_ef_search: int,
+    seed: int,
+) -> list[dict[str, Any]]:
+    """Load cached embeddings for *dataset* and run all requested methods."""
+    enc_dir = find_encoder_dir(cache_dir, dataset, split)
+
+    corpus_arr = load_npy_f32(enc_dir / "corpus.f32.npy")
+    queries_arr = load_npy_f32(enc_dir / "queries.f32.npy")
+    corpus_ids, query_ids = load_ids(enc_dir)
+
+    # Sanity-check id-count vs embedding row-count
+    if len(corpus_ids) != corpus_arr.shape[0]:
+        raise ValueError(
+            f"corpus_ids has {len(corpus_ids)} entries but corpus.f32.npy has "
+            f"{corpus_arr.shape[0]} rows."
+        )
+    if len(query_ids) != queries_arr.shape[0]:
+        raise ValueError(
+            f"query_ids has {len(query_ids)} entries but queries.f32.npy has "
+            f"{queries_arr.shape[0]} rows."
+        )
+
+    summaries: list[dict[str, Any]] = []
+
+    if "faiss-flat" in methods:
+        s = run_faiss_flat(
+            corpus=corpus_arr,
+            queries=queries_arr,
+            corpus_ids=corpus_ids,
+            query_ids=query_ids,
+            dataset=dataset,
+            split=split,
+            top_k=top_k,
+            out_dir=out_dir,
+        )
+        summaries.append(s)
+
+    if "hnswlib" in methods:
+        s = run_hnswlib(
+            corpus=corpus_arr,
+            queries=queries_arr,
+            corpus_ids=corpus_ids,
+            query_ids=query_ids,
+            dataset=dataset,
+            split=split,
+            top_k=top_k,
+            out_dir=out_dir,
+            hnsw_m=hnsw_m,
+            hnsw_ef_construction=hnsw_ef_construction,
+            hnsw_ef_search=hnsw_ef_search,
+            seed=seed,
+        )
+        summaries.append(s)
+
+    return summaries
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+_KNOWN_METHODS = {"faiss-flat", "hnswlib"}
+
+
+def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        description="BEIR native baselines (faiss-flat, hnswlib).",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    p.add_argument(
+        "--datasets",
+        nargs="+",
+        required=True,
+        metavar="DATASET",
+        help="One or more BEIR dataset names (e.g. nfcorpus scifact).",
+    )
+    p.add_argument(
+        "--split",
+        default="test",
+        help="Corpus split to evaluate.",
+    )
+    p.add_argument(
+        "--cache-dir",
+        default="/home/ndspence/GitHub/ordvec-beir/.cache/ordvec-beir",
+        help="Root of the embedding cache produced by beir_prepare.py.",
+    )
+    p.add_argument(
+        "--out-dir",
+        default="/home/ndspence/GitHub/ordvec-beir/results/beir",
+        help="Root directory for top-k JSONL and summary JSON output.",
+    )
+    p.add_argument(
+        "--top-k",
+        type=int,
+        default=100,
+        help="Number of results to retrieve per query.",
+    )
+    p.add_argument(
+        "--methods",
+        default="faiss-flat,hnswlib",
+        help="Comma-separated list of methods to run (faiss-flat, hnswlib).",
+    )
+    # HNSW params
+    p.add_argument(
+        "--hnsw-m",
+        type=int,
+        default=16,
+        help="HNSW M parameter (number of bi-directional links per node).",
+    )
+    p.add_argument(
+        "--hnsw-ef-construction",
+        type=int,
+        default=200,
+        help="HNSW ef_construction parameter.",
+    )
+    p.add_argument(
+        "--hnsw-ef-search",
+        type=int,
+        default=200,
+        help="HNSW ef (search) parameter.",
+    )
+    p.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed for hnswlib index construction.",
+    )
+    return p.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = _parse_args(argv)
+
+    requested = {m.strip() for m in args.methods.split(",")}
+    unknown = requested - _KNOWN_METHODS
+    if unknown:
+        raise ValueError(
+            f"Unknown method(s): {sorted(unknown)}. "
+            f"Supported: {sorted(_KNOWN_METHODS)}"
+        )
+
+    cache_dir = pathlib.Path(args.cache_dir)
+    out_dir = pathlib.Path(args.out_dir)
+
+    all_summaries: list[dict[str, Any]] = []
+    for dataset in args.datasets:
+        print(f"\n=== {dataset} ===")
+        summaries = run_dataset(
+            dataset=dataset,
+            split=args.split,
+            cache_dir=cache_dir,
+            out_dir=out_dir,
+            top_k=args.top_k,
+            methods=requested,
+            hnsw_m=args.hnsw_m,
+            hnsw_ef_construction=args.hnsw_ef_construction,
+            hnsw_ef_search=args.hnsw_ef_search,
+            seed=args.seed,
+        )
+        all_summaries.extend(summaries)
+
+    print(f"\nDone. {len(all_summaries)} run(s) completed.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/benchmarks/beir/beir_eval.py b/benchmarks/beir/beir_eval.py
new file mode 100644
index 00000000..1d80df15
--- /dev/null
+++ b/benchmarks/beir/beir_eval.py
@@ -0,0 +1,770 @@
+"""
+beir_eval.py — Evaluate ordvec-beir top-k runs against BEIR qrels.
+
+Responsibilities (spec §9)
+--------------------------
+1. Discover every ``<runs-dir>/<dataset>/*.topk.jsonl`` file.
+2. Build the run dict ``{qid: {doc_id: score}}`` for each method.
+3. Evaluate against the cached BEIR qrels using ``pytrec_eval`` (the same
+   engine BEIR's ``EvaluateRetrieval`` wraps).  Headline metric is nDCG@10;
+   secondary metrics are MAP@10, Recall@100, MRR@10, Precision@10.
+4. Pull systems columns (bytes/vector, total MiB, build seconds,
+   p50/p95/p99 latency, queries/second) from each method's ``.summary.json``.
+5. Run a *paired* bootstrap of every method vs the ``--baseline`` (faiss-flat):
+   resample queries with replacement ``--bootstrap-iters`` times (seeded),
+   compute the per-query metric delta (method - baseline), and report the
+   mean delta + 95% CI + ``within_noise``.
+6. (Diagnostic, behind ``--include-ann-diagnostics``) ANN recall@100 vs the
+   baseline (overlap of top-100 doc sets).  Kept OUT of the headline summary.
+7. Emit ``summary.csv``, ``summary.json``, ``comparison-matrix.md``,
+   ``bootstrap.json`` and (via :mod:`beir_report`) ``summary.md``.
+
+This harness is an *external consumer* of ordvec — it MUST NOT ``import
+ordvec``.  It only reads cached artefacts and result files.
+
+CLI
+---
+Run ``python beir_eval.py --help`` for full usage.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import sys
+from typing import Any
+
+import numpy as np
+
+# Allow `from common import ...` when run as a script from the repo root
+# (the Makefile invokes `python3 benchmarks/beir/<script>.py`).
+import os as _os
+import sys as _sys
+
+_sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__)))
+
+from common import (
+    find_encoder_dir,
+    load_manifest,
+    load_qrels,
+    read_topk_jsonl,
+)
+
+# ---------------------------------------------------------------------------
+# Metric definitions
+# ---------------------------------------------------------------------------
+
+#: Headline metric reported as the lead column everywhere.
+HEADLINE_METRIC = "ndcg@10"
+
+#: Metric families pytrec_eval can compute per-query at a cut value ``k``.
+#: Maps our metric prefix → (pytrec measure family, pytrec key template).
+_PYTREC_FAMILIES: dict[str, tuple[str, str]] = {
+    "ndcg": ("ndcg_cut", "ndcg_cut_{k}"),
+    "map": ("map_cut", "map_cut_{k}"),
+    "recall": ("recall", "recall_{k}"),
+    "precision": ("P", "P_{k}"),
+}
+
+
+def _metric_label(prefix: str, k: int) -> str:
+    """Public metric label, e.g. ``ndcg@10`` / ``recall@100``."""
+    return f"{prefix}@{k}"
+
+
+# ---------------------------------------------------------------------------
+# Run / qrels loading
+# ---------------------------------------------------------------------------
+
+def discover_runs(
+    runs_dir: pathlib.Path, dataset: str
+) -> dict[str, pathlib.Path]:
+    """Return ``{method_slug: topk_jsonl_path}`` for one dataset.
+
+    The method slug is the JSONL filename with ``.topk.jsonl`` stripped.
+    """
+    ds_dir = runs_dir / dataset
+    if not ds_dir.is_dir():
+        raise FileNotFoundError(
+            f"No run directory for dataset {dataset!r}: {ds_dir} does not exist."
+        )
+    out: dict[str, pathlib.Path] = {}
+    for path in sorted(ds_dir.glob("*.topk.jsonl")):
+        slug = path.name[: -len(".topk.jsonl")]
+        out[slug] = path
+    if not out:
+        raise FileNotFoundError(
+            f"No *.topk.jsonl run files found under {ds_dir}."
+        )
+    return out
+
+
+def build_run_dict(topk_path: pathlib.Path) -> dict[str, dict[str, float]]:
+    """Load a top-k JSONL file into ``{qid: {doc_id: score}}``.
+
+    Later duplicate ``(qid, doc_id)`` pairs overwrite earlier ones, matching
+    pytrec_eval's own last-wins semantics for run files.
+    """
+    run: dict[str, dict[str, float]] = {}
+    for row in read_topk_jsonl(topk_path):
+        qid = str(row["qid"])
+        doc_ids = row["doc_ids"]
+        scores = row["scores"]
+        if len(doc_ids) != len(scores):
+            raise ValueError(
+                f"{topk_path}: qid={qid} has {len(doc_ids)} doc_ids but "
+                f"{len(scores)} scores."
+            )
+        per_q = run.setdefault(qid, {})
+        for did, score in zip(doc_ids, scores):
+            per_q[str(did)] = float(score)
+    return run
+
+
+def load_summary(
+    runs_dir: pathlib.Path, dataset: str, method_slug: str
+) -> dict[str, Any] | None:
+    """Load ``<method_slug>.summary.json`` if present, else ``None``."""
+    path = runs_dir / dataset / f"{method_slug}.summary.json"
+    if not path.is_file():
+        return None
+    with path.open("r", encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+# ---------------------------------------------------------------------------
+# Per-query metrics (pytrec_eval + manual MRR)
+# ---------------------------------------------------------------------------
+
+def _require_pytrec_eval():
+    try:
+        import pytrec_eval  # noqa: F401
+    except ImportError as exc:  # pragma: no cover - exercised only without dep
+        raise SystemExit(
+            "pytrec_eval is required for BEIR evaluation but is not installed. "
+            "Install it with `pip install pytrec_eval` (it is the same engine "
+            "BEIR's EvaluateRetrieval wraps)."
+        ) from exc
+    return pytrec_eval
+
+
+def per_query_metrics(
+    qrels: dict[str, dict[str, int]],
+    run: dict[str, dict[str, float]],
+    k_values: list[int],
+) -> dict[str, dict[str, float]]:
+    """Compute every supported metric per query.
+
+    Returns ``{metric_label: {qid: value}}`` covering, for each ``k`` in
+    *k_values*: ``ndcg@k``, ``map@k``, ``recall@k``, ``precision@k`` (from
+    pytrec_eval) and ``mrr@k`` (computed manually, matching BEIR semantics).
+
+    Only qids present in *qrels* are scored — a method that omits a judged
+    query is treated as scoring 0 for that query (pytrec_eval reports nothing,
+    so we backfill zeros to keep the bootstrap paired).
+    """
+    pytrec_eval = _require_pytrec_eval()
+
+    # Build the pytrec_eval measure set: one family entry per requested k.
+    measures: set[str] = set()
+    for k in k_values:
+        for _prefix, (family, _tmpl) in _PYTREC_FAMILIES.items():
+            measures.add(f"{family}.{k}")
+
+    # pytrec_eval requires int relevances and string ids.
+    clean_qrels = {
+        qid: {str(did): int(rel) for did, rel in rels.items()}
+        for qid, rels in qrels.items()
+    }
+    clean_run = {
+        qid: {str(did): float(s) for did, s in docs.items()}
+        for qid, docs in run.items()
+    }
+
+    evaluator = pytrec_eval.RelevanceEvaluator(clean_qrels, measures)
+    raw = evaluator.evaluate(clean_run)  # {qid: {pytrec_key: value}}
+
+    judged_qids = list(clean_qrels.keys())
+    out: dict[str, dict[str, float]] = {}
+
+    for k in k_values:
+        for prefix, (_family, tmpl) in _PYTREC_FAMILIES.items():
+            label = _metric_label(prefix, k)
+            key = tmpl.format(k=k)
+            out[label] = {
+                qid: float(raw.get(qid, {}).get(key, 0.0))
+                for qid in judged_qids
+            }
+        # MRR@k computed manually (pytrec_eval has no direct cut MRR).
+        mrr_label = _metric_label("mrr", k)
+        out[mrr_label] = {
+            qid: _mrr_at_k(clean_qrels[qid], clean_run.get(qid, {}), k)
+            for qid in judged_qids
+        }
+    return out
+
+
+def _mrr_at_k(
+    rels: dict[str, int], scored: dict[str, float], k: int
+) -> float:
+    """Reciprocal rank of the first relevant doc within the top-*k* (BEIR)."""
+    relevant = {did for did, rel in rels.items() if rel > 0}
+    if not relevant:
+        return 0.0
+    # Rank by score descending; ties broken by doc_id for determinism.
+    ranked = sorted(scored.items(), key=lambda kv: (-kv[1], kv[0]))
+    for rank, (did, _score) in enumerate(ranked[:k], start=1):
+        if did in relevant:
+            return 1.0 / rank
+    return 0.0
+
+
+def aggregate(per_query: dict[str, dict[str, float]]) -> dict[str, float]:
+    """Mean each metric across its queries."""
+    return {
+        label: (float(np.mean(list(vals.values()))) if vals else 0.0)
+        for label, vals in per_query.items()
+    }
+
+
+# ---------------------------------------------------------------------------
+# ANN recall diagnostic (optional)
+# ---------------------------------------------------------------------------
+
+def ann_recall_at_k(
+    method_run: dict[str, dict[str, float]],
+    baseline_run: dict[str, dict[str, float]],
+    k: int,
+) -> float:
+    """Mean fraction of the baseline top-*k* doc set recovered by *method_run*.
+
+    Diagnostic only — overlap of doc-id sets, NOT a qrel-based metric.
+    """
+    def _topk_ids(docs: dict[str, float]) -> set[str]:
+        ranked = sorted(docs.items(), key=lambda kv: (-kv[1], kv[0]))
+        return {did for did, _ in ranked[:k]}
+
+    overlaps: list[float] = []
+    for qid, base_docs in baseline_run.items():
+        base_top = _topk_ids(base_docs)
+        if not base_top:
+            continue
+        meth_top = _topk_ids(method_run.get(qid, {}))
+        overlaps.append(len(base_top & meth_top) / len(base_top))
+    return float(np.mean(overlaps)) if overlaps else 0.0
+
+
+# ---------------------------------------------------------------------------
+# Paired bootstrap
+# ---------------------------------------------------------------------------
+
+def paired_bootstrap(
+    method_pq: dict[str, float],
+    baseline_pq: dict[str, float],
+    n_iters: int,
+    rng: np.random.Generator,
+) -> dict[str, float]:
+    """Paired bootstrap of (method - baseline) over a shared query set.
+
+    *method_pq* / *baseline_pq* are ``{qid: per_query_value}`` for ONE metric.
+    Resamples the common qid set with replacement *n_iters* times; the SAME
+    resampled indices index both methods (paired).  Returns the observed mean
+    delta plus the 2.5/97.5 percentiles of the bootstrap delta distribution
+    and ``within_noise`` (the 95% CI straddles 0).
+    """
+    common = sorted(set(method_pq) & set(baseline_pq))
+    n = len(common)
+    if n == 0:
+        return {
+            "delta": 0.0,
+            "ci95_low": 0.0,
+            "ci95_high": 0.0,
+            "within_noise": True,
+        }
+    m = np.array([method_pq[q] for q in common], dtype=np.float64)
+    b = np.array([baseline_pq[q] for q in common], dtype=np.float64)
+    diff = m - b
+    observed_delta = float(diff.mean())
+
+    boot = np.empty(n_iters, dtype=np.float64)
+    for i in range(n_iters):
+        idx = rng.integers(0, n, size=n)
+        boot[i] = diff[idx].mean()
+
+    ci_low = float(np.percentile(boot, 2.5))
+    ci_high = float(np.percentile(boot, 97.5))
+    within_noise = bool(ci_low <= 0.0 <= ci_high)
+    return {
+        "delta": observed_delta,
+        "ci95_low": ci_low,
+        "ci95_high": ci_high,
+        "within_noise": within_noise,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Encoder provenance
+# ---------------------------------------------------------------------------
+
+def load_encoder_meta(
+    cache_dir: pathlib.Path, dataset: str, split: str
+) -> dict[str, Any]:
+    """Read the encoder manifest for a dataset; tolerate a missing cache."""
+    try:
+        enc_dir = find_encoder_dir(cache_dir, dataset, split)
+        manifest = load_manifest(enc_dir)
+    except (FileNotFoundError, ValueError):
+        return {
+            "encoder_provider": "unknown",
+            "encoder_model": "unknown",
+            "encoder_revision": None,
+            "encoder_slug": "unknown",
+        }
+    return {
+        "encoder_provider": manifest.get("encoder_provider", "unknown"),
+        "encoder_model": manifest.get("encoder_model", "unknown"),
+        "encoder_revision": manifest.get("encoder_revision"),
+        "encoder_slug": manifest.get("encoder_slug", "unknown"),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Systems columns
+# ---------------------------------------------------------------------------
+
+_SYSTEMS_KEYS = (
+    "bytes_per_vector",
+    "index_total_mib",
+    "build_seconds",
+    "query_latency_ms_p50",
+    "query_latency_ms_p95",
+    "query_latency_ms_p99",
+    "queries_per_second",
+)
+
+
+def systems_columns(summary: dict[str, Any] | None) -> dict[str, Any]:
+    """Extract the systems columns from a method summary (None → all None)."""
+    if summary is None:
+        return {key: None for key in _SYSTEMS_KEYS}
+    return {key: summary.get(key) for key in _SYSTEMS_KEYS}
+
+
+# ---------------------------------------------------------------------------
+# Core evaluation driver
+# ---------------------------------------------------------------------------
+
+def evaluate_dataset(
+    dataset: str,
+    split: str,
+    cache_dir: pathlib.Path,
+    runs_dir: pathlib.Path,
+    k_values: list[int],
+    baseline: str,
+    bootstrap_iters: int,
+    seed: int,
+    include_ann: bool,
+) -> dict[str, Any]:
+    """Evaluate every method for one dataset.
+
+    Returns a dict with ``rows`` (one per method, headline + systems +
+    metrics), ``bootstrap`` (list of bootstrap entries) and ``encoder`` meta.
+    """
+    qrels = load_qrels(find_encoder_dir(cache_dir, dataset, split))
+    encoder = load_encoder_meta(cache_dir, dataset, split)
+    runs = discover_runs(runs_dir, dataset)
+
+    # Per-method per-query metrics + summaries.
+    pq_by_method: dict[str, dict[str, dict[str, float]]] = {}
+    run_by_method: dict[str, dict[str, dict[str, float]]] = {}
+    rows: list[dict[str, Any]] = []
+
+    metric_labels: list[str] = []
+    for k in k_values:
+        for prefix in ("ndcg", "map", "recall", "precision", "mrr"):
+            metric_labels.append(_metric_label(prefix, k))
+
+    for method_slug, topk_path in runs.items():
+        run = build_run_dict(topk_path)
+        run_by_method[method_slug] = run
+        pq = per_query_metrics(qrels, run, k_values)
+        pq_by_method[method_slug] = pq
+        means = aggregate(pq)
+        summary = load_summary(runs_dir, dataset, method_slug)
+        row: dict[str, Any] = {
+            "dataset": dataset,
+            "split": split,
+            "method": method_slug,
+            "encoder_provider": encoder["encoder_provider"],
+            "encoder_model": encoder["encoder_model"],
+            "encoder_slug": encoder["encoder_slug"],
+            "n_queries_judged": len(qrels),
+            "headline": means.get(HEADLINE_METRIC, 0.0),
+        }
+        row.update({label: means[label] for label in metric_labels})
+        row.update(systems_columns(summary))
+        rows.append(row)
+
+    # ANN recall diagnostic (optional, never in headline rows by default).
+    if include_ann and baseline in run_by_method:
+        base_run = run_by_method[baseline]
+        for row in rows:
+            method = row["method"]
+            row["ann_recall@100"] = ann_recall_at_k(
+                run_by_method[method], base_run, 100
+            )
+
+    # Paired bootstrap vs baseline.
+    bootstrap_entries: list[dict[str, Any]] = []
+    if baseline in pq_by_method:
+        base_pq = pq_by_method[baseline]
+        for method_slug, pq in pq_by_method.items():
+            if method_slug == baseline:
+                continue
+            for label in metric_labels:
+                rng = np.random.default_rng(
+                    _bootstrap_seed(seed, dataset, method_slug, label)
+                )
+                stats = paired_bootstrap(
+                    pq[label], base_pq[label], bootstrap_iters, rng
+                )
+                bootstrap_entries.append(
+                    {
+                        "dataset": dataset,
+                        "method": method_slug,
+                        "baseline": baseline,
+                        "metric": label,
+                        "delta": stats["delta"],
+                        "ci95_low": stats["ci95_low"],
+                        "ci95_high": stats["ci95_high"],
+                        "within_noise": stats["within_noise"],
+                    }
+                )
+    else:
+        print(
+            f"[eval] WARNING: baseline {baseline!r} not found for dataset "
+            f"{dataset!r}; bootstrap deltas skipped.",
+            file=sys.stderr,
+        )
+
+    return {
+        "dataset": dataset,
+        "split": split,
+        "encoder": encoder,
+        "rows": rows,
+        "bootstrap": bootstrap_entries,
+    }
+
+
+def _bootstrap_seed(
+    seed: int, dataset: str, method: str, metric: str
+) -> int:
+    """Derive a stable per-(dataset,method,metric) seed from the base seed."""
+    import hashlib
+
+    h = hashlib.sha256(f"{seed}|{dataset}|{method}|{metric}".encode())
+    # 63-bit positive int for numpy's SeedSequence.
+    return int.from_bytes(h.digest()[:8], "big") & ((1 << 63) - 1)
+
+
+# ---------------------------------------------------------------------------
+# Output: CSV
+# ---------------------------------------------------------------------------
+
+def _csv_columns(k_values: list[int], include_ann: bool) -> list[str]:
+    cols = [
+        "dataset",
+        "split",
+        "method",
+        "encoder_provider",
+        "encoder_model",
+        "encoder_slug",
+        "n_queries_judged",
+        "headline",
+    ]
+    for k in k_values:
+        for prefix in ("ndcg", "map", "recall", "precision", "mrr"):
+            cols.append(_metric_label(prefix, k))
+    cols.extend(_SYSTEMS_KEYS)
+    if include_ann:
+        cols.append("ann_recall@100")
+    return cols
+
+
+def write_csv(
+    path: pathlib.Path,
+    all_rows: list[dict[str, Any]],
+    k_values: list[int],
+    include_ann: bool,
+) -> None:
+    import csv
+
+    cols = _csv_columns(k_values, include_ann)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8", newline="") as fh:
+        writer = csv.DictWriter(fh, fieldnames=cols, extrasaction="ignore")
+        writer.writeheader()
+        for row in all_rows:
+            writer.writerow({c: row.get(c, "") for c in cols})
+
+
+# ---------------------------------------------------------------------------
+# Output: comparison matrix
+# ---------------------------------------------------------------------------
+
+#: Static family / implementation / search-type metadata for the matrix.
+#: Keyed by the method-name *stem* (params stripped).
+_METHOD_FAMILY: dict[str, dict[str, str]] = {
+    "faiss-flat": {
+        "family": "dense (float)",
+        "implementation": "FAISS FlatIP",
+        "search_type": "exact brute-force",
+        "headline_role": "baseline (comparison, not ground truth)",
+    },
+    "ordvec-rq2": {
+        "family": "ordvec rank-quant",
+        "implementation": "RankQuant b=2",
+        "search_type": "exact asymmetric LUT",
+        "headline_role": "candidate",
+    },
+    "ordvec-rq4": {
+        "family": "ordvec rank-quant",
+        "implementation": "RankQuant b=4",
+        "search_type": "exact asymmetric LUT",
+        "headline_role": "candidate",
+    },
+    "ordvec-bitmap-rq2": {
+        "family": "ordvec two-stage",
+        "implementation": "Bitmap → RankQuant b=2",
+        "search_type": "candidate-gen + rerank",
+        "headline_role": "candidate",
+    },
+    "ordvec-sign-rq2": {
+        "family": "ordvec two-stage",
+        "implementation": "SignBitmap → RankQuant b=2",
+        "search_type": "candidate-gen + rerank",
+        "headline_role": "candidate",
+    },
+}
+
+
+def method_stem(method_slug: str) -> str:
+    """Strip ``-m<N>`` / ``-b<N>`` parameter suffixes from a method slug."""
+    parts = method_slug.split("-")
+    kept = [
+        p
+        for p in parts
+        if not (p[:1] == "m" and p[1:].isdigit())
+        and not (p[:1] == "b" and p[1:].isdigit())
+    ]
+    return "-".join(kept)
+
+
+def family_meta(method_slug: str) -> dict[str, str]:
+    """Return the comparison-matrix metadata for a method (best-effort)."""
+    meta = _METHOD_FAMILY.get(method_stem(method_slug))
+    if meta is not None:
+        return dict(meta)
+    return {
+        "family": "unknown",
+        "implementation": method_slug,
+        "search_type": "unknown",
+        "headline_role": "candidate",
+    }
+
+
+# ---------------------------------------------------------------------------
+# Output: summary.json assembly
+# ---------------------------------------------------------------------------
+
+def assemble_summary_json(
+    datasets: list[str],
+    split: str,
+    baseline: str,
+    k_values: list[int],
+    bootstrap_iters: int,
+    seed: int,
+    include_ann: bool,
+    per_dataset: list[dict[str, Any]],
+) -> dict[str, Any]:
+    """Assemble the master summary.json structure consumed by beir_report."""
+    all_rows: list[dict[str, Any]] = []
+    all_bootstrap: list[dict[str, Any]] = []
+    encoders: dict[str, dict[str, Any]] = {}
+    for ds in per_dataset:
+        all_rows.extend(ds["rows"])
+        all_bootstrap.extend(ds["bootstrap"])
+        encoders[ds["dataset"]] = ds["encoder"]
+
+    return {
+        "config": {
+            "datasets": datasets,
+            "split": split,
+            "baseline": baseline,
+            "k_values": k_values,
+            "bootstrap_iters": bootstrap_iters,
+            "seed": seed,
+            "include_ann_diagnostics": include_ann,
+            "headline_metric": HEADLINE_METRIC,
+        },
+        "encoders": encoders,
+        "rows": all_rows,
+        "bootstrap": all_bootstrap,
+    }
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="beir_eval",
+        description=(
+            "Evaluate ordvec-beir top-k runs against BEIR qrels "
+            "(nDCG@10 headline; paired bootstrap vs the baseline)."
+        ),
+    )
+    p.add_argument(
+        "--datasets",
+        nargs="+",
+        required=True,
+        metavar="DATASET",
+        help="One or more BEIR dataset names to evaluate.",
+    )
+    p.add_argument("--split", default="test", help="Split (default: test).")
+    p.add_argument(
+        "--cache-dir",
+        default=None,
+        dest="cache_dir",
+        help="Embedding cache root (default: <repo-root>/.cache/ordvec-beir).",
+    )
+    p.add_argument(
+        "--runs-dir",
+        default=None,
+        dest="runs_dir",
+        help="Results root (default: <repo-root>/results/beir).",
+    )
+    p.add_argument(
+        "--k-values",
+        nargs="+",
+        type=int,
+        default=[10, 100],
+        dest="k_values",
+        help="BEIR k-values for nDCG/MAP/Recall/Precision/MRR (default: 10 100).",
+    )
+    p.add_argument(
+        "--baseline",
+        default="faiss-flat",
+        help="Method slug used as the paired-bootstrap baseline.",
+    )
+    p.add_argument(
+        "--bootstrap-iters",
+        type=int,
+        default=10000,
+        dest="bootstrap_iters",
+        help="Bootstrap resamples per (dataset,method,metric) (default: 10000).",
+    )
+    p.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Base RNG seed for the bootstrap (default: 42).",
+    )
+    p.add_argument(
+        "--out-dir",
+        default=None,
+        dest="out_dir",
+        help="Output directory for summary artefacts (default: --runs-dir).",
+    )
+    p.add_argument(
+        "--include-ann-diagnostics",
+        action="store_true",
+        dest="include_ann",
+        help="Also compute ANN recall@100 vs the baseline (diagnostic only).",
+    )
+    return p
+
+
+def _default_cache_dir() -> pathlib.Path:
+    return pathlib.Path(__file__).resolve().parents[2] / ".cache" / "ordvec-beir"
+
+
+def _default_runs_dir() -> pathlib.Path:
+    return pathlib.Path(__file__).resolve().parents[2] / "results" / "beir"
+
+
+def run_eval(args: argparse.Namespace) -> dict[str, Any]:
+    """Execute the full evaluation and write all artefacts."""
+    cache_dir = (
+        pathlib.Path(args.cache_dir) if args.cache_dir else _default_cache_dir()
+    )
+    runs_dir = (
+        pathlib.Path(args.runs_dir) if args.runs_dir else _default_runs_dir()
+    )
+    out_dir = pathlib.Path(args.out_dir) if args.out_dir else runs_dir
+    k_values = sorted(set(int(k) for k in args.k_values))
+
+    per_dataset: list[dict[str, Any]] = []
+    for dataset in args.datasets:
+        print(f"[eval] Evaluating {dataset}/{args.split} ...", flush=True)
+        per_dataset.append(
+            evaluate_dataset(
+                dataset=dataset,
+                split=args.split,
+                cache_dir=cache_dir,
+                runs_dir=runs_dir,
+                k_values=k_values,
+                baseline=args.baseline,
+                bootstrap_iters=args.bootstrap_iters,
+                seed=args.seed,
+                include_ann=args.include_ann,
+            )
+        )
+
+    summary = assemble_summary_json(
+        datasets=args.datasets,
+        split=args.split,
+        baseline=args.baseline,
+        k_values=k_values,
+        bootstrap_iters=args.bootstrap_iters,
+        seed=args.seed,
+        include_ann=args.include_ann,
+        per_dataset=per_dataset,
+    )
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+    summary_json_path = out_dir / "summary.json"
+    with summary_json_path.open("w", encoding="utf-8") as fh:
+        json.dump(summary, fh, indent=2, sort_keys=False)
+        fh.write("\n")
+
+    bootstrap_path = out_dir / "bootstrap.json"
+    with bootstrap_path.open("w", encoding="utf-8") as fh:
+        json.dump(summary["bootstrap"], fh, indent=2)
+        fh.write("\n")
+
+    write_csv(out_dir / "summary.csv", summary["rows"], k_values, args.include_ann)
+
+    # Render the markdown tables + summary.md via the report module.
+    import beir_report
+
+    beir_report.render_all(summary, out_dir)
+
+    print(
+        f"[eval] Wrote summary.json, summary.csv, bootstrap.json, "
+        f"comparison-matrix.md and summary.md to {out_dir}",
+        flush=True,
+    )
+    return summary
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    run_eval(args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/benchmarks/beir/beir_prepare.py b/benchmarks/beir/beir_prepare.py
new file mode 100644
index 00000000..70591412
--- /dev/null
+++ b/benchmarks/beir/beir_prepare.py
@@ -0,0 +1,565 @@
+"""
+beir_prepare.py — Download and embed BEIR datasets for the ordvec-beir harness.
+
+Responsibilities
+----------------
+1. Download (if absent) and load the BEIR dataset via GenericDataLoader.
+2. Build stable orderings:
+   - corpus_ids  = sorted(corpus.keys())
+   - query_ids   = sorted(qrels.keys())
+3. Construct document text:
+   - ``title + "\\n" + text`` when title is non-empty, else ``text``.
+4. Construct query text (raw query string, no prompt prepended to text — the
+   prompt is baked in via ``prompt_name`` for ST or manually for Ollama).
+5. Embed with the chosen provider (sentence-transformers or Ollama).
+6. L2-normalise all rows; validate via ``validate_embeddings``.
+7. Write the cache artefacts:
+   - corpus.f32.npy, queries.f32.npy
+   - corpus_ids.json, query_ids.json, qrels.json
+   - texts.manifest.json, embeddings.manifest.json, sha256s.json
+
+CLI
+---
+Run ``python beir_prepare.py --help`` for full usage.
+
+Providers
+---------
+* **st** (canonical): sentence-transformers ``SentenceTransformer``.
+  - Queries encoded with ``prompt_name="web_search_query"``.
+  - Documents encoded with NO prompt.
+  - Records sentence_transformers / transformers / torch versions + device.
+* **ollama**: HTTP POST to ``<ollama-url>/api/embed``.
+  - Queries prefixed with ``QUERY_PROMPT`` manually (documents unprefixed).
+  - Rows normalised in Python after decoding.
+  - Records ollama version, model digest, gguf_quant; ``canonical=false``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import pathlib
+import random
+import sys
+import time
+from typing import Any
+
+import numpy as np
+import requests
+
+# Allow `from common import ...` when run as a script from the repo root
+# (the Makefile invokes `python3 benchmarks/beir/<script>.py`).
+import os as _os
+import sys as _sys
+
+_sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__)))
+
+from common import (
+    QUERY_PROMPT,
+    dataset_cache_dir,
+    encoder_slug,
+    sha256_file,
+    validate_embeddings,
+)
+
+# ---------------------------------------------------------------------------
+# Seeding
+# ---------------------------------------------------------------------------
+
+def _set_seeds(seed: int) -> None:
+    random.seed(seed)
+    np.random.seed(seed)
+    try:
+        import torch
+        torch.manual_seed(seed)
+    except ImportError:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Text helpers
+# ---------------------------------------------------------------------------
+
+def _doc_text(entry: dict[str, str]) -> str:
+    """Combine title and body according to the spec."""
+    title = (entry.get("title") or "").strip()
+    text = (entry.get("text") or "").strip()
+    if title:
+        return f"{title}\n{text}"
+    return text
+
+
+# ---------------------------------------------------------------------------
+# Sentence-transformers encoder
+# ---------------------------------------------------------------------------
+
+def _embed_st(
+    corpus_texts: list[str],
+    query_texts: list[str],
+    model_name: str,
+    revision: str | None,
+    device: str,
+    batch_size: int,
+) -> tuple[np.ndarray, np.ndarray, dict[str, Any]]:
+    """Embed with sentence-transformers; return (corpus_emb, query_emb, meta)."""
+    import sentence_transformers
+    import torch
+    import transformers
+
+    model = sentence_transformers.SentenceTransformer(
+        model_name,
+        revision=revision,
+        device=device,
+        trust_remote_code=False,
+    )
+
+    corpus_emb = model.encode(
+        corpus_texts,
+        batch_size=batch_size,
+        normalize_embeddings=True,
+        show_progress_bar=True,
+        convert_to_numpy=True,
+    )
+    query_emb = model.encode(
+        query_texts,
+        batch_size=batch_size,
+        prompt_name="web_search_query",
+        normalize_embeddings=True,
+        show_progress_bar=True,
+        convert_to_numpy=True,
+    )
+
+    corpus_emb = np.ascontiguousarray(corpus_emb, dtype=np.float32)
+    query_emb = np.ascontiguousarray(query_emb, dtype=np.float32)
+
+    meta: dict[str, Any] = {
+        "sentence_transformers_version": sentence_transformers.__version__,
+        "transformers_version": transformers.__version__,
+        "torch_version": torch.__version__,
+        "device": device,
+    }
+    return corpus_emb, query_emb, meta
+
+
+# ---------------------------------------------------------------------------
+# Ollama encoder
+# ---------------------------------------------------------------------------
+
+def _ollama_version(ollama_url: str) -> str:
+    """Fetch Ollama server version string (best-effort)."""
+    try:
+        r = requests.get(f"{ollama_url.rstrip('/')}/api/version", timeout=10)
+        r.raise_for_status()
+        return r.json().get("version", "unknown")
+    except Exception:
+        return "unknown"
+
+
+def _ollama_model_info(ollama_url: str, model: str) -> dict[str, str]:
+    """Fetch model digest + gguf_quant (best-effort)."""
+    try:
+        r = requests.post(
+            f"{ollama_url.rstrip('/')}/api/show",
+            json={"name": model},
+            timeout=30,
+        )
+        r.raise_for_status()
+        data = r.json()
+        digest = data.get("modelfile", {}) or {}
+        # digest lives at top level in newer Ollama
+        model_digest = data.get("digest", "unknown")
+        details = data.get("details", {}) or {}
+        gguf_quant = details.get("quantization_level", "unknown")
+        return {"model_digest": model_digest, "gguf_quant": gguf_quant}
+    except Exception:
+        return {"model_digest": "unknown", "gguf_quant": "unknown"}
+
+
+def _ollama_embed_batch(
+    ollama_url: str,
+    model: str,
+    texts: list[str],
+    batch_size: int,
+) -> np.ndarray:
+    """Call Ollama /api/embed in batches; return stacked float32 array."""
+    url = f"{ollama_url.rstrip('/')}/api/embed"
+    all_vecs: list[np.ndarray] = []
+    for i in range(0, len(texts), batch_size):
+        batch = texts[i : i + batch_size]
+        resp = requests.post(
+            url,
+            json={"model": model, "input": batch},
+            timeout=600,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        embeddings = data.get("embeddings")
+        if embeddings is None:
+            raise ValueError(
+                f"Ollama /api/embed returned no 'embeddings' key for batch "
+                f"starting at index {i}. Response keys: {list(data.keys())}"
+            )
+        all_vecs.append(np.array(embeddings, dtype=np.float32))
+    return np.vstack(all_vecs)
+
+
+def _embed_ollama(
+    corpus_texts: list[str],
+    query_texts: list[str],
+    model: str,
+    ollama_url: str,
+    batch_size: int,
+) -> tuple[np.ndarray, np.ndarray, dict[str, Any]]:
+    """Embed with Ollama; return (corpus_emb, query_emb, meta)."""
+    # Prepend the query prompt manually for queries
+    prefixed_queries = [QUERY_PROMPT + q for q in query_texts]
+
+    corpus_emb = _ollama_embed_batch(ollama_url, model, corpus_texts, batch_size)
+    query_emb = _ollama_embed_batch(ollama_url, model, prefixed_queries, batch_size)
+
+    # Manual L2-normalise
+    corpus_norms = np.linalg.norm(corpus_emb, axis=1, keepdims=True)
+    query_norms = np.linalg.norm(query_emb, axis=1, keepdims=True)
+    corpus_norms = np.where(corpus_norms == 0, 1.0, corpus_norms)
+    query_norms = np.where(query_norms == 0, 1.0, query_norms)
+    corpus_emb = np.ascontiguousarray(corpus_emb / corpus_norms, dtype=np.float32)
+    query_emb = np.ascontiguousarray(query_emb / query_norms, dtype=np.float32)
+
+    version = _ollama_version(ollama_url)
+    model_info = _ollama_model_info(ollama_url, model)
+
+    meta: dict[str, Any] = {
+        "ollama_version": version,
+        "model_digest": model_info["model_digest"],
+        "gguf_quant": model_info["gguf_quant"],
+        "canonical": False,
+    }
+    return corpus_emb, query_emb, meta
+
+
+# ---------------------------------------------------------------------------
+# Cache-write helpers
+# ---------------------------------------------------------------------------
+
+def _write_json(path: pathlib.Path, obj: Any) -> None:
+    with path.open("w", encoding="utf-8") as fh:
+        json.dump(obj, fh, ensure_ascii=False, indent=2)
+        fh.write("\n")
+
+
+def _write_npy(path: pathlib.Path, arr: np.ndarray) -> None:
+    """Save a 2-D C-order float32 array."""
+    arr = np.ascontiguousarray(arr, dtype=np.float32)
+    np.save(str(path), arr)
+
+
+# ---------------------------------------------------------------------------
+# Main prepare routine
+# ---------------------------------------------------------------------------
+
+def prepare_dataset(
+    dataset: str,
+    split: str,
+    provider: str,
+    model: str,
+    revision: str | None,
+    device: str,
+    batch_size: int,
+    ollama_url: str,
+    cache_dir: pathlib.Path,
+) -> None:
+    """Run the full prepare pipeline for one dataset."""
+    from beir import util as beir_util
+    from beir.datasets.data_loader import GenericDataLoader
+
+    # ------------------------------------------------------------------ #
+    # 1. Download dataset if absent                                        #
+    # ------------------------------------------------------------------ #
+    data_path = cache_dir / "raw" / dataset
+    if not data_path.exists():
+        print(f"[prepare] Downloading BEIR dataset: {dataset}", flush=True)
+        url = f"https://public.ukp.informatik.tu-darmstadt.de/thakur/BEIR/datasets/{dataset}.zip"
+        data_path.parent.mkdir(parents=True, exist_ok=True)
+        out_dir = beir_util.download_and_unzip(str(url), str(data_path.parent))
+        data_path = pathlib.Path(out_dir)
+    else:
+        print(f"[prepare] Using cached raw data at {data_path}", flush=True)
+
+    # ------------------------------------------------------------------ #
+    # 2. Load                                                              #
+    # ------------------------------------------------------------------ #
+    corpus, queries, qrels = GenericDataLoader(data_folder=str(data_path)).load(
+        split=split
+    )
+
+    # ------------------------------------------------------------------ #
+    # 3. Stable ordering                                                   #
+    # ------------------------------------------------------------------ #
+    corpus_ids: list[str] = sorted(corpus.keys())
+    query_ids: list[str] = sorted(qrels.keys())
+
+    # ------------------------------------------------------------------ #
+    # 4. Build text lists                                                  #
+    # ------------------------------------------------------------------ #
+    corpus_texts = [_doc_text(corpus[cid]) for cid in corpus_ids]
+    query_texts = [queries[qid] for qid in query_ids]
+
+    n_docs = len(corpus_ids)
+    n_queries = len(query_ids)
+    print(
+        f"[prepare] {dataset}/{split}: {n_docs} docs, {n_queries} queries",
+        flush=True,
+    )
+
+    # ------------------------------------------------------------------ #
+    # 5. Embed                                                             #
+    # ------------------------------------------------------------------ #
+    slug = encoder_slug(provider, model, revision)
+    enc_dir = dataset_cache_dir(cache_dir, dataset, split, slug)
+
+    t0 = time.time()
+    if provider == "st":
+        corpus_emb, query_emb, enc_meta = _embed_st(
+            corpus_texts,
+            query_texts,
+            model_name=model,
+            revision=revision,
+            device=device,
+            batch_size=batch_size,
+        )
+    elif provider == "ollama":
+        corpus_emb, query_emb, enc_meta = _embed_ollama(
+            corpus_texts,
+            query_texts,
+            model=model,
+            ollama_url=ollama_url,
+            batch_size=batch_size,
+        )
+    else:
+        raise ValueError(f"Unknown provider: {provider!r}")
+    embed_seconds = time.time() - t0
+
+    # ------------------------------------------------------------------ #
+    # 6. Validate (fail-closed)                                            #
+    # ------------------------------------------------------------------ #
+    validate_embeddings(corpus_emb)
+    validate_embeddings(query_emb)
+
+    dim = corpus_emb.shape[1]
+
+    # ------------------------------------------------------------------ #
+    # 7. Write artefacts                                                   #
+    # ------------------------------------------------------------------ #
+    corpus_npy = enc_dir / "corpus.f32.npy"
+    query_npy = enc_dir / "queries.f32.npy"
+    _write_npy(corpus_npy, corpus_emb)
+    _write_npy(query_npy, query_emb)
+
+    _write_json(enc_dir / "corpus_ids.json", corpus_ids)
+    _write_json(enc_dir / "query_ids.json", query_ids)
+
+    # qrels keyed by str qid → {str doc_id: int relevance}
+    qrels_serialisable = {
+        qid: {did: int(rel) for did, rel in doc_rels.items()}
+        for qid, doc_rels in qrels.items()
+    }
+    _write_json(enc_dir / "qrels.json", qrels_serialisable)
+
+    # texts.manifest.json
+    texts_manifest = {
+        "dataset": dataset,
+        "split": split,
+        "n_corpus": n_docs,
+        "n_queries": n_queries,
+        "corpus_id_order": "sorted(corpus.keys())",
+        "query_id_order": "sorted(qrels.keys())",
+        "doc_text_format": "title + '\\n' + text if title else text",
+        "query_text_format": "raw query string (no prefix in text list)",
+    }
+    _write_json(enc_dir / "texts.manifest.json", texts_manifest)
+
+    # sha256s (compute after writing npys)
+    corpus_sha256 = sha256_file(corpus_npy)
+    query_sha256 = sha256_file(query_npy)
+
+    # embeddings.manifest.json
+    if provider == "st":
+        embeddings_manifest: dict[str, Any] = {
+            "encoder_provider": "sentence-transformers",
+            "encoder_model": model,
+            "encoder_revision": revision,
+            "encoder_slug": slug,
+            "embedding_dim": dim,
+            "dtype": "float32",
+            "normalize_embeddings": True,
+            "query_prompt_name": "web_search_query",
+            "query_prompt_text": QUERY_PROMPT,
+            "document_prompt_text": None,
+            "n_corpus": n_docs,
+            "n_queries": n_queries,
+            "corpus_sha256": corpus_sha256,
+            "query_sha256": query_sha256,
+            "embed_seconds": embed_seconds,
+            "device": enc_meta["device"],
+            "sentence_transformers_version": enc_meta["sentence_transformers_version"],
+            "transformers_version": enc_meta["transformers_version"],
+            "torch_version": enc_meta["torch_version"],
+        }
+    else:  # ollama
+        embeddings_manifest = {
+            "encoder_provider": "ollama",
+            "encoder_model": model,
+            "encoder_revision": revision,
+            "encoder_slug": slug,
+            "embedding_dim": dim,
+            "dtype": "float32",
+            "normalize_embeddings": True,
+            "query_prompt_name": None,
+            "query_prompt_text": QUERY_PROMPT,
+            "document_prompt_text": None,
+            "n_corpus": n_docs,
+            "n_queries": n_queries,
+            "corpus_sha256": corpus_sha256,
+            "query_sha256": query_sha256,
+            "embed_seconds": embed_seconds,
+            "ollama_version": enc_meta["ollama_version"],
+            "model_digest": enc_meta["model_digest"],
+            "gguf_quant": enc_meta["gguf_quant"],
+            "canonical": False,
+        }
+
+    _write_json(enc_dir / "embeddings.manifest.json", embeddings_manifest)
+
+    sha256s = {
+        "corpus.f32.npy": corpus_sha256,
+        "queries.f32.npy": query_sha256,
+    }
+    _write_json(enc_dir / "sha256s.json", sha256s)
+
+    print(f"[prepare] Done. Wrote artefacts to {enc_dir}", flush=True)
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="beir_prepare",
+        description="Download and embed BEIR datasets for the ordvec-beir harness.",
+    )
+    p.add_argument(
+        "--datasets",
+        nargs="+",
+        required=True,
+        metavar="DATASET",
+        help="One or more BEIR dataset names (e.g. msmarco nfcorpus).",
+    )
+    p.add_argument(
+        "--split",
+        default="test",
+        help="Dataset split to use (default: test).",
+    )
+    p.add_argument(
+        "--provider",
+        choices=["st", "ollama"],
+        default="st",
+        help="Encoder provider: 'st' (sentence-transformers) or 'ollama'.",
+    )
+    p.add_argument(
+        "--model",
+        default="microsoft/harrier-oss-v1-0.6b",
+        help="Model name / HuggingFace path (for 'st') or Ollama model tag.",
+    )
+    p.add_argument(
+        "--revision",
+        default=None,
+        help="Model revision / git commit SHA (for 'st'; ignored for 'ollama').",
+    )
+    p.add_argument(
+        "--device",
+        default="cpu",
+        help="Torch device for sentence-transformers (e.g. 'cuda', 'mps', 'cpu').",
+    )
+    p.add_argument(
+        "--batch-size",
+        type=int,
+        default=64,
+        dest="batch_size",
+        help="Encoding batch size (default: 64).",
+    )
+    p.add_argument(
+        "--ollama-url",
+        default="http://localhost:11434",
+        dest="ollama_url",
+        help="Base URL for the Ollama server (default: http://localhost:11434).",
+    )
+    p.add_argument(
+        "--cache-dir",
+        default=None,
+        dest="cache_dir",
+        help=(
+            "Root cache directory.  Defaults to "
+            "<repo-root>/.cache/ordvec-beir."
+        ),
+    )
+    p.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed (default: 42).",
+    )
+    return p
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    _set_seeds(args.seed)
+
+    if args.cache_dir is None:
+        # Resolve relative to this file's repo root: benchmarks/beir/../../
+        repo_root = pathlib.Path(__file__).resolve().parents[2]
+        cache_dir = repo_root / ".cache" / "ordvec-beir"
+    else:
+        cache_dir = pathlib.Path(args.cache_dir)
+
+    cache_dir.mkdir(parents=True, exist_ok=True)
+
+    failed: list[str] = []
+    for dataset in args.datasets:
+        print(f"\n{'='*60}", flush=True)
+        print(f"[prepare] Processing: {dataset}", flush=True)
+        try:
+            prepare_dataset(
+                dataset=dataset,
+                split=args.split,
+                provider=args.provider,
+                model=args.model,
+                revision=args.revision,
+                device=args.device,
+                batch_size=args.batch_size,
+                ollama_url=args.ollama_url,
+                cache_dir=cache_dir,
+            )
+        except Exception as exc:  # noqa: BLE001
+            print(
+                f"[prepare] ERROR for dataset {dataset!r}: {exc}",
+                file=sys.stderr,
+                flush=True,
+            )
+            failed.append(dataset)
+
+    if failed:
+        print(
+            f"\n[prepare] FAILED datasets: {failed}",
+            file=sys.stderr,
+            flush=True,
+        )
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/benchmarks/beir/beir_report.py b/benchmarks/beir/beir_report.py
new file mode 100644
index 00000000..1b4ad65c
--- /dev/null
+++ b/benchmarks/beir/beir_report.py
@@ -0,0 +1,469 @@
+"""
+beir_report.py — Render the public BEIR report tables from summary.json.
+
+Responsibilities (spec §10)
+---------------------------
+Render three markdown tables plus the required-claims preamble:
+
+1. **Comparison matrix** — family / method / implementation / search-type /
+   bytes-per-vector-at-1024d / headline-role.
+2. **Main per-dataset table** — dataset, encoder, method, nDCG@10, Δ vs FAISS,
+   95% CI, MAP@10, Recall@100, bytes/vec, build s, p50, p95.
+3. **Rollup table** — method, mean nDCG@10, mean Δ vs FAISS, datasets-within-CI,
+   mean Recall@100, bytes/vec.
+
+The report ALWAYS shows ``encoder_provider`` so HF and GGUF (Ollama) numbers are
+never silently mixed.  All tables use ``tabulate`` (GitHub-flavoured markdown).
+
+It writes ``comparison-matrix.md`` and ``summary.md`` (the latter embeds all
+three tables plus the two required-claims paragraphs from spec §12, verbatim).
+
+This module can be imported by :mod:`beir_eval` (``render_all``) or run on its
+own against an existing ``summary.json`` (``python beir_report.py
+results/beir/summary.json``).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+from typing import Any
+
+# Allow `import beir_eval` when run as a script from the repo root
+# (the Makefile invokes `python3 benchmarks/beir/<script>.py`).
+import os as _os
+import sys as _sys
+
+_sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__)))
+
+# ---------------------------------------------------------------------------
+# Required-claims paragraphs (spec §12) — reproduced VERBATIM.
+# Editing these breaks the claims-discipline guarantee; keep them in sync with
+# benchmarks/beir/README.md's "Claims discipline" section.
+# ---------------------------------------------------------------------------
+
+REQUIRED_CLAIM_REPRODUCIBILITY = (
+    "**Benchmark numbers in this repository reflect synthetic or user-runnable "
+    "real-corpus experiments only.  No numbers are fabricated or cherry-picked.  "
+    "Every result file produced by `make benchmark-beir` is fully reproducible "
+    "from the commands documented here, using publicly available BEIR datasets "
+    "and the pinned encoder revision recorded in `embeddings.manifest.json`.**"
+)
+
+REQUIRED_CLAIM_FAISS_NOT_GROUND_TRUTH = (
+    "**FAISS FlatIP is a full-float dense retrieval baseline used for comparison "
+    "purposes — it is NOT ground truth.  nDCG@10 is computed against the official "
+    "BEIR qrels (human-annotated relevance judgements), not against FAISS "
+    "results.  ANN-recall-vs-FAISS (fraction of FAISS top-k recovered by an ANN "
+    "method) is an optional diagnostic metric only; it does not substitute for "
+    "qrel-based evaluation.**"
+)
+
+
+# ---------------------------------------------------------------------------
+# tabulate shim
+# ---------------------------------------------------------------------------
+
+def _tabulate(rows: list[list[Any]], headers: list[str]) -> str:
+    """Render a GitHub-flavoured markdown table via ``tabulate``."""
+    try:
+        from tabulate import tabulate as _t
+    except ImportError as exc:  # pragma: no cover - exercised only without dep
+        raise SystemExit(
+            "tabulate is required for report rendering but is not installed. "
+            "Install it with `pip install tabulate`."
+        ) from exc
+    return _t(rows, headers=headers, tablefmt="github")
+
+
+# ---------------------------------------------------------------------------
+# Formatting helpers
+# ---------------------------------------------------------------------------
+
+def _fmt_num(value: Any, places: int = 4) -> str:
+    """Format a numeric value; ``None``/missing → ``"-"``."""
+    if value is None or value == "":
+        return "-"
+    try:
+        return f"{float(value):.{places}f}"
+    except (TypeError, ValueError):
+        return str(value)
+
+
+def _fmt_int(value: Any) -> str:
+    if value is None or value == "":
+        return "-"
+    try:
+        return str(int(value))
+    except (TypeError, ValueError):
+        return str(value)
+
+
+def _fmt_ci(low: Any, high: Any) -> str:
+    if low is None or high is None:
+        return "-"
+    return f"[{float(low):+.4f}, {float(high):+.4f}]"
+
+
+def _fmt_delta(value: Any) -> str:
+    if value is None:
+        return "-"
+    return f"{float(value):+.4f}"
+
+
+def _encoder_label(encoder: dict[str, Any]) -> str:
+    """Compact ``provider / model`` label (never silently drops provider)."""
+    provider = encoder.get("encoder_provider", "unknown")
+    model = encoder.get("encoder_model", "unknown")
+    return f"{provider} / {model}"
+
+
+# ---------------------------------------------------------------------------
+# Bootstrap index
+# ---------------------------------------------------------------------------
+
+def _bootstrap_index(
+    bootstrap: list[dict[str, Any]],
+) -> dict[tuple[str, str, str], dict[str, Any]]:
+    """Index bootstrap entries by ``(dataset, method, metric)``."""
+    out: dict[tuple[str, str, str], dict[str, Any]] = {}
+    for entry in bootstrap:
+        key = (entry["dataset"], entry["method"], entry["metric"])
+        out[key] = entry
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Comparison matrix
+# ---------------------------------------------------------------------------
+
+def render_comparison_matrix(summary: dict[str, Any]) -> str:
+    """Render the family/method/implementation/search-type matrix."""
+    import beir_eval  # local import: family metadata + stem helper live there
+
+    headers = [
+        "Family",
+        "Method",
+        "Implementation",
+        "Search type",
+        "Bytes/vec @1024d",
+        "Headline role",
+    ]
+    # One row per unique method slug, sorted with the baseline first.
+    seen: dict[str, dict[str, Any]] = {}
+    for row in summary["rows"]:
+        seen.setdefault(row["method"], row)
+
+    baseline = summary["config"]["baseline"]
+
+    def _sort_key(method: str) -> tuple[int, str]:
+        return (0 if method == baseline else 1, method)
+
+    body: list[list[Any]] = []
+    for method in sorted(seen, key=_sort_key):
+        row = seen[method]
+        meta = beir_eval.family_meta(method)
+        body.append(
+            [
+                meta["family"],
+                method,
+                meta["implementation"],
+                meta["search_type"],
+                _fmt_int(row.get("bytes_per_vector")),
+                meta["headline_role"],
+            ]
+        )
+    return _tabulate(body, headers)
+
+
+# ---------------------------------------------------------------------------
+# Main per-dataset table
+# ---------------------------------------------------------------------------
+
+def render_main_table(summary: dict[str, Any]) -> str:
+    """Render the per-(dataset, method) headline table."""
+    boot = _bootstrap_index(summary["bootstrap"])
+    baseline = summary["config"]["baseline"]
+    encoders = summary.get("encoders", {})
+
+    headers = [
+        "Dataset",
+        "Encoder (provider / model)",
+        "Method",
+        "nDCG@10",
+        "Δ vs FAISS",
+        "95% CI",
+        "MAP@10",
+        "Recall@100",
+        "Bytes/vec",
+        "Build s",
+        "p50 ms",
+        "p95 ms",
+    ]
+
+    # Group rows by dataset (preserve config order), method baseline-first.
+    by_dataset: dict[str, list[dict[str, Any]]] = {}
+    for row in summary["rows"]:
+        by_dataset.setdefault(row["dataset"], []).append(row)
+
+    body: list[list[Any]] = []
+    for dataset in summary["config"]["datasets"]:
+        rows = by_dataset.get(dataset, [])
+        rows = sorted(
+            rows, key=lambda r: (0 if r["method"] == baseline else 1, r["method"])
+        )
+        enc_label = _encoder_label(encoders.get(dataset, {}))
+        for row in rows:
+            method = row["method"]
+            if method == baseline:
+                delta_str = "(baseline)"
+                ci_str = "-"
+            else:
+                b = boot.get((dataset, method, "ndcg@10"))
+                if b is None:
+                    delta_str = "-"
+                    ci_str = "-"
+                else:
+                    delta_str = _fmt_delta(b["delta"])
+                    if b.get("within_noise"):
+                        delta_str += " *"
+                    ci_str = _fmt_ci(b["ci95_low"], b["ci95_high"])
+            body.append(
+                [
+                    dataset,
+                    enc_label,
+                    method,
+                    _fmt_num(row.get("ndcg@10")),
+                    delta_str,
+                    ci_str,
+                    _fmt_num(row.get("map@10")),
+                    _fmt_num(row.get("recall@100")),
+                    _fmt_int(row.get("bytes_per_vector")),
+                    _fmt_num(row.get("build_seconds"), 2),
+                    _fmt_num(row.get("query_latency_ms_p50"), 3),
+                    _fmt_num(row.get("query_latency_ms_p95"), 3),
+                ]
+            )
+    return _tabulate(body, headers)
+
+
+# ---------------------------------------------------------------------------
+# Rollup table
+# ---------------------------------------------------------------------------
+
+def render_rollup_table(summary: dict[str, Any]) -> str:
+    """Render the cross-dataset rollup per method."""
+    boot = _bootstrap_index(summary["bootstrap"])
+    baseline = summary["config"]["baseline"]
+    datasets = summary["config"]["datasets"]
+
+    headers = [
+        "Method",
+        "Mean nDCG@10",
+        "Mean Δ vs FAISS",
+        "Datasets within CI",
+        "Mean Recall@100",
+        "Bytes/vec",
+    ]
+
+    # Accumulate per-method values across datasets.
+    rows_by_method: dict[str, list[dict[str, Any]]] = {}
+    for row in summary["rows"]:
+        rows_by_method.setdefault(row["method"], []).append(row)
+
+    def _mean(values: list[float]) -> float | None:
+        clean = [v for v in values if v is not None]
+        return (sum(clean) / len(clean)) if clean else None
+
+    def _sort_key(method: str) -> tuple[int, str]:
+        return (0 if method == baseline else 1, method)
+
+    n_datasets = len(datasets)
+    body: list[list[Any]] = []
+    for method in sorted(rows_by_method, key=_sort_key):
+        rows = rows_by_method[method]
+        mean_ndcg = _mean([r.get("ndcg@10") for r in rows])
+        mean_recall = _mean([r.get("recall@100") for r in rows])
+        # Bytes/vec is fixed per method; take the first defined value.
+        bytes_per_vec = next(
+            (r.get("bytes_per_vector") for r in rows
+             if r.get("bytes_per_vector") is not None),
+            None,
+        )
+
+        if method == baseline:
+            mean_delta_str = "(baseline)"
+            within_str = "-"
+        else:
+            deltas = []
+            within = 0
+            counted = 0
+            for ds in datasets:
+                b = boot.get((ds, method, "ndcg@10"))
+                if b is None:
+                    continue
+                counted += 1
+                deltas.append(b["delta"])
+                if b.get("within_noise"):
+                    within += 1
+            mean_delta = _mean(deltas)
+            mean_delta_str = _fmt_delta(mean_delta) if mean_delta is not None else "-"
+            denom = counted if counted else n_datasets
+            within_str = f"{within}/{denom}"
+
+        body.append(
+            [
+                method,
+                _fmt_num(mean_ndcg),
+                mean_delta_str,
+                within_str,
+                _fmt_num(mean_recall),
+                _fmt_int(bytes_per_vec),
+            ]
+        )
+    return _tabulate(body, headers)
+
+
+# ---------------------------------------------------------------------------
+# summary.md assembly
+# ---------------------------------------------------------------------------
+
+def render_summary_md(summary: dict[str, Any]) -> str:
+    """Assemble the full summary.md document."""
+    config = summary["config"]
+    encoders = summary.get("encoders", {})
+
+    # Provider audit line — surfaces a mixed-provider run loudly.
+    providers = sorted(
+        {enc.get("encoder_provider", "unknown") for enc in encoders.values()}
+    )
+    provider_note = ", ".join(providers) if providers else "unknown"
+    mixed_warning = ""
+    if len(providers) > 1:
+        mixed_warning = (
+            "\n> **Warning:** this report mixes more than one encoder provider "
+            f"({provider_note}).  HF and GGUF numbers are NOT comparable; "
+            "inspect the per-dataset encoder column before drawing conclusions.\n"
+        )
+
+    parts: list[str] = []
+    parts.append("# ordvec BEIR evaluation summary\n")
+    parts.append(
+        f"- **Split:** `{config['split']}`\n"
+        f"- **Datasets:** {', '.join(config['datasets'])}\n"
+        f"- **Baseline:** `{config['baseline']}` "
+        "(comparison only — not ground truth)\n"
+        f"- **Headline metric:** {config['headline_metric']}\n"
+        f"- **k-values:** {', '.join(str(k) for k in config['k_values'])}\n"
+        f"- **Bootstrap iters:** {config['bootstrap_iters']} "
+        f"(seed {config['seed']})\n"
+        f"- **Encoder provider(s):** {provider_note}\n"
+    )
+    parts.append(mixed_warning)
+
+    parts.append("\n## Claims discipline\n")
+    parts.append("\n> " + REQUIRED_CLAIM_REPRODUCIBILITY + "\n")
+    parts.append("\n> " + REQUIRED_CLAIM_FAISS_NOT_GROUND_TRUTH + "\n")
+
+    parts.append("\n## Comparison matrix\n\n")
+    parts.append(render_comparison_matrix(summary))
+    parts.append("\n")
+
+    parts.append("\n## Per-dataset results\n\n")
+    parts.append(
+        "`Δ vs FAISS` is the paired-bootstrap mean nDCG@10 delta "
+        "(method - baseline); a trailing `*` marks deltas whose 95% CI "
+        "straddles 0 (within noise).\n\n"
+    )
+    parts.append(render_main_table(summary))
+    parts.append("\n")
+
+    parts.append("\n## Rollup (mean across datasets)\n\n")
+    parts.append(render_rollup_table(summary))
+    parts.append("\n")
+
+    if config.get("include_ann_diagnostics"):
+        parts.append("\n## ANN recall diagnostic (vs baseline)\n\n")
+        parts.append(render_ann_table(summary))
+        parts.append("\n")
+
+    return "".join(parts)
+
+
+def render_ann_table(summary: dict[str, Any]) -> str:
+    """Render the optional ANN-recall@100-vs-baseline diagnostic table."""
+    headers = ["Dataset", "Method", "ANN recall@100 (vs baseline)"]
+    baseline = summary["config"]["baseline"]
+    body: list[list[Any]] = []
+    for dataset in summary["config"]["datasets"]:
+        for row in summary["rows"]:
+            if row["dataset"] != dataset or row["method"] == baseline:
+                continue
+            if "ann_recall@100" not in row:
+                continue
+            body.append(
+                [dataset, row["method"], _fmt_num(row["ann_recall@100"])]
+            )
+    if not body:
+        return "_No ANN diagnostic data (run with `--include-ann-diagnostics`)._"
+    return _tabulate(body, headers)
+
+
+# ---------------------------------------------------------------------------
+# Render-all entrypoint (called by beir_eval)
+# ---------------------------------------------------------------------------
+
+def render_all(summary: dict[str, Any], out_dir: pathlib.Path) -> None:
+    """Write ``comparison-matrix.md`` and ``summary.md`` into *out_dir*."""
+    out_dir = pathlib.Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    matrix_md = (
+        "# ordvec BEIR comparison matrix\n\n"
+        + render_comparison_matrix(summary)
+        + "\n"
+    )
+    (out_dir / "comparison-matrix.md").write_text(matrix_md, encoding="utf-8")
+
+    summary_md = render_summary_md(summary)
+    (out_dir / "summary.md").write_text(summary_md, encoding="utf-8")
+
+
+# ---------------------------------------------------------------------------
+# CLI (standalone rendering from an existing summary.json)
+# ---------------------------------------------------------------------------
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="beir_report",
+        description="Render BEIR report tables from a summary.json.",
+    )
+    p.add_argument(
+        "summary_json",
+        help="Path to summary.json produced by beir_eval.py.",
+    )
+    p.add_argument(
+        "--out-dir",
+        default=None,
+        dest="out_dir",
+        help="Output directory (default: directory of summary.json).",
+    )
+    return p
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    summary_path = pathlib.Path(args.summary_json)
+    with summary_path.open("r", encoding="utf-8") as fh:
+        summary = json.load(fh)
+    out_dir = (
+        pathlib.Path(args.out_dir) if args.out_dir else summary_path.parent
+    )
+    render_all(summary, out_dir)
+    print(f"[report] Wrote comparison-matrix.md and summary.md to {out_dir}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/benchmarks/beir/common.py b/benchmarks/beir/common.py
new file mode 100644
index 00000000..0bce17d2
--- /dev/null
+++ b/benchmarks/beir/common.py
@@ -0,0 +1,289 @@
+"""
+common.py — shared contract module for the ordvec-beir harness.
+
+All public names here are imported by other lanes (beir_prepare.py,
+eval.py, etc.).  DO NOT rename or remove any public symbol.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import pathlib
+import re
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import numpy as np
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+QUERY_PROMPT: str = (
+    "Instruct: Given a web search query, retrieve relevant passages that answer"
+    " the query\nQuery: "
+)
+
+# ---------------------------------------------------------------------------
+# Encoder slug
+# ---------------------------------------------------------------------------
+
+_UNSAFE_RE = re.compile(r"[^A-Za-z0-9._-]")
+
+
+def encoder_slug(provider: str, model: str, revision: str | None) -> str:
+    """Return a deterministic, filesystem-safe slug for an encoder spec.
+
+    Format:  <provider>__<model-safe>__<revision-or-norev>
+    All ``/`` and ``:`` are replaced with ``__``; other unsafe chars are
+    replaced with ``_``.
+
+    Examples
+    --------
+    >>> encoder_slug("st", "microsoft/harrier-oss-v1-0.6b", "abc123")
+    'st__microsoft__harrier-oss-v1-0.6b__abc123'
+    """
+    def _safe(s: str) -> str:
+        s = s.replace("/", "__").replace(":", "__")
+        s = _UNSAFE_RE.sub("_", s)
+        return s
+
+    rev_part = _safe(revision) if revision else "norev"
+    return f"{_safe(provider)}__{_safe(model)}__{rev_part}"
+
+
+# ---------------------------------------------------------------------------
+# Cache / results path helpers
+# ---------------------------------------------------------------------------
+
+def dataset_cache_dir(
+    cache_dir: str | pathlib.Path,
+    dataset: str,
+    split: str,
+    slug: str,
+) -> pathlib.Path:
+    """Return (and create) the per-encoder cache directory.
+
+    Layout: <cache_dir>/<dataset>/<split>/encoder=<slug>/
+    """
+    p = pathlib.Path(cache_dir) / dataset / split / f"encoder={slug}"
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def find_encoder_dir(
+    cache_dir: str | pathlib.Path,
+    dataset: str,
+    split: str,
+) -> pathlib.Path:
+    """Resolve the single ``encoder=*`` sub-directory.
+
+    Raises ``FileNotFoundError`` if zero matches, ``ValueError`` if >1.
+    """
+    base = pathlib.Path(cache_dir) / dataset / split
+    matches = list(base.glob("encoder=*"))
+    if len(matches) == 0:
+        raise FileNotFoundError(
+            f"No encoder directory found under {base}. "
+            "Run beir_prepare.py first."
+        )
+    if len(matches) > 1:
+        raise ValueError(
+            f"Multiple encoder directories found under {base}: {matches}. "
+            "Specify --encoder-slug to disambiguate."
+        )
+    return matches[0]
+
+
+# ---------------------------------------------------------------------------
+# Manifest / metadata I/O
+# ---------------------------------------------------------------------------
+
+def load_manifest(enc_dir: str | pathlib.Path) -> dict:
+    """Read ``embeddings.manifest.json`` from *enc_dir* and return its dict."""
+    path = pathlib.Path(enc_dir) / "embeddings.manifest.json"
+    with path.open("r", encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+def load_ids(
+    enc_dir: str | pathlib.Path,
+) -> tuple[list[str], list[str]]:
+    """Return ``(corpus_ids, query_ids)`` loaded from the cache directory."""
+    enc_dir = pathlib.Path(enc_dir)
+    with (enc_dir / "corpus_ids.json").open("r", encoding="utf-8") as fh:
+        corpus_ids: list[str] = json.load(fh)
+    with (enc_dir / "query_ids.json").open("r", encoding="utf-8") as fh:
+        query_ids: list[str] = json.load(fh)
+    return corpus_ids, query_ids
+
+
+def load_qrels(
+    enc_dir: str | pathlib.Path,
+) -> dict[str, dict[str, int]]:
+    """Return ``qrels`` dict ``{qid: {doc_id: relevance_int}}``."""
+    path = pathlib.Path(enc_dir) / "qrels.json"
+    with path.open("r", encoding="utf-8") as fh:
+        return json.load(fh)
+
+
+# ---------------------------------------------------------------------------
+# Embedding array I/O
+# ---------------------------------------------------------------------------
+
+def load_npy_f32(path: str | pathlib.Path) -> "np.ndarray":
+    """Load a 2-D C-order float32 ``.npy`` array and validate its shape.
+
+    Raises
+    ------
+    ValueError
+        If the array is not 2-D, not float32, or not C-contiguous.
+    """
+    import numpy as np  # local import — numpy may not be installed at import time
+
+    arr = np.load(str(path))
+    if arr.ndim != 2:
+        raise ValueError(
+            f"Expected 2-D array; got shape {arr.shape} from {path}"
+        )
+    if arr.dtype != np.float32:
+        raise ValueError(
+            f"Expected float32 array; got dtype={arr.dtype} from {path}"
+        )
+    if not arr.flags["C_CONTIGUOUS"]:
+        arr = np.ascontiguousarray(arr, dtype=np.float32)
+    return arr
+
+
+# ---------------------------------------------------------------------------
+# Embedding validation (fail-closed)
+# ---------------------------------------------------------------------------
+
+def validate_embeddings(arr: "np.ndarray") -> None:
+    """Raise ``ValueError`` on any violation of the spec's fail-closed rules.
+
+    Rules
+    -----
+    * 2-D array
+    * dtype == float32
+    * shape[1] == 1024
+    * shape[1] % 16 == 0
+    * every row L2 norm in [0.999, 1.001]
+    """
+    import numpy as np
+
+    if arr.ndim != 2:
+        raise ValueError(f"Embeddings must be 2-D; got shape {arr.shape}")
+    if arr.dtype != np.float32:
+        raise ValueError(
+            f"Embeddings must be float32; got dtype={arr.dtype}"
+        )
+    dim = arr.shape[1]
+    if dim != 1024:
+        raise ValueError(
+            f"Embedding dimension must be 1024; got {dim}"
+        )
+    if dim % 16 != 0:
+        raise ValueError(
+            f"Embedding dimension must be divisible by 16; got {dim}"
+        )
+    norms = np.linalg.norm(arr, axis=1)
+    bad = np.where((norms < 0.999) | (norms > 1.001))[0]
+    if bad.size > 0:
+        raise ValueError(
+            f"{bad.size} rows have L2 norm outside [0.999, 1.001]. "
+            f"First offending row: index={bad[0]}, norm={norms[bad[0]]:.6f}"
+        )
+
+
+# ---------------------------------------------------------------------------
+# Hashing
+# ---------------------------------------------------------------------------
+
+def sha256_file(path: str | pathlib.Path) -> str:
+    """Return the hex-encoded SHA-256 digest of the file at *path*."""
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for chunk in iter(lambda: fh.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+# ---------------------------------------------------------------------------
+# Results path helpers
+# ---------------------------------------------------------------------------
+
+def slug_for_method(
+    method: str,
+    candidate_m: int | None,
+    batch: int | None,
+) -> str:
+    """Build a results slug from method name + optional params.
+
+    Examples
+    --------
+    >>> slug_for_method("ordvec-bitmap-rq2", 500, 8)
+    'ordvec-bitmap-rq2-m500-b8'
+    >>> slug_for_method("dense-exact", None, None)
+    'dense-exact'
+    """
+    parts = [method]
+    if candidate_m is not None:
+        parts.append(f"m{candidate_m}")
+    if batch is not None:
+        parts.append(f"b{batch}")
+    return "-".join(parts)
+
+
+def topk_jsonl_path(
+    runs_dir: str | pathlib.Path,
+    dataset: str,
+    method_slug: str,
+) -> pathlib.Path:
+    """Return the path for the top-k JSONL results file."""
+    p = pathlib.Path(runs_dir) / dataset
+    p.mkdir(parents=True, exist_ok=True)
+    return p / f"{method_slug}.topk.jsonl"
+
+
+def summary_json_path(
+    runs_dir: str | pathlib.Path,
+    dataset: str,
+    method_slug: str,
+) -> pathlib.Path:
+    """Return the path for the summary JSON file."""
+    p = pathlib.Path(runs_dir) / dataset
+    p.mkdir(parents=True, exist_ok=True)
+    return p / f"{method_slug}.summary.json"
+
+
+# ---------------------------------------------------------------------------
+# Top-k JSONL I/O
+# ---------------------------------------------------------------------------
+
+def write_topk_jsonl(path: str | pathlib.Path, rows: list[dict]) -> None:
+    """Write *rows* as newline-delimited JSON (one object per line).
+
+    Each row must conform to the spec schema::
+
+        {"dataset", "split", "method", "qid_idx", "qid",
+         "k", "doc_idxs": [int], "doc_ids": [str], "scores": [float]}
+    """
+    path = pathlib.Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as fh:
+        for row in rows:
+            fh.write(json.dumps(row, separators=(",", ":")) + "\n")
+
+
+def read_topk_jsonl(path: str | pathlib.Path) -> list[dict]:
+    """Read a top-k JSONL file and return a list of row dicts."""
+    path = pathlib.Path(path)
+    rows: list[dict] = []
+    with path.open("r", encoding="utf-8") as fh:
+        for line in fh:
+            line = line.strip()
+            if line:
+                rows.append(json.loads(line))
+    return rows
diff --git a/benchmarks/beir/requirements.txt b/benchmarks/beir/requirements.txt
new file mode 100644
index 00000000..381270f0
--- /dev/null
+++ b/benchmarks/beir/requirements.txt
@@ -0,0 +1,12 @@
+beir
+numpy
+scipy
+sentence-transformers
+torch
+transformers
+faiss-cpu
+hnswlib
+tqdm
+requests
+pandas
+tabulate
diff --git a/examples/beir_ordvec.rs b/examples/beir_ordvec.rs
new file mode 100644
index 00000000..9f27eaa6
--- /dev/null
+++ b/examples/beir_ordvec.rs
@@ -0,0 +1,1195 @@
+//! OrdVec BEIR evaluation driver.
+//!
+//! Loads pre-computed embeddings from the shared cache layout, runs
+//! OrdVec index methods over the BEIR query set, and writes per-query
+//! top-k JSONL + per-method summary JSON to the results directory.
+//!
+//! BEIR metrics (NDCG@10, MAP, …) are NOT computed here; they are
+//! evaluated offline in Python against the qrels files.
+//!
+//! Usage:
+//!   cargo run --release --example beir_ordvec -- \
+//!     --cache-dir .cache/ordvec-beir \
+//!     --dataset scifact \
+//!     --split test \
+//!     --methods rq2,rq4,bitmap-rq2,sign-rq2 \
+//!     --candidates 500 \
+//!     --top-k 100 \
+//!     --batch 8 \
+//!     --out-dir results/beir
+//!
+//! Cache layout (one encoder per prepare run):
+//!   <cache-dir>/<dataset>/<split>/encoder=<slug>/
+//!     corpus.f32.npy   queries.f32.npy
+//!     corpus_ids.json  query_ids.json  qrels.json
+//!     texts.manifest.json  embeddings.manifest.json  sha256s.json
+//!
+//! Results layout:
+//!   <out-dir>/<dataset>/<method-slug>.topk.jsonl
+//!   <out-dir>/<dataset>/<method-slug>.summary.json
+
+use ordvec::{Bitmap, CandidateBatch, RankQuant, SignBitmap, SubsetScratch};
+use std::io::{BufWriter, Write};
+use std::time::Instant;
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+
+struct Config {
+    cache_dir: String,
+    dataset: String,
+    split: String,
+    top_k: usize,
+    batch: usize,
+    candidates: usize,
+    methods: Vec<String>,
+    out_dir: String,
+}
+
+fn parse_args() -> Config {
+    let mut cache_dir = String::from(".cache/ordvec-beir");
+    let mut dataset = String::new();
+    let mut split = String::from("test");
+    let mut top_k = 100usize;
+    let mut batch = 8usize;
+    let mut candidates = 500usize;
+    let mut methods = vec![
+        "rq2".to_string(),
+        "rq4".to_string(),
+        "bitmap-rq2".to_string(),
+        "sign-rq2".to_string(),
+    ];
+    let mut out_dir = String::from("results/beir");
+
+    let mut args = std::env::args().skip(1);
+    while let Some(a) = args.next() {
+        match a.as_str() {
+            "--cache-dir" => cache_dir = args.next().expect("--cache-dir requires a value"),
+            "--dataset" => dataset = args.next().expect("--dataset requires a value"),
+            "--split" => split = args.next().expect("--split requires a value"),
+            "--top-k" => {
+                top_k = args
+                    .next()
+                    .expect("--top-k requires a value")
+                    .parse()
+                    .expect("--top-k must be an integer")
+            }
+            "--batch" => {
+                batch = args
+                    .next()
+                    .expect("--batch requires a value")
+                    .parse()
+                    .expect("--batch must be an integer")
+            }
+            "--candidates" => {
+                candidates = args
+                    .next()
+                    .expect("--candidates requires a value")
+                    .parse()
+                    .expect("--candidates must be an integer")
+            }
+            "--methods" => {
+                methods = args
+                    .next()
+                    .expect("--methods requires a value")
+                    .split(',')
+                    .map(|s| s.trim().to_string())
+                    .filter(|s| !s.is_empty())
+                    .collect()
+            }
+            "--out-dir" => out_dir = args.next().expect("--out-dir requires a value"),
+            other => panic!("unknown argument: {other}"),
+        }
+    }
+    assert!(!dataset.is_empty(), "--dataset is required");
+    assert!(batch >= 1, "--batch must be >= 1");
+    assert!(top_k >= 1, "--top-k must be >= 1");
+    assert!(candidates >= 1, "--candidates must be >= 1");
+
+    Config {
+        cache_dir,
+        dataset,
+        split,
+        top_k,
+        batch,
+        candidates,
+        methods,
+        out_dir,
+    }
+}
+
+// ---------------------------------------------------------------------------
+// NumPy v1 reader (2-D LE f32, C-order) — adapted from bench_rank.rs
+// ---------------------------------------------------------------------------
+
+fn load_npy_f32(path: &str) -> (Vec<f32>, usize, usize) {
+    let bytes = std::fs::read(path).unwrap_or_else(|e| panic!("read npy {path}: {e}"));
+    assert!(bytes.len() >= 10, "npy file too short: {path}");
+    assert_eq!(&bytes[..6], b"\x93NUMPY", "not a numpy file: {path}");
+    let major = bytes[6];
+    let minor = bytes[7];
+    assert!(
+        major == 1 || major == 2,
+        "unsupported npy version {major}.{minor}: {path}",
+    );
+    let (header_len, header_start) = if major == 1 {
+        let hl = u16::from_le_bytes([bytes[8], bytes[9]]) as usize;
+        (hl, 10)
+    } else {
+        let hl = u32::from_le_bytes([bytes[8], bytes[9], bytes[10], bytes[11]]) as usize;
+        (hl, 12)
+    };
+    let header = std::str::from_utf8(&bytes[header_start..header_start + header_len])
+        .expect("npy header not utf-8");
+    assert!(
+        header.contains("'descr': '<f4'"),
+        "expected <f4 dtype in {path}: {header}",
+    );
+    assert!(
+        header.contains("'fortran_order': False"),
+        "expected C order in {path}",
+    );
+    let shape_start = header.find("'shape':").expect("no shape in npy header");
+    let after = &header[shape_start..];
+    let open = after.find('(').unwrap();
+    let close = after.find(')').unwrap();
+    let dims: Vec<usize> = after[open + 1..close]
+        .split(',')
+        .filter_map(|s| s.trim().parse::<usize>().ok())
+        .collect();
+    assert_eq!(
+        dims.len(),
+        2,
+        "expected 2-D array in {path}, got {} dims",
+        dims.len()
+    );
+    let n = dims[0];
+    let dim = dims[1];
+    let data_start = header_start + header_len;
+    let n_floats = n * dim;
+    assert_eq!(
+        bytes.len() - data_start,
+        n_floats * 4,
+        "data length mismatch in {path}",
+    );
+    let mut out = vec![0.0f32; n_floats];
+    for (i, chunk) in bytes[data_start..].chunks_exact(4).enumerate() {
+        out[i] = f32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
+    }
+    (out, n, dim)
+}
+
+// ---------------------------------------------------------------------------
+// JSON helpers (no serde dep: manual string building)
+// ---------------------------------------------------------------------------
+
+fn load_json_string_array(path: &str) -> Vec<String> {
+    let text = std::fs::read_to_string(path).unwrap_or_else(|e| panic!("read {path}: {e}"));
+    // Minimal parser: split on `"`, take even-indexed non-empty tokens between quotes.
+    // Works for a JSON array of strings with no embedded quotes.
+    let mut out = Vec::new();
+    let mut in_str = false;
+    let mut cur = String::new();
+    let mut chars = text.chars().peekable();
+    while let Some(c) = chars.next() {
+        if c == '"' {
+            if in_str {
+                out.push(cur.clone());
+                cur.clear();
+                in_str = false;
+            } else {
+                in_str = true;
+            }
+        } else if in_str {
+            if c == '\\' {
+                if let Some(next) = chars.next() {
+                    match next {
+                        '"' => cur.push('"'),
+                        '\\' => cur.push('\\'),
+                        'n' => cur.push('\n'),
+                        't' => cur.push('\t'),
+                        other => {
+                            cur.push('\\');
+                            cur.push(other);
+                        }
+                    }
+                }
+            } else {
+                cur.push(c);
+            }
+        }
+    }
+    out
+}
+
+/// sha256 of a file using the system sha256sum / shasum / openssl.
+///
+/// Panics if none of those tools is available — the manifest hash is provenance
+/// that must match the Python (`hashlib`) digest, so we never emit a non-SHA-256
+/// value that merely looks like one.
+fn sha256_file(path: &str) -> String {
+    // Try sha256sum (Linux), then shasum -a 256 (macOS), then openssl.
+    for (cmd, args) in &[
+        ("sha256sum", vec![path]),
+        ("shasum", vec!["-a", "256", path]),
+        ("openssl", vec!["dgst", "-sha256", path]),
+    ] {
+        if let Ok(out) = std::process::Command::new(cmd).args(args).output() {
+            if out.status.success() {
+                let s = String::from_utf8_lossy(&out.stdout);
+                // sha256sum: "<hex>  <file>"; shasum: same; openssl: "SHA256(...)= <hex>"
+                for token in s.split_whitespace() {
+                    if token.len() == 64 && token.chars().all(|c| c.is_ascii_hexdigit()) {
+                        return token.to_string();
+                    }
+                }
+            }
+        }
+    }
+    panic!(
+        "no SHA-256 tool available (tried sha256sum / shasum -a 256 / openssl) — \
+         cannot compute the encoder-manifest digest for {path}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// Detect SIMD features
+// ---------------------------------------------------------------------------
+
+fn detected_simd() -> Vec<String> {
+    #[cfg(target_arch = "x86_64")]
+    {
+        let mut v = Vec::new();
+        if is_x86_feature_detected!("avx2") {
+            v.push("avx2".to_string());
+        }
+        if is_x86_feature_detected!("fma") {
+            v.push("fma".to_string());
+        }
+        if is_x86_feature_detected!("avx512f") {
+            v.push("avx512f".to_string());
+        }
+        v
+    }
+    #[cfg(not(target_arch = "x86_64"))]
+    {
+        Vec::new()
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Percentile helper
+// ---------------------------------------------------------------------------
+
+fn percentile_ms(mut samples: Vec<u128>, p: f32) -> f64 {
+    samples.sort_unstable();
+    let i = ((samples.len() as f32 - 1.0) * p).round() as usize;
+    // samples are nanoseconds; convert to milliseconds
+    samples[i] as f64 / 1_000_000.0
+}
+
+// ---------------------------------------------------------------------------
+// Top-k JSONL writer
+// ---------------------------------------------------------------------------
+
+/// Write one JSONL row per query to `writer`.
+/// `indices` is a flat `nq * k` slice (global doc indices, i64; -1 = padding).
+fn write_topk_jsonl<W: Write>(
+    writer: &mut W,
+    dataset: &str,
+    split: &str,
+    method: &str,
+    k: usize,
+    query_ids: &[String],
+    corpus_ids: &[String],
+    indices: &[i64],
+    scores: &[f32],
+) {
+    let nq = query_ids.len();
+    let n_corpus = corpus_ids.len();
+    for qi in 0..nq {
+        let row_indices = &indices[qi * k..(qi + 1) * k];
+        // Build doc_idxs and doc_ids arrays (skip sentinels at the end).
+        let mut doc_idxs_str = String::from("[");
+        let mut doc_ids_str = String::from("[");
+        let mut scores_str = String::from("[");
+        let mut first = true;
+        for (j, &di) in row_indices.iter().enumerate() {
+            if di < 0 {
+                break;
+            }
+            let di_usize = di as usize;
+            if !first {
+                doc_idxs_str.push(',');
+                doc_ids_str.push(',');
+                scores_str.push(',');
+            }
+            first = false;
+            doc_idxs_str.push_str(&di_usize.to_string());
+            let doc_id = if di_usize < n_corpus {
+                corpus_ids[di_usize].as_str()
+            } else {
+                ""
+            };
+            doc_ids_str.push('"');
+            doc_ids_str.push_str(doc_id);
+            doc_ids_str.push('"');
+            // Real per-doc score (results are rank-ordered; downstream eval ranks
+            // by score). Non-finite guarded to keep the JSON valid.
+            let sc = scores.get(qi * k + j).copied().unwrap_or(0.0);
+            if sc.is_finite() {
+                scores_str.push_str(&sc.to_string());
+            } else {
+                scores_str.push_str("0.0");
+            }
+        }
+        doc_idxs_str.push(']');
+        doc_ids_str.push(']');
+        scores_str.push(']');
+
+        writeln!(
+            writer,
+            r#"{{"dataset":"{dataset}","split":"{split}","method":"{method}","qid_idx":{qi},"qid":"{qid}","k":{k},"doc_idxs":{doc_idxs_str},"doc_ids":{doc_ids_str},"scores":{scores_str}}}"#,
+            qid = query_ids[qi],
+        )
+        .expect("write topk jsonl");
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Summary JSON writer
+// ---------------------------------------------------------------------------
+
+#[allow(clippy::too_many_arguments)]
+fn write_summary_json<W: Write>(
+    writer: &mut W,
+    dataset: &str,
+    split: &str,
+    method: &str,
+    dim: usize,
+    n_docs: usize,
+    n_queries: usize,
+    top_k: usize,
+    bytes_per_vector: usize,
+    index_total_mib: f64,
+    build_seconds: f64,
+    p50_ms: f64,
+    p95_ms: f64,
+    p99_ms: f64,
+    queries_per_second: f64,
+    candidate_m: usize,
+    batch: usize,
+    simd_detected: &[String],
+    encoder_manifest_sha256: &str,
+) {
+    let simd_arr: String = {
+        let parts: Vec<String> = simd_detected.iter().map(|s| format!("\"{s}\"")).collect();
+        format!("[{}]", parts.join(","))
+    };
+    let rustc = rustc_version();
+    let crate_ver = env!("CARGO_PKG_VERSION");
+    writeln!(
+        writer,
+        r#"{{"dataset":"{dataset}","split":"{split}","method":"{method}","dim":{dim},"n_docs":{n_docs},"n_queries":{n_queries},"top_k":{top_k},"bytes_per_vector":{bytes_per_vector},"index_total_mib":{index_total_mib:.3},"build_seconds":{build_seconds:.4},"query_latency_ms_p50":{p50_ms:.4},"query_latency_ms_p95":{p95_ms:.4},"query_latency_ms_p99":{p99_ms:.4},"queries_per_second":{queries_per_second:.2},"candidate_m":{candidate_m},"batch":{batch},"cpu_arch":"{arch}","simd_detected":{simd_arr},"rustc":"{rustc}","crate_version":"{crate_ver}","encoder_manifest_sha256":"{encoder_manifest_sha256}"}}"#,
+        arch = std::env::consts::ARCH,
+    )
+    .expect("write summary json");
+}
+
+fn rustc_version() -> String {
+    if let Ok(out) = std::process::Command::new("rustc")
+        .arg("--version")
+        .output()
+    {
+        if out.status.success() {
+            return String::from_utf8_lossy(&out.stdout).trim().to_string();
+        }
+    }
+    "unknown".to_string()
+}
+
+// ---------------------------------------------------------------------------
+// Output file helpers
+// ---------------------------------------------------------------------------
+
+fn open_output(out_dir: &str, dataset: &str, slug: &str, ext: &str) -> BufWriter<std::fs::File> {
+    let dir = format!("{out_dir}/{dataset}");
+    std::fs::create_dir_all(&dir).unwrap_or_else(|e| panic!("create_dir_all {dir}: {e}"));
+    let path = format!("{dir}/{slug}.{ext}");
+    let f = std::fs::File::create(&path).unwrap_or_else(|e| panic!("create {path}: {e}"));
+    BufWriter::new(f)
+}
+
+// ---------------------------------------------------------------------------
+// Validate embeddings
+// ---------------------------------------------------------------------------
+
+fn validate_embeddings(data: &[f32], n: usize, dim: usize, label: &str) {
+    assert_eq!(dim, 1024, "{label}: embedding_dim must be 1024, got {dim}");
+    assert_eq!(dim % 16, 0, "{label}: dim must be divisible by 16");
+    for (i, row) in data.chunks_exact(dim).enumerate() {
+        let norm2: f32 = row.iter().map(|x| x * x).sum();
+        let norm = norm2.sqrt();
+        assert!(
+            (norm - 1.0).abs() < 1e-3,
+            "{label} row {i}: L2 norm {norm:.6} not in [0.999, 1.001]",
+        );
+    }
+    eprintln!("  {label}: validated {n} rows (dim={dim}, L2-normalised)");
+}
+
+// ---------------------------------------------------------------------------
+// Timing helpers
+// ---------------------------------------------------------------------------
+
+/// Collect per-query latency samples (ns) for `search_fn` applied to each
+/// query row. `warmup` queries are excluded from timing.
+fn time_batched<F>(
+    queries: &[f32],
+    dim: usize,
+    n_queries: usize,
+    batch: usize,
+    warmup: usize,
+    mut search_fn: F,
+) -> Vec<u128>
+where
+    F: FnMut(&[f32]) -> Vec<i64>,
+{
+    // Warmup: run a few batches without recording.
+    let warmup_queries = warmup.min(n_queries);
+    {
+        let w_end = (warmup_queries + batch - 1) / batch * batch;
+        let w_end = w_end.min(n_queries);
+        for b_start in (0..w_end).step_by(batch) {
+            let b_end = (b_start + batch).min(n_queries);
+            let batch_q = &queries[b_start * dim..b_end * dim];
+            let _ = search_fn(batch_q);
+        }
+    }
+
+    let mut samples = Vec::with_capacity(n_queries);
+    let mut b_start = 0usize;
+    while b_start < n_queries {
+        let b_end = (b_start + batch).min(n_queries);
+        let b = b_end - b_start;
+        let batch_q = &queries[b_start * dim..b_end * dim];
+        let t0 = Instant::now();
+        let _ = search_fn(batch_q);
+        let elapsed_ns = t0.elapsed().as_nanos();
+        let per_query_ns = elapsed_ns / b as u128;
+        for _ in 0..b {
+            samples.push(per_query_ns);
+        }
+        b_start = b_end;
+    }
+    samples
+}
+
+// ---------------------------------------------------------------------------
+// Collect all predictions (flat nq*k indices)
+// ---------------------------------------------------------------------------
+
+fn collect_all_predictions<F>(
+    queries: &[f32],
+    dim: usize,
+    n_queries: usize,
+    top_k: usize,
+    batch: usize,
+    mut search_fn: F,
+) -> (Vec<i64>, Vec<f32>)
+where
+    F: FnMut(&[f32]) -> (Vec<i64>, Vec<f32>),
+{
+    let mut out_i = Vec::with_capacity(n_queries * top_k);
+    let mut out_s = Vec::with_capacity(n_queries * top_k);
+    let mut b_start = 0usize;
+    while b_start < n_queries {
+        let b_end = (b_start + batch).min(n_queries);
+        let batch_q = &queries[b_start * dim..b_end * dim];
+        let (pi, ps) = search_fn(batch_q);
+        out_i.extend_from_slice(&pi);
+        out_s.extend_from_slice(&ps);
+        b_start = b_end;
+    }
+    (out_i, out_s)
+}
+
+// ---------------------------------------------------------------------------
+// Method runners
+// ---------------------------------------------------------------------------
+
+/// Build a Bitmap→CSR helper: convert `Vec<Vec<u32>>` (one row per query)
+/// into CSR (offsets, concatenated candidates).
+fn bitmap_vecs_to_csr(vecs: Vec<Vec<u32>>) -> (Vec<usize>, Vec<u32>) {
+    let nq = vecs.len();
+    let mut offsets = Vec::with_capacity(nq + 1);
+    let mut candidates = Vec::new();
+    offsets.push(0usize);
+    for row in &vecs {
+        candidates.extend_from_slice(row);
+        offsets.push(candidates.len());
+    }
+    (offsets, candidates)
+}
+
+/// rq2 / rq4: full-scan asymmetric search.
+fn run_full_scan(
+    corpus: &[f32],
+    queries: &[f32],
+    dim: usize,
+    n_queries: usize,
+    top_k: usize,
+    batch: usize,
+    bits: u8,
+    dataset: &str,
+    split: &str,
+    query_ids: &[String],
+    corpus_ids: &[String],
+    out_dir: &str,
+    simd: &[String],
+    encoder_sha: &str,
+) {
+    let method_slug = format!("ordvec-rq{bits}");
+    eprintln!("building RankQuant b={bits} index ...");
+    let mut idx = RankQuant::new(dim, bits);
+    let t0 = Instant::now();
+    idx.add(corpus);
+    let build_seconds = t0.elapsed().as_secs_f64();
+    eprintln!("  build done in {build_seconds:.2}s ({} docs)", idx.len());
+
+    let n_docs = idx.len();
+    let bytes_per_vector = idx.bytes_per_vec();
+    let index_total_mib = idx.byte_size() as f64 / 1024.0 / 1024.0;
+
+    // Warmup: min(5, n_queries) queries.
+    let warmup = 5.min(n_queries);
+
+    // Timing pass (batched, allocation-free after warmup).
+    eprintln!("  timing {n_queries} queries (batch={batch}, warmup={warmup}) ...");
+    let samples = time_batched(queries, dim, n_queries, batch, warmup, |batch_q| {
+        let res = idx.search_asymmetric(batch_q, top_k);
+        res.indices
+    });
+
+    let p50 = percentile_ms(samples.clone(), 0.50);
+    let p95 = percentile_ms(samples.clone(), 0.95);
+    let p99 = percentile_ms(samples, 0.99);
+    let qps = 1_000.0 / p50.max(f64::EPSILON);
+
+    // Collect predictions.
+    eprintln!("  collecting predictions ...");
+    let (pred_indices, pred_scores) =
+        collect_all_predictions(queries, dim, n_queries, top_k, batch, |batch_q| {
+            let res = idx.search_asymmetric(batch_q, top_k);
+            (res.indices, res.scores)
+        });
+
+    // Write JSONL.
+    let mut jsonl_writer = open_output(out_dir, dataset, &method_slug, "topk.jsonl");
+    write_topk_jsonl(
+        &mut jsonl_writer,
+        dataset,
+        split,
+        &method_slug,
+        top_k,
+        query_ids,
+        corpus_ids,
+        &pred_indices,
+        &pred_scores,
+    );
+    jsonl_writer.flush().expect("flush topk jsonl");
+
+    // Write summary.
+    let mut summary_writer = open_output(out_dir, dataset, &method_slug, "summary.json");
+    write_summary_json(
+        &mut summary_writer,
+        dataset,
+        split,
+        &method_slug,
+        dim,
+        n_docs,
+        n_queries,
+        top_k,
+        bytes_per_vector,
+        index_total_mib,
+        build_seconds,
+        p50,
+        p95,
+        p99,
+        qps,
+        0, // candidate_m not applicable for full scan
+        batch,
+        simd,
+        encoder_sha,
+    );
+    summary_writer.flush().expect("flush summary json");
+    eprintln!("  {method_slug}: p50={p50:.3}ms p95={p95:.3}ms p99={p99:.3}ms qps={qps:.1}",);
+}
+
+/// bitmap-rq2: Bitmap candidate gen → RankQuant b=2 asymmetric rerank.
+fn run_bitmap_rq2(
+    corpus: &[f32],
+    queries: &[f32],
+    dim: usize,
+    n_queries: usize,
+    top_k: usize,
+    batch: usize,
+    candidates: usize,
+    dataset: &str,
+    split: &str,
+    query_ids: &[String],
+    corpus_ids: &[String],
+    out_dir: &str,
+    simd: &[String],
+    encoder_sha: &str,
+) {
+    let method_slug = format!("ordvec-bitmap-rq2-m{candidates}-b{batch}");
+    eprintln!("building Bitmap + RankQuant b=2 index (m={candidates}) ...");
+
+    // n_top for the bitmap: mirror bench_rank.rs (dim/4 = top quarter, b=2-equivalent).
+    let n_top = dim / 4;
+    let mut bitmap = Bitmap::new(dim, n_top);
+    let mut rq = RankQuant::new(dim, 2);
+    let t0 = Instant::now();
+    bitmap.add(corpus);
+    rq.add(corpus);
+    let build_seconds = t0.elapsed().as_secs_f64();
+    eprintln!("  build done in {build_seconds:.2}s");
+
+    let n_docs = rq.len();
+    let bytes_per_vector = bitmap.bytes_per_vec() + rq.bytes_per_vec();
+    let index_total_mib = (bitmap.byte_size() + rq.byte_size()) as f64 / 1024.0 / 1024.0;
+
+    let out_k = top_k.min(candidates).min(n_docs);
+    let warmup = 5.min(n_queries);
+
+    // Allocate pooled scratch and output buffers — reused across all batches.
+    let mut scratch = SubsetScratch::new();
+    // Size the output buffers for a full batch (worst case = `batch` queries).
+    let max_batch = batch;
+    let mut out_scores_buf = vec![f32::NEG_INFINITY; max_batch * out_k];
+    let mut out_indices_buf = vec![-1i64; max_batch * out_k];
+
+    // Helper: run one query-batch through the two-stage pipeline.
+    // Returns flat nq_batch * out_k indices (sentinel-padded).
+    let two_stage_batch = |batch_q: &[f32],
+                           bitmap: &Bitmap,
+                           rq: &RankQuant,
+                           scratch: &mut SubsetScratch,
+                           out_scores_buf: &mut Vec<f32>,
+                           out_indices_buf: &mut Vec<i64>|
+     -> (Vec<i64>, Vec<f32>) {
+        let nq_batch = batch_q.len() / dim;
+        // Resize scratch output buffers if batch shrinks (last batch may be smaller).
+        let needed = nq_batch * out_k;
+        if out_scores_buf.len() != needed {
+            out_scores_buf.resize(needed, f32::NEG_INFINITY);
+            out_indices_buf.resize(needed, -1);
+        }
+
+        // Stage 1: bitmap candidate gen → Vec<Vec<u32>>.
+        let cand_vecs = bitmap.top_m_candidates_batched(batch_q, candidates);
+        // Convert to CSR for the batched subset rerank.
+        let (offsets, cand_flat) = bitmap_vecs_to_csr(cand_vecs);
+
+        // Stage 2: pooled subset rerank.
+        rq.search_asymmetric_subset_batched_serial_into(
+            batch_q,
+            &offsets,
+            &cand_flat,
+            top_k,
+            scratch,
+            out_scores_buf,
+            out_indices_buf,
+        );
+
+        // Map candidate-local indices (already global doc ids, since cands come from
+        // bitmap which stores global doc ids) — indices are already global.
+        // Pad per-query results to `top_k` with -1 sentinels if out_k < top_k.
+        let mut result = vec![-1i64; nq_batch * top_k];
+        let mut result_scores = vec![0.0f32; nq_batch * top_k];
+        for qi in 0..nq_batch {
+            let src = &out_indices_buf[qi * out_k..(qi + 1) * out_k];
+            let src_s = &out_scores_buf[qi * out_k..(qi + 1) * out_k];
+            let dst = &mut result[qi * top_k..(qi + 1) * top_k];
+            let copy_len = src.len().min(dst.len());
+            dst[..copy_len].copy_from_slice(&src[..copy_len]);
+            result_scores[qi * top_k..qi * top_k + copy_len].copy_from_slice(&src_s[..copy_len]);
+        }
+        (result, result_scores)
+    };
+
+    eprintln!("  timing {n_queries} queries (batch={batch}, warmup={warmup}) ...");
+    let samples = {
+        // Warmup.
+        {
+            let w_end = (warmup + batch - 1) / batch * batch;
+            let w_end = w_end.min(n_queries);
+            for b_start in (0..w_end).step_by(batch) {
+                let b_end = (b_start + batch).min(n_queries);
+                let batch_q = &queries[b_start * dim..b_end * dim];
+                let _ = two_stage_batch(
+                    batch_q,
+                    &bitmap,
+                    &rq,
+                    &mut scratch,
+                    &mut out_scores_buf,
+                    &mut out_indices_buf,
+                );
+            }
+        }
+        let mut s = Vec::with_capacity(n_queries);
+        let mut b_start = 0usize;
+        while b_start < n_queries {
+            let b_end = (b_start + batch).min(n_queries);
+            let b = b_end - b_start;
+            let batch_q = &queries[b_start * dim..b_end * dim];
+            let t0 = Instant::now();
+            let _ = two_stage_batch(
+                batch_q,
+                &bitmap,
+                &rq,
+                &mut scratch,
+                &mut out_scores_buf,
+                &mut out_indices_buf,
+            );
+            let elapsed_ns = t0.elapsed().as_nanos();
+            let per_query_ns = elapsed_ns / b as u128;
+            for _ in 0..b {
+                s.push(per_query_ns);
+            }
+            b_start = b_end;
+        }
+        s
+    };
+
+    let p50 = percentile_ms(samples.clone(), 0.50);
+    let p95 = percentile_ms(samples.clone(), 0.95);
+    let p99 = percentile_ms(samples, 0.99);
+    let qps = 1_000.0 / p50.max(f64::EPSILON);
+
+    eprintln!("  collecting predictions ...");
+    let mut pred_indices = Vec::with_capacity(n_queries * top_k);
+    let mut pred_scores: Vec<f32> = Vec::with_capacity(n_queries * top_k);
+    let mut b_start = 0usize;
+    while b_start < n_queries {
+        let b_end = (b_start + batch).min(n_queries);
+        let batch_q = &queries[b_start * dim..b_end * dim];
+        let (preds, pred_s) = two_stage_batch(
+            batch_q,
+            &bitmap,
+            &rq,
+            &mut scratch,
+            &mut out_scores_buf,
+            &mut out_indices_buf,
+        );
+        pred_indices.extend_from_slice(&preds);
+        pred_scores.extend_from_slice(&pred_s);
+        b_start = b_end;
+    }
+
+    // Write outputs.
+    let mut jsonl_writer = open_output(out_dir, dataset, &method_slug, "topk.jsonl");
+    write_topk_jsonl(
+        &mut jsonl_writer,
+        dataset,
+        split,
+        &method_slug,
+        top_k,
+        query_ids,
+        corpus_ids,
+        &pred_indices,
+        &pred_scores,
+    );
+    jsonl_writer.flush().expect("flush topk jsonl");
+
+    let mut summary_writer = open_output(out_dir, dataset, &method_slug, "summary.json");
+    write_summary_json(
+        &mut summary_writer,
+        dataset,
+        split,
+        &method_slug,
+        dim,
+        n_docs,
+        n_queries,
+        top_k,
+        bytes_per_vector,
+        index_total_mib,
+        build_seconds,
+        p50,
+        p95,
+        p99,
+        qps,
+        candidates,
+        batch,
+        simd,
+        encoder_sha,
+    );
+    summary_writer.flush().expect("flush summary json");
+    eprintln!("  {method_slug}: p50={p50:.3}ms p95={p95:.3}ms p99={p99:.3}ms qps={qps:.1}",);
+}
+
+/// sign-rq2: SignBitmap candidate gen → RankQuant b=2 asymmetric rerank.
+fn run_sign_rq2(
+    corpus: &[f32],
+    queries: &[f32],
+    dim: usize,
+    n_queries: usize,
+    top_k: usize,
+    batch: usize,
+    candidates: usize,
+    dataset: &str,
+    split: &str,
+    query_ids: &[String],
+    corpus_ids: &[String],
+    out_dir: &str,
+    simd: &[String],
+    encoder_sha: &str,
+) {
+    let method_slug = format!("ordvec-sign-rq2-m{candidates}-b{batch}");
+    eprintln!("building SignBitmap + RankQuant b=2 index (m={candidates}) ...");
+
+    let mut sign = SignBitmap::new(dim);
+    let mut rq = RankQuant::new(dim, 2);
+    let t0 = Instant::now();
+    sign.add(corpus);
+    rq.add(corpus);
+    let build_seconds = t0.elapsed().as_secs_f64();
+    eprintln!("  build done in {build_seconds:.2}s");
+
+    let n_docs = rq.len();
+    let bytes_per_vector = sign.bytes_per_vec() + rq.bytes_per_vec();
+    let index_total_mib = (sign.byte_size() + rq.byte_size()) as f64 / 1024.0 / 1024.0;
+
+    let out_k = top_k.min(candidates).min(n_docs);
+    let warmup = 5.min(n_queries);
+
+    // Pooled scratch and output buffers — reused across batches (allocation-free after warmup).
+    let mut scratch = SubsetScratch::new();
+    let max_batch = batch;
+    let mut out_scores_buf = vec![f32::NEG_INFINITY; max_batch * out_k];
+    let mut out_indices_buf = vec![-1i64; max_batch * out_k];
+
+    let sign_two_stage_batch = |batch_q: &[f32],
+                                sign: &SignBitmap,
+                                rq: &RankQuant,
+                                scratch: &mut SubsetScratch,
+                                out_scores_buf: &mut Vec<f32>,
+                                out_indices_buf: &mut Vec<i64>|
+     -> (Vec<i64>, Vec<f32>) {
+        let nq_batch = batch_q.len() / dim;
+        let needed = nq_batch * out_k;
+        if out_scores_buf.len() != needed {
+            out_scores_buf.resize(needed, f32::NEG_INFINITY);
+            out_indices_buf.resize(needed, -1);
+        }
+
+        // Stage 1: SignBitmap → CSR CandidateBatch (SIMD XOR-popcount kernel).
+        let cb: CandidateBatch = sign.top_m_candidates_batched_serial_csr(batch_q, candidates);
+
+        // Stage 2: pooled subset rerank.
+        rq.search_asymmetric_subset_batched_serial_into(
+            batch_q,
+            &cb.offsets,
+            &cb.candidates,
+            top_k,
+            scratch,
+            out_scores_buf,
+            out_indices_buf,
+        );
+
+        // Pad per-query results to `top_k` with -1 sentinels if out_k < top_k.
+        let mut result = vec![-1i64; nq_batch * top_k];
+        let mut result_scores = vec![0.0f32; nq_batch * top_k];
+        for qi in 0..nq_batch {
+            let src = &out_indices_buf[qi * out_k..(qi + 1) * out_k];
+            let src_s = &out_scores_buf[qi * out_k..(qi + 1) * out_k];
+            let dst = &mut result[qi * top_k..(qi + 1) * top_k];
+            let copy_len = src.len().min(dst.len());
+            dst[..copy_len].copy_from_slice(&src[..copy_len]);
+            result_scores[qi * top_k..qi * top_k + copy_len].copy_from_slice(&src_s[..copy_len]);
+        }
+        (result, result_scores)
+    };
+
+    eprintln!("  timing {n_queries} queries (batch={batch}, warmup={warmup}) ...");
+
+    // Warmup via top_m_candidates_batched_serial_csr.
+    {
+        let w_end = warmup.min(n_queries);
+        if w_end > 0 {
+            let _ = sign.top_m_candidates_batched_serial_csr(&queries[..w_end * dim], candidates);
+        }
+    }
+
+    let samples = {
+        let mut s = Vec::with_capacity(n_queries);
+        let mut b_start = 0usize;
+        while b_start < n_queries {
+            let b_end = (b_start + batch).min(n_queries);
+            let b = b_end - b_start;
+            let batch_q = &queries[b_start * dim..b_end * dim];
+            let t0 = Instant::now();
+            let _ = sign_two_stage_batch(
+                batch_q,
+                &sign,
+                &rq,
+                &mut scratch,
+                &mut out_scores_buf,
+                &mut out_indices_buf,
+            );
+            let elapsed_ns = t0.elapsed().as_nanos();
+            let per_query_ns = elapsed_ns / b as u128;
+            for _ in 0..b {
+                s.push(per_query_ns);
+            }
+            b_start = b_end;
+        }
+        s
+    };
+
+    let p50 = percentile_ms(samples.clone(), 0.50);
+    let p95 = percentile_ms(samples.clone(), 0.95);
+    let p99 = percentile_ms(samples, 0.99);
+    let qps = 1_000.0 / p50.max(f64::EPSILON);
+
+    eprintln!("  collecting predictions ...");
+    let mut pred_indices = Vec::with_capacity(n_queries * top_k);
+    let mut pred_scores: Vec<f32> = Vec::with_capacity(n_queries * top_k);
+    let mut b_start = 0usize;
+    while b_start < n_queries {
+        let b_end = (b_start + batch).min(n_queries);
+        let batch_q = &queries[b_start * dim..b_end * dim];
+        let (preds, pred_s) = sign_two_stage_batch(
+            batch_q,
+            &sign,
+            &rq,
+            &mut scratch,
+            &mut out_scores_buf,
+            &mut out_indices_buf,
+        );
+        pred_indices.extend_from_slice(&preds);
+        pred_scores.extend_from_slice(&pred_s);
+        b_start = b_end;
+    }
+
+    // Write outputs.
+    let mut jsonl_writer = open_output(out_dir, dataset, &method_slug, "topk.jsonl");
+    write_topk_jsonl(
+        &mut jsonl_writer,
+        dataset,
+        split,
+        &method_slug,
+        top_k,
+        query_ids,
+        corpus_ids,
+        &pred_indices,
+        &pred_scores,
+    );
+    jsonl_writer.flush().expect("flush topk jsonl");
+
+    let mut summary_writer = open_output(out_dir, dataset, &method_slug, "summary.json");
+    write_summary_json(
+        &mut summary_writer,
+        dataset,
+        split,
+        &method_slug,
+        dim,
+        n_docs,
+        n_queries,
+        top_k,
+        bytes_per_vector,
+        index_total_mib,
+        build_seconds,
+        p50,
+        p95,
+        p99,
+        qps,
+        candidates,
+        batch,
+        simd,
+        encoder_sha,
+    );
+    summary_writer.flush().expect("flush summary json");
+    eprintln!("  {method_slug}: p50={p50:.3}ms p95={p95:.3}ms p99={p99:.3}ms qps={qps:.1}",);
+}
+
+// ---------------------------------------------------------------------------
+// Cache resolution
+// ---------------------------------------------------------------------------
+
+/// Resolve the single `encoder=*` subdirectory under
+/// `<cache_dir>/<dataset>/<split>/`. Panics if zero or multiple matches.
+fn resolve_encoder_dir(cache_dir: &str, dataset: &str, split: &str) -> String {
+    let parent = format!("{cache_dir}/{dataset}/{split}");
+    let entries = std::fs::read_dir(&parent).unwrap_or_else(|e| panic!("read_dir {parent}: {e}"));
+    let mut matches: Vec<String> = entries
+        .filter_map(|e| e.ok())
+        .filter(|e| e.file_name().to_string_lossy().starts_with("encoder=") && e.path().is_dir())
+        .map(|e| e.path().to_string_lossy().to_string())
+        .collect();
+    assert!(
+        !matches.is_empty(),
+        "no encoder=* subdirectory found under {parent}",
+    );
+    assert!(
+        matches.len() == 1,
+        "multiple encoder=* directories found under {parent}: {matches:?} — \
+         specify exactly one encoder per dataset/split",
+    );
+    matches.remove(0)
+}
+
+// ---------------------------------------------------------------------------
+// main
+// ---------------------------------------------------------------------------
+
+fn main() {
+    let cfg = parse_args();
+
+    eprintln!(
+        "beir_ordvec: dataset={} split={} top_k={} batch={} candidates={} methods={:?}",
+        cfg.dataset, cfg.split, cfg.top_k, cfg.batch, cfg.candidates, cfg.methods,
+    );
+
+    // Resolve encoder directory.
+    let enc_dir = resolve_encoder_dir(&cfg.cache_dir, &cfg.dataset, &cfg.split);
+    eprintln!("encoder dir: {enc_dir}");
+
+    // Compute encoder_manifest_sha256 from embeddings.manifest.json.
+    let manifest_path = format!("{enc_dir}/embeddings.manifest.json");
+    let encoder_sha = sha256_file(&manifest_path);
+    eprintln!("encoder_manifest_sha256: {encoder_sha}");
+
+    // Load corpus embeddings.
+    let corpus_npy = format!("{enc_dir}/corpus.f32.npy");
+    eprintln!("loading corpus: {corpus_npy}");
+    let t0 = Instant::now();
+    let (corpus, n_corpus, dim) = load_npy_f32(&corpus_npy);
+    eprintln!(
+        "  loaded {n_corpus} corpus vectors in {:.2}s",
+        t0.elapsed().as_secs_f64()
+    );
+
+    // Load query embeddings.
+    let queries_npy = format!("{enc_dir}/queries.f32.npy");
+    eprintln!("loading queries: {queries_npy}");
+    let t0 = Instant::now();
+    let (queries, n_queries, q_dim) = load_npy_f32(&queries_npy);
+    assert_eq!(q_dim, dim, "query dim {q_dim} != corpus dim {dim}",);
+    eprintln!(
+        "  loaded {n_queries} query vectors in {:.2}s",
+        t0.elapsed().as_secs_f64()
+    );
+
+    // Validate embeddings.
+    validate_embeddings(&corpus, n_corpus, dim, "corpus");
+    validate_embeddings(&queries, n_queries, q_dim, "queries");
+    assert_eq!(
+        n_corpus,
+        corpus.len() / dim,
+        "corpus id count / embedding count mismatch",
+    );
+    assert_eq!(
+        n_queries,
+        queries.len() / dim,
+        "query id count / embedding count mismatch",
+    );
+
+    // Load corpus_ids and query_ids.
+    let corpus_ids_path = format!("{enc_dir}/corpus_ids.json");
+    let query_ids_path = format!("{enc_dir}/query_ids.json");
+    let corpus_ids = load_json_string_array(&corpus_ids_path);
+    let query_ids = load_json_string_array(&query_ids_path);
+    assert_eq!(
+        corpus_ids.len(),
+        n_corpus,
+        "corpus_ids length {} != n_corpus {n_corpus}",
+        corpus_ids.len(),
+    );
+    assert_eq!(
+        query_ids.len(),
+        n_queries,
+        "query_ids length {} != n_queries {n_queries}",
+        query_ids.len(),
+    );
+
+    let simd = detected_simd();
+    eprintln!("simd detected: {:?}", simd);
+    eprintln!("dim={dim} n_corpus={n_corpus} n_queries={n_queries}");
+
+    // Run each requested method.
+    for method in &cfg.methods {
+        eprintln!("\n--- method: {method} ---");
+        match method.as_str() {
+            "rq2" => run_full_scan(
+                &corpus,
+                &queries,
+                dim,
+                n_queries,
+                cfg.top_k,
+                cfg.batch,
+                2,
+                &cfg.dataset,
+                &cfg.split,
+                &query_ids,
+                &corpus_ids,
+                &cfg.out_dir,
+                &simd,
+                &encoder_sha,
+            ),
+            "rq4" => run_full_scan(
+                &corpus,
+                &queries,
+                dim,
+                n_queries,
+                cfg.top_k,
+                cfg.batch,
+                4,
+                &cfg.dataset,
+                &cfg.split,
+                &query_ids,
+                &corpus_ids,
+                &cfg.out_dir,
+                &simd,
+                &encoder_sha,
+            ),
+            "bitmap-rq2" => run_bitmap_rq2(
+                &corpus,
+                &queries,
+                dim,
+                n_queries,
+                cfg.top_k,
+                cfg.batch,
+                cfg.candidates,
+                &cfg.dataset,
+                &cfg.split,
+                &query_ids,
+                &corpus_ids,
+                &cfg.out_dir,
+                &simd,
+                &encoder_sha,
+            ),
+            "sign-rq2" => run_sign_rq2(
+                &corpus,
+                &queries,
+                dim,
+                n_queries,
+                cfg.top_k,
+                cfg.batch,
+                cfg.candidates,
+                &cfg.dataset,
+                &cfg.split,
+                &query_ids,
+                &corpus_ids,
+                &cfg.out_dir,
+                &simd,
+                &encoder_sha,
+            ),
+            other => panic!("unknown method '{other}'. Supported: rq2, rq4, bitmap-rq2, sign-rq2",),
+        }
+    }
+
+    eprintln!("\ndone. Results in {}/{}", cfg.out_dir, cfg.dataset);
+}
diff --git a/results/beir/.gitkeep b/results/beir/.gitkeep
new file mode 100644
index 00000000..e69de29b

From eb4aaa4b69ed2e6c5945642b104288f050357393 Mon Sep 17 00:00:00 2001
From: Nelson Spence <nelson@projectnavi.ai>
Date: Mon, 15 Jun 2026 09:17:38 -0500
Subject: [PATCH 2/5] bench: rework BEIR harness to all-Rust comparison +
 README above-the-fold
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the split Python-baselines + single-method-example harness with a single
all-Rust comparison binary, and lead the README with the reproducible results.

Why: the previous design measured ordvec (Rust) against FAISS/hnswlib (Python),
so the latency comparison crossed a language/FFI boundary and used a single-query
baseline — not apples-to-apples, and the headline multiplier depended on
un-stated batch/thread choices.

benchmarks/beir-bench (new workspace member, publish=false, isolated so its
hnsw_rs/matrixmultiply deps never touch the `-p ordvec` deps gate or the
published crate):
- flat: exact inner product (== FAISS IndexFlatIP retrieval) via a pure-Rust
  SIMD GEMM (matrixmultiply) — a competitive baseline, not a scalar strawman.
- hnsw: pure-Rust HNSW (hnsw_rs, M=32/ef=128) — the portable stand-in for C++
  hnswlib (no maintained Rust binding to the latter exists).
- ordvec rq2/rq4 + bitmap-rq2/sign-rq2 via the batched/pooled/SIMD fast paths.
- One process, matched batch; `--threads N` pins query latency to a rayon pool
  (build still uses all cores), `--max-docs M` sub-samples the corpus for the
  scaling sweep. Emits per-(method,n,threads) timing.jsonl + full-corpus
  topk/summary for offline nDCG.

Harness/Python:
- beir_prepare.py: canonical llamacpp lane (GGUF Q8 Harrier via llama-cpp-python,
  CUDA) + skip-if-cached guard so multi-target runs don't re-embed.
- beir_plot.py (new): renders the three README figures (scaling curve +
  single-thread/threaded bars) from timing.jsonl.
- beir_eval/beir_report: classify the flat/hnsw slugs; baseline-relative deltas
  use the actual baseline name.
- requirements.txt: drop the unbuildable `beir`/`pytrec_eval`; vendored BEIR
  loader + pytrec-eval-terrier + huggingface-hub + matplotlib; llama-cpp-python
  is built with CUDA flags by `make bench-beir-setup`.
- Makefile: benchmark-beir = guardrail + quality(nDCG) + scaling + graphics;
  .NOTPARALLEL so an inherited MAKEFLAGS=-jN can't race the cache.
- Delete beir_baselines.py (Python FAISS/hnswlib) and examples/beir_ordvec.rs —
  both superseded by beir-bench.

README: drop the private-arXiv real-embedding block; add a "Benchmark at a
glance" hero (scaling curve + one-command reproduce) and a BEIR section with the
nDCG@10 table, the three latency views (single-query ~100x, batched, threaded),
and an explicit ordvec-vs-HNSW tradeoff table (HNSW edges threaded latency;
ordvec wins build [training-free vs 51s], memory [8-16x], and single-query).
benchmarks/ excluded from the published crate; figures referenced by absolute
raw URL.

Verified: cargo fmt --all --check, clippy -p ordvec / -p beir-bench (0 warnings),
cargo build --locked, deps gate (`cargo tree -p ordvec` clean), py_compile all
scripts, and a full `make benchmark-beir` on scifact + trec-covid (171,332 docs).

Signed-off-by: Nelson Spence <nelson@projectnavi.ai>
---
 CHANGELOG.md                                  |   15 +
 Cargo.lock                                    |  538 ++++++-
 Cargo.toml                                    |    3 +-
 Makefile                                      |  278 ++--
 README.md                                     |  167 ++-
 benchmarks/beir-bench/Cargo.toml              |   28 +
 benchmarks/beir-bench/src/main.rs             | 1327 +++++++++++++++++
 benchmarks/beir/beir_baselines.py             |  459 ------
 benchmarks/beir/beir_eval.py                  |   19 +
 benchmarks/beir/beir_plot.py                  |  234 +++
 benchmarks/beir/beir_prepare.py               |  293 +++-
 benchmarks/beir/beir_report.py                |   13 +-
 .../beir/figures/bars_single_thread.png       |  Bin 0 -> 82096 bytes
 benchmarks/beir/figures/bars_threaded.png     |  Bin 0 -> 87751 bytes
 benchmarks/beir/figures/scaling_curve.png     |  Bin 0 -> 145541 bytes
 benchmarks/beir/requirements.txt              |   41 +-
 examples/beir_ordvec.rs                       | 1195 ---------------
 17 files changed, 2730 insertions(+), 1880 deletions(-)
 create mode 100644 benchmarks/beir-bench/Cargo.toml
 create mode 100644 benchmarks/beir-bench/src/main.rs
 delete mode 100644 benchmarks/beir/beir_baselines.py
 create mode 100644 benchmarks/beir/beir_plot.py
 create mode 100644 benchmarks/beir/figures/bars_single_thread.png
 create mode 100644 benchmarks/beir/figures/bars_threaded.png
 create mode 100644 benchmarks/beir/figures/scaling_curve.png
 delete mode 100644 examples/beir_ordvec.rs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bd5c1cc8..683b5b54 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+### Added
+
+- **Reproducible BEIR benchmark harness** (`make benchmark-beir`; dev-only,
+  excluded from the published crate). All latency is measured in a single Rust
+  process (`benchmarks/beir-bench`) — ordvec's rank/sign methods against an exact
+  inner-product baseline (`flat`, identical retrieval to FAISS `IndexFlatIP`, via
+  a pure-Rust SIMD GEMM) and a pure-Rust HNSW (`hnsw_rs`, M=32) — so the
+  comparison is apples-to-apples (same machine, batch, thread count, no
+  Python/FFI in the hot path). Covers single-query / batched / 32-thread regimes
+  and a corpus-size scaling sweep on public BEIR datasets, with the corpus
+  embedded by Harrier-Q8 (GGUF `Q8_0` via `llama-cpp-python`, CUDA). The README
+  now leads with the resulting scaling curve, latency bars, and nDCG@10 table;
+  every figure is regenerated by the harness (nothing hand-entered). Replaces the
+  previous private-arXiv real-embedding numbers in the README.
+
 ### Performance
 
 - **AVX-512 VPOPCNTDQ scan kernels now cover every `dim` (a multiple of 64), not
diff --git a/Cargo.lock b/Cargo.lock
index 235bcd8a..620b2cd2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,21 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
@@ -11,6 +26,23 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "anndists"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8396b473aa0bceed68fb32462505387ea39fa47c7029417e0a49f10592b036"
+dependencies = [
+ "anyhow",
+ "cfg-if",
+ "cpu-time",
+ "env_logger",
+ "lazy_static",
+ "log",
+ "num-traits",
+ "num_cpus",
+ "rayon",
+]
+
 [[package]]
 name = "anstream"
 version = "1.0.0"
@@ -73,6 +105,25 @@ version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 
+[[package]]
+name = "beir-bench"
+version = "0.0.0"
+dependencies = [
+ "hnsw_rs",
+ "matrixmultiply",
+ "ordvec",
+ "rayon",
+]
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "bitflags"
 version = "2.11.1"
@@ -94,6 +145,18 @@ version = "3.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
 
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+
 [[package]]
 name = "cc"
 version = "1.2.62"
@@ -110,6 +173,12 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
 [[package]]
 name = "chacha20"
 version = "0.10.0"
@@ -118,7 +187,7 @@ checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
 dependencies = [
  "cfg-if",
  "cpufeatures",
- "rand_core",
+ "rand_core 0.10.1",
 ]
 
 [[package]]
@@ -178,6 +247,16 @@ version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
 
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "memchr",
+]
+
 [[package]]
 name = "const-oid"
 version = "0.10.2"
@@ -190,6 +269,16 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
+[[package]]
+name = "cpu-time"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9e393a7668fe1fad3075085b86c781883000b4ede868f43627b34a87c8b7ded"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
 [[package]]
 name = "cpufeatures"
 version = "0.3.0"
@@ -250,6 +339,41 @@ version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
 
+[[package]]
+name = "enum-as-inner"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "env_filter"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e90c2accc4b07a8456ea0debdc2e7587bdd890680d71173a15d4ae604f6eef"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.11.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0621c04f2196ac3f488dd583365b9c09be011a4ab8b9f37248ffcc8f6198b56a"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "env_filter",
+ "jiff",
+ "log",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -326,6 +450,18 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.4.2"
@@ -334,8 +470,8 @@ checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
 dependencies = [
  "cfg-if",
  "libc",
- "r-efi",
- "rand_core",
+ "r-efi 6.0.0",
+ "rand_core 0.10.1",
  "wasip2",
  "wasip3",
 ]
@@ -346,6 +482,8 @@ version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 dependencies = [
+ "allocator-api2",
+ "equivalent",
  "foldhash 0.1.5",
 ]
 
@@ -379,12 +517,43 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
 [[package]]
 name = "hex"
 version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
+[[package]]
+name = "hnsw_rs"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43a5258f079b97bf2e8311ff9579e903c899dcbac0d9a138d62e9a066778bd07"
+dependencies = [
+ "anndists",
+ "anyhow",
+ "bincode",
+ "cfg-if",
+ "cpu-time",
+ "env_logger",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "lazy_static",
+ "log",
+ "mmap-rs",
+ "num-traits",
+ "num_cpus",
+ "parking_lot",
+ "rand 0.9.4",
+ "rayon",
+ "serde",
+]
+
 [[package]]
 name = "hybrid-array"
 version = "0.4.12"
@@ -448,6 +617,30 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
+[[package]]
+name = "jiff"
+version = "0.2.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4603d3033e49e2b0e31229fcab20a5d40089c607d975cd9c80551dc69eed9102"
+dependencies = [
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde_core",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "782d32378dddf207193ac91cefb848ad41abb58195c95168e1291227a0832b47"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "js-sys"
 version = "0.3.99"
@@ -460,6 +653,12 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
 [[package]]
 name = "leb128fmt"
 version = "0.1.0"
@@ -489,12 +688,30 @@ version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
 
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
 [[package]]
 name = "log"
 version = "0.4.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "616ec5685824bcc94416c6d4a7a446eea774a31efd7062c8480ba6fd06d7a6e5"
 
+[[package]]
+name = "mach2"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "matrixmultiply"
 version = "0.3.10"
@@ -511,6 +728,23 @@ version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
+[[package]]
+name = "mmap-rs"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ecce9d566cb9234ae3db9e249c8b55665feaaf32b0859ff1e27e310d2beb3d8"
+dependencies = [
+ "bitflags",
+ "combine",
+ "libc",
+ "mach2",
+ "nix",
+ "sysctl",
+ "thiserror 2.0.18",
+ "widestring",
+ "windows",
+]
+
 [[package]]
 name = "ndarray"
 version = "0.17.2"
@@ -526,6 +760,18 @@ dependencies = [
  "rawpointer",
 ]
 
+[[package]]
+name = "nix"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
 [[package]]
 name = "num-complex"
 version = "0.4.6"
@@ -553,6 +799,16 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "num_cpus"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
 [[package]]
 name = "numpy"
 version = "0.29.0"
@@ -585,8 +841,8 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 name = "ordvec"
 version = "0.5.0"
 dependencies = [
- "rand",
- "rand_chacha",
+ "rand 0.10.1",
+ "rand_chacha 0.10.0",
  "rayon",
 ]
 
@@ -632,6 +888,29 @@ dependencies = [
  "pyo3",
 ]
 
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
 [[package]]
 name = "pin-project-lite"
 version = "0.2.17"
@@ -753,12 +1032,28 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
 [[package]]
 name = "r-efi"
 version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
+[[package]]
+name = "rand"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.5",
+]
+
 [[package]]
 name = "rand"
 version = "0.10.1"
@@ -766,8 +1061,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"
 dependencies = [
  "chacha20",
- "getrandom",
- "rand_core",
+ "getrandom 0.4.2",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -777,7 +1082,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3e6af7f3e25ded52c41df4e0b1af2d047e45896c2f3281792ed68a1c243daedb"
 dependencies = [
  "ppv-lite86",
- "rand_core",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
 ]
 
 [[package]]
@@ -812,6 +1126,44 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1292b7759ae1cb9ec195452d1390a074f0cd8541ab7a5a8c31cd6db45d4a6ba"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
+
 [[package]]
 name = "rsqlite-vfs"
 version = "0.1.1"
@@ -819,7 +1171,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c51c9ae4df8a7fba42103df5c621fa3c37eccf3a3c650879e90fc48b11cc192c"
 dependencies = [
  "hashbrown 0.16.1",
- "thiserror",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
@@ -862,6 +1214,21 @@ version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
 [[package]]
 name = "semver"
 version = "1.0.28"
@@ -969,6 +1336,20 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "sysctl"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01198a2debb237c62b6826ec7081082d951f46dbb64b0e8c7649a452230d1dfc"
+dependencies = [
+ "bitflags",
+ "byteorder",
+ "enum-as-inner",
+ "libc",
+ "thiserror 1.0.69",
+ "walkdir",
+]
+
 [[package]]
 name = "target-lexicon"
 version = "0.13.5"
@@ -982,19 +1363,39 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
  "fastrand",
- "getrandom",
+ "getrandom 0.4.2",
  "once_cell",
  "rustix",
  "windows-sys",
 ]
 
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
 [[package]]
 name = "thiserror"
 version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 2.0.18",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]
@@ -1038,7 +1439,7 @@ version = "1.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d258b83ceec21034727ecee8c382cfa6c3e133699b0742c64571814fb420c9f7"
 dependencies = [
- "getrandom",
+ "getrandom 0.4.2",
  "js-sys",
  "wasm-bindgen",
 ]
@@ -1049,6 +1450,16 @@ version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
 [[package]]
 name = "wasip2"
 version = "1.0.3+wasi-0.2.9"
@@ -1146,6 +1557,52 @@ dependencies = [
  "semver",
 ]
 
+[[package]]
+name = "widestring"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f"
+dependencies = [
+ "windows-targets",
+]
+
 [[package]]
 name = "windows-core"
 version = "0.62.2"
@@ -1214,6 +1671,63 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
 [[package]]
 name = "wit-bindgen"
 version = "0.51.0"
diff --git a/Cargo.toml b/Cargo.toml
index 3a63ad89..f4520c95 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,6 +21,7 @@ exclude = [
     ".github/",
     ".gitignore",
     ".playwright-mcp/",
+    "benchmarks/",
     "CLAUDE.md",
     "CODE_OF_CONDUCT.md",
     "CONTRIBUTING.md",
@@ -92,7 +93,7 @@ opt-level = 3
 # `Cargo.lock` carries their transitive dependencies.
 [workspace]
 resolver = "2"
-members = ["ordvec-python", "ordvec-ffi", "ordvec-manifest", "ordvec-manifest-python"]
+members = ["ordvec-python", "ordvec-ffi", "ordvec-manifest", "ordvec-manifest-python", "benchmarks/beir-bench"]
 default-members = ["."]
 # fuzz/ is a cargo-fuzz crate built only via `cargo +nightly fuzz`. Keep it out of
 # the workspace so it stays a standalone crate (its own Cargo.lock) and `cargo fuzz`
diff --git a/Makefile b/Makefile
index c6208cf8..4b2e1f22 100644
--- a/Makefile
+++ b/Makefile
@@ -1,176 +1,194 @@
 # ordvec-beir benchmark harness
-# Reproduces nDCG@10 on standard BEIR datasets using ordvec's rank/sign retrieval
-# methods plus FAISS FlatIP + HNSW dense baselines (for comparison, NOT ground truth).
+#
+# Reproduces, on a fresh CUDA machine, the ordvec retrieval story on standard
+# BEIR datasets:
+#   * quality  — nDCG@10 vs the official BEIR qrels, ordvec vs an exact
+#                full-float baseline (`flat`, == FAISS IndexFlatIP math).
+#   * scaling  — speedup-vs-corpus-size: brute force is O(n), ordvec sign/rank
+#                candidate-gen is near-flat in n, so the gap widens with scale.
+#   * graphics — three README figures (scaling curve + single-thread & threaded
+#                latency bars).
+#
+# ALL latency is measured in ONE Rust process (`beir-bench`): ordvec vs an exact
+# inner-product baseline vs a pure-Rust HNSW — same machine, batch, and thread
+# count, no Python/FFI boundary. Python only embeds (GGUF Q8 via llama-cpp-python),
+# scores nDCG, and renders the figures.
 #
 # Usage:
-#   make bench-beir-setup          # install Python deps
-#   make benchmark-beir-smoke      # quick sanity run (scifact only)
-#   make benchmark-beir            # full suite
+#   make bench-beir-setup        # install Python deps + CUDA llama-cpp-python
+#   make benchmark-beir-smoke    # quick end-to-end sanity (scifact only)
+#   make benchmark-beir          # full: quality + scaling + graphics
 
 # ── interpreter ──────────────────────────────────────────────────────────────
 PY ?= python3
 
 # ── paths ─────────────────────────────────────────────────────────────────────
-CACHE_DIR  := .cache/ordvec-beir
+CACHE_DIR   := .cache/ordvec-beir
 RESULTS_DIR := results/beir
+FIG_DIR     := $(RESULTS_DIR)/figures
+
+# ── datasets ──────────────────────────────────────────────────────────────────
+# Quality (nDCG) datasets. PERF_DATASET drives the scaling curve + latency bars
+# and must be large enough for the curve to bend (trec-covid ≈ 171K docs).
+QUALITY_DATASETS := scifact
+PERF_DATASET     := trec-covid
+SPLIT            := test
 
-# ── dataset suite ─────────────────────────────────────────────────────────────
-DATASETS       := scifact nfcorpus fiqa trec-covid
-SMOKE_DATASETS := scifact
-SPLIT          := test
+# Smoke overrides (scifact is small + already cheap to embed).
+SMOKE_QUALITY      := scifact
+SMOKE_PERF_DATASET := scifact
+SMOKE_SCALE_SIZES  := 500 1000 2000
 
 # ── retrieval parameters ─────────────────────────────────────────────────────
 TOPK       := 100
 K_VALUES   := 10 100
-BATCH      := 8
+BATCH      := 32
 CANDIDATES := 500
 SEED       := 1
-
-# ── encoder ───────────────────────────────────────────────────────────────────
-ENCODER_PROVIDER  := st
-HARRIER_MODEL     := microsoft/harrier-oss-v1-0.6b
-HARRIER_REVISION  :=
-DEVICE            := cuda
+NPROC      := $(shell nproc 2>/dev/null || echo 8)
+# Batch regimes for the graphics: the scaling curve + single-thread bar use
+# single-query (batch=1) — the latency-sensitive deployment where flat is
+# memory-bound and ordvec wins ~100×; the threaded bar uses a batched throughput
+# regime where flat amortizes its corpus stream across the batch.
+SCALE_BATCH := 1
+MULTI_BATCH := 32
+
+# Corpus-size ladder for the scaling sweep (clamped to the real corpus size by
+# the bench). Full-corpus points are added by the dedicated full runs.
+SCALE_SIZES := 1000 3000 10000 30000 100000 170000
+
+# ── methods (all measured in the single Rust process) ─────────────────────────
+#   flat       exact inner product (== FAISS IndexFlatIP math), 4096 B/vec
+#   hnsw       pure-Rust HNSW M=32 (Malkov–Yashunin), 4096 B/vec
+#   rq2/rq4    ordvec RankQuant b=2 / b=4 (256 / 512 B/vec)
+#   bitmap-rq2 ordvec Bitmap → RankQuant b=2 (two-stage)
+#   sign-rq2   ordvec SignBitmap → RankQuant b=2 (two-stage)
+BENCH_METHODS := flat,hnsw,rq2,rq4,bitmap-rq2,sign-rq2
+
+# ── encoder (canonical: GGUF Q8_0 via llama-cpp-python / CUDA) ────────────────
+HARRIER_GGUF_REPO := mradermacher/harrier-oss-v1-0.6b-GGUF
+GGUF_FILE         := *Q8_0.gguf
+N_GPU_LAYERS      := -1
+N_CTX             := 2048
 ENCODE_BATCH      := 16
-
-# ── ollama lane ───────────────────────────────────────────────────────────────
-OLLAMA_URL          := http://localhost:11434
-HARRIER_GGUF_MODEL  := hf.co/mradermacher/harrier-oss-v1-0.6b-GGUF:Q8_0
-
-# ── baselines + ordvec methods ────────────────────────────────────────────────
-ORDVEC_METHODS    := rq2,rq4,bitmap-rq2,sign-rq2
-BASELINE_METHODS  := faiss-flat,hnswlib
-HNSW_M            := 32
-HNSW_EF_CONSTRUCT := 200
-HNSW_EF_SEARCH    := 128
+# CUDA build flags for llama-cpp-python (override LLAMA_CMAKE_ARGS= for CPU).
+LLAMA_CMAKE_ARGS  := -DGGML_CUDA=on
 
 # ── phony ─────────────────────────────────────────────────────────────────────
-.PHONY: benchmark-beir benchmark-beir-smoke benchmark-beir-bm25 \
-        bench-beir-setup bench-beir-prepare bench-beir-prepare-ollama \
-        bench-beir-ordvec bench-beir-baselines bench-beir-eval \
-        bench-beir-guardrail bench-beir-clean bench-beir-clean-cache
+.PHONY: benchmark-beir benchmark-beir-smoke bench-beir-setup bench-beir-build \
+        bench-beir-guardrail bench-beir-quality bench-beir-scaling \
+        bench-beir-plot bench-beir-clean bench-beir-clean-cache
+
+# The pipeline is strictly sequential (prepare writes the cache the bench reads;
+# eval/plot read run files). Steps are unordered prerequisites, so under a
+# parallel make (-j, or an inherited MAKEFLAGS=-jN) they would race on a
+# half-written cache. Force serial execution regardless.
+.NOTPARALLEL:
 
 # ── top-level targets ─────────────────────────────────────────────────────────
 
-## Full benchmark run (guardrail → prepare → ordvec → baselines → eval)
-benchmark-beir: bench-beir-guardrail bench-beir-prepare bench-beir-ordvec bench-beir-baselines bench-beir-eval
+## Full run: quality (nDCG) + scaling sweep + three README graphics.
+benchmark-beir: bench-beir-guardrail bench-beir-quality bench-beir-scaling bench-beir-plot
 
-## Smoke run: scifact only, quick sanity check
+## Quick end-to-end sanity: everything on scifact, tiny scaling ladder.
 benchmark-beir-smoke:
-	$(MAKE) benchmark-beir \
-		DATASETS=$(SMOKE_DATASETS) \
-		TOPK=100 \
-		ENCODE_BATCH=8
-
-## Optional BM25 lane (placeholder — requires beir[bm25] extras)
-benchmark-beir-bm25:
-	@echo "BM25 lane: install beir[bm25] extras then run:"
-	@echo "  $(PY) benchmarks/beir/beir_baselines.py --methods bm25 \\"
-	@echo "      --datasets $(DATASETS) --split $(SPLIT) \\"
-	@echo "      --cache-dir $(CACHE_DIR) --out-dir $(RESULTS_DIR) --top-k $(TOPK)"
+	$(MAKE) bench-beir-guardrail
+	$(MAKE) bench-beir-quality QUALITY_DATASETS="$(SMOKE_QUALITY)"
+	$(MAKE) bench-beir-scaling PERF_DATASET=$(SMOKE_PERF_DATASET) SCALE_SIZES="$(SMOKE_SCALE_SIZES)"
+	$(MAKE) bench-beir-plot PERF_DATASET=$(SMOKE_PERF_DATASET)
 
 # ── setup ─────────────────────────────────────────────────────────────────────
 
-## Install Python benchmark dependencies
+## Install Python deps (core wheels) + CUDA llama-cpp-python. The latter is built
+## against the host CUDA toolkit; --no-cache-dir + --force-reinstall defeat pip's
+## wheel cache (it ignores CMAKE_ARGS and would hand back a stale CPU build).
+## CPU-only box: make bench-beir-setup LLAMA_CMAKE_ARGS=
 bench-beir-setup:
 	$(PY) -m pip install -r benchmarks/beir/requirements.txt
+	CMAKE_ARGS="$(LLAMA_CMAKE_ARGS)" $(PY) -m pip install \
+		--upgrade --force-reinstall --no-cache-dir llama-cpp-python
+
+## Build the all-Rust comparison harness (release).
+bench-beir-build:
+	cargo build --release -p beir-bench
 
 # ── guardrail ─────────────────────────────────────────────────────────────────
 
-## Fail loudly if any harness file imports the ordvec Python package directly.
-## The harness is an EXTERNAL consumer — it must use the Rust crate at bench time,
-## not the ordvec Python package. That coupling breaks the reproducibility claim.
+## Fail loudly if any harness *.py imports the ordvec Python package directly —
+## the benchmark hot path is the Rust crate, not the Python bindings.
 bench-beir-guardrail:
-	@if grep -R "import ordvec" benchmarks/beir 2>/dev/null; then \
-		echo ""; \
-		echo "ERROR: benchmarks/beir/ must not contain 'import ordvec'."; \
-		echo "The benchmark hot path is the Rust crate, not the ordvec Python package."; \
+	@if grep -rnE "^[[:space:]]*(import ordvec|from ordvec)\b" benchmarks/beir --include='*.py' 2>/dev/null; then \
+		echo "ERROR: a benchmarks/beir/*.py file imports the ordvec Python package."; \
 		exit 1; \
 	fi
-	@echo "guardrail OK: no 'import ordvec' found in benchmarks/beir/"
-
-# ── prepare ───────────────────────────────────────────────────────────────────
-
-## Download datasets and encode with Harrier (sentence-transformers / CUDA lane)
-bench-beir-prepare:
-	$(PY) benchmarks/beir/beir_prepare.py \
-		--datasets $(DATASETS) \
-		--split $(SPLIT) \
-		--provider $(ENCODER_PROVIDER) \
-		--model "$(HARRIER_MODEL)" \
-		$(if $(HARRIER_REVISION),--revision $(HARRIER_REVISION),) \
-		--device "$(DEVICE)" \
-		--batch-size $(ENCODE_BATCH) \
-		--cache-dir "$(CACHE_DIR)" \
-		--seed $(SEED)
-
-## Encode with Harrier via Ollama (CPU/quantised lane — no GPU required)
-bench-beir-prepare-ollama:
-	$(PY) benchmarks/beir/beir_prepare.py \
-		--datasets $(DATASETS) \
-		--split $(SPLIT) \
-		--provider ollama \
-		--ollama-url "$(OLLAMA_URL)" \
-		--model "$(HARRIER_GGUF_MODEL)" \
-		--batch-size $(ENCODE_BATCH) \
-		--cache-dir "$(CACHE_DIR)" \
-		--seed $(SEED)
-
-# ── ordvec retrieval ──────────────────────────────────────────────────────────
-
-## Build the Rust beir_ordvec example binary and run all ordvec methods
-bench-beir-ordvec:
-	cargo build --release --example beir_ordvec
-	@for dataset in $(DATASETS); do \
-		$(CURDIR)/target/release/examples/beir_ordvec \
-			--cache-dir "$(CACHE_DIR)" \
-			--dataset "$$dataset" \
-			--split $(SPLIT) \
-			--top-k $(TOPK) \
-			--batch $(BATCH) \
-			--candidates $(CANDIDATES) \
-			--methods $(ORDVEC_METHODS) \
-			--out-dir "$(RESULTS_DIR)"; \
+	@echo "guardrail OK: no 'import ordvec' in benchmarks/beir/*.py"
+
+# ── quality: nDCG@10 vs qrels (ordvec vs exact flat) ──────────────────────────
+
+## Embed → run all methods (single-thread, full corpus) → score nDCG, per dataset.
+bench-beir-quality: bench-beir-build
+	@for d in $(QUALITY_DATASETS); do \
+		echo "=== quality: $$d ==="; \
+		$(PY) benchmarks/beir/beir_prepare.py --datasets $$d --split $(SPLIT) \
+			--provider llamacpp --model "$(HARRIER_GGUF_REPO)" --gguf-file "$(GGUF_FILE)" \
+			--n-gpu-layers $(N_GPU_LAYERS) --n-ctx $(N_CTX) --batch-size $(ENCODE_BATCH) \
+			--cache-dir "$(CACHE_DIR)" --seed $(SEED) || exit 1; \
+		$(CURDIR)/target/release/beir-bench --cache-dir "$(CACHE_DIR)" --dataset $$d \
+			--split $(SPLIT) --top-k $(TOPK) --batch $(BATCH) --candidates $(CANDIDATES) \
+			--threads 1 --methods $(BENCH_METHODS) --out-dir "$(RESULTS_DIR)" || exit 1; \
+		$(PY) benchmarks/beir/beir_eval.py --datasets $$d --split $(SPLIT) \
+			--cache-dir "$(CACHE_DIR)" --runs-dir "$(RESULTS_DIR)" --k-values $(K_VALUES) \
+			--baseline flat --bootstrap-iters 1000 --seed $(SEED) --out-dir "$(RESULTS_DIR)" || exit 1; \
 	done
 
-# ── native dense baselines ────────────────────────────────────────────────────
-
-## Run FAISS FlatIP + HNSW dense baselines (comparison references, NOT ground truth)
-bench-beir-baselines:
-	$(PY) benchmarks/beir/beir_baselines.py \
-		--datasets $(DATASETS) \
-		--split $(SPLIT) \
-		--cache-dir "$(CACHE_DIR)" \
-		--out-dir "$(RESULTS_DIR)" \
-		--top-k $(TOPK) \
-		--methods $(BASELINE_METHODS) \
-		--hnsw-m $(HNSW_M) \
-		--hnsw-ef-construction $(HNSW_EF_CONSTRUCT) \
-		--hnsw-ef-search $(HNSW_EF_SEARCH) \
-		--seed $(SEED)
-
-# ── evaluation ────────────────────────────────────────────────────────────────
-
-## Evaluate nDCG@10 etc. vs BEIR qrels + paired bootstrap deltas vs FAISS
-bench-beir-eval:
-	$(PY) benchmarks/beir/beir_eval.py \
-		--datasets $(DATASETS) \
-		--split $(SPLIT) \
-		--cache-dir "$(CACHE_DIR)" \
-		--runs-dir "$(RESULTS_DIR)" \
-		--k-values $(K_VALUES) \
-		--baseline faiss-flat \
-		--bootstrap-iters 1000 \
-		--seed $(SEED) \
-		--out-dir "$(RESULTS_DIR)"
+# ── scaling: speedup-vs-corpus-size + single/threaded full-corpus points ───────
+
+## Sweep the perf dataset over a corpus-size ladder (single-thread), then full
+## corpus at 1 thread and at $(NPROC) threads. All append to timing.jsonl.
+bench-beir-scaling: bench-beir-build
+	@echo "=== scaling: $(PERF_DATASET) (sizes: $(SCALE_SIZES); threaded full = $(NPROC)t) ==="
+	$(PY) benchmarks/beir/beir_prepare.py --datasets $(PERF_DATASET) --split $(SPLIT) \
+		--provider llamacpp --model "$(HARRIER_GGUF_REPO)" --gguf-file "$(GGUF_FILE)" \
+		--n-gpu-layers $(N_GPU_LAYERS) --n-ctx $(N_CTX) --batch-size $(ENCODE_BATCH) \
+		--cache-dir "$(CACHE_DIR)" --seed $(SEED)
+	rm -f "$(RESULTS_DIR)/$(PERF_DATASET)/timing.jsonl"
+	@for n in $(SCALE_SIZES); do \
+		echo "  -- n=$$n (1 thread, single-query batch=$(SCALE_BATCH)) --"; \
+		$(CURDIR)/target/release/beir-bench --cache-dir "$(CACHE_DIR)" --dataset $(PERF_DATASET) \
+			--split $(SPLIT) --top-k $(TOPK) --batch $(SCALE_BATCH) --candidates $(CANDIDATES) \
+			--threads 1 --max-docs $$n --methods $(BENCH_METHODS) --out-dir "$(RESULTS_DIR)" || exit 1; \
+	done
+	@echo "  -- full corpus (1 thread, single-query batch=$(SCALE_BATCH); writes topk + nDCG inputs) --"
+	$(CURDIR)/target/release/beir-bench --cache-dir "$(CACHE_DIR)" --dataset $(PERF_DATASET) \
+		--split $(SPLIT) --top-k $(TOPK) --batch $(SCALE_BATCH) --candidates $(CANDIDATES) \
+		--threads 1 --methods $(BENCH_METHODS) --out-dir "$(RESULTS_DIR)"
+	@echo "  -- full corpus ($(NPROC) threads, batched batch=$(MULTI_BATCH)) --"
+	$(CURDIR)/target/release/beir-bench --cache-dir "$(CACHE_DIR)" --dataset $(PERF_DATASET) \
+		--split $(SPLIT) --top-k $(TOPK) --batch $(MULTI_BATCH) --candidates $(CANDIDATES) \
+		--threads $(NPROC) --methods $(BENCH_METHODS) --out-dir "$(RESULTS_DIR)"
+	$(PY) benchmarks/beir/beir_eval.py --datasets $(PERF_DATASET) --split $(SPLIT) \
+		--cache-dir "$(CACHE_DIR)" --runs-dir "$(RESULTS_DIR)" --k-values $(K_VALUES) \
+		--baseline flat --bootstrap-iters 1000 --seed $(SEED) --out-dir "$(RESULTS_DIR)"
+
+# ── graphics ──────────────────────────────────────────────────────────────────
+
+## Render the three README figures from the timing records.
+bench-beir-plot:
+	$(PY) benchmarks/beir/beir_plot.py --runs-dir "$(RESULTS_DIR)" \
+		--scaling-dataset $(PERF_DATASET) --bar-dataset $(PERF_DATASET) \
+		--scaling-threads 1 --scaling-batch $(SCALE_BATCH) \
+		--bar-single-threads 1 --bar-single-batch $(SCALE_BATCH) \
+		--bar-multi-threads $(NPROC) --bar-multi-batch $(MULTI_BATCH) \
+		--out-dir "$(FIG_DIR)"
 
 # ── cleanup ───────────────────────────────────────────────────────────────────
 
-## Remove generated result files (keeps cache)
+## Remove generated result files (keeps the embedding cache).
 bench-beir-clean:
 	find $(RESULTS_DIR) -name "*.topk.jsonl" -delete
 	find $(RESULTS_DIR) -name "*.summary.json" -delete
+	find $(RESULTS_DIR) -name "timing.jsonl" -delete
 
-## Remove the embedding cache (re-encoding will be required)
+## Remove the embedding cache (re-encoding will be required).
 bench-beir-clean-cache:
 	rm -rf $(CACHE_DIR)
diff --git a/README.md b/README.md
index f6d77306..9eec7d59 100644
--- a/README.md
+++ b/README.md
@@ -15,6 +15,35 @@ Training-free ordinal & sign quantization for vector retrieval.
 `ordvec` is a small, dependency-light Rust crate for compressed
 nearest-neighbour search over high-dimensional embeddings.
 
+## Benchmark at a glance
+
+On **trec-covid** (171,332 documents, the public [BEIR](https://github.com/beir-cellar/beir)
+benchmark) with **Harrier-Q8** 1024-d embeddings, ordvec's two-stage retrieval
+keeps a near-flat per-query cost as the corpus grows, while exact brute-force
+(`flat`, identical math to FAISS `IndexFlatIP`) is O(n) — so the speedup
+*widens* with scale:
+
+![ordvec speedup over exact search grows with corpus size](https://raw.githubusercontent.com/Fieldnote-Echo/ordvec/main/benchmarks/beir/figures/scaling_curve.png)
+
+- **~100× faster, single query.** At 171K docs, single-query latency: exact
+  `flat` 56 ms vs ordvec `Sign→rq2` **0.53 ms** — and the gap grows with the
+  corpus (it is ~5× at 1K docs).
+- **8–16× smaller.** 256–384 bytes/vector vs 4096 for full float, at
+  **nDCG@10 within bootstrap noise of exact** (on trec-covid the ordinal rows
+  even edge ahead; see [Benchmarks](#benchmarks)).
+- **Reproducible on your machine, one command:**
+
+  ```sh
+  make bench-beir-setup     # Python deps + CUDA llama-cpp-python (GGUF Q8 encoder)
+  make benchmark-beir       # download BEIR, embed, run all methods, render graphics
+  ```
+
+  Every number and figure above is regenerated from public BEIR data by that
+  command — nothing here is hand-entered. Latency is measured for all methods in
+  **one Rust process** (no Python/FFI in the hot path); see the
+  [Benchmarks](#benchmarks) section for the single-query, batched-throughput, and
+  threaded views and their caveats.
+
 ## What's different
 
 Compressed-retrieval libraries usually either **fit a codebook to your
@@ -241,47 +270,103 @@ candidate slices passed to `Search` until the call returns.
 
 ## Benchmarks
 
-### Real-embedding retrieval
-
-The current paper-harness run is a real-embedding source-recovery task, not the
-in-repo synthetic stress test: 207,695 arXiv paper embeddings, 7,200 queries
-across title / first-sentence / middle-sentence / paraphrase query sets, 1024-D
-sentence-transformer embeddings, and `nDCG@10` / `hit@10` / `MRR@10` against the
-source paper id.
-
-The baseline rows use FAISS over L2-normalized FP32 embeddings:
-`IndexFlatIP` for dense exact search and `IndexHNSWFlat(M=32, efSearch=128)` for
-the tested HNSW configuration. The ordinal rows remove stored dense coordinate
-magnitudes:
-
-- **ordinal rank-cosine** stores mean-centered, L2-normalized
-  `argsort(argsort(.))` rank vectors and queries with the same rank-cosine
-  representation; and
-- **RankQuant b=2 asym** stores 2-bit ordinal document codes
-  (`256 bytes/vector` at dim=1024) and scores FP32 queries with
-  `RankQuant::search_asymmetric`.
-
-| Mode | bytes/vec | nDCG@10 | hit@10 | MRR@10 |
-|------|----------:|--------:|-------:|-------:|
-| FAISS dense exact | 4096 | 0.7817 | 0.8604 | 0.7566 |
-| ordinal rank-cosine | 4096 | 0.7796 | 0.8596 | 0.7542 |
-| FAISS HNSW | ~4352 | 0.7756 | 0.8528 | 0.7509 |
-| RankQuant b=2 asym | 256 | 0.7754 | 0.8536 | 0.7506 |
-
-Paired bootstrap over all 7,200 queries:
-
-- ordinal rank-cosine minus FAISS HNSW: `+0.00406 nDCG@10`, 95% CI
-  `[+0.00133, +0.00687]`
-- ordinal rank-cosine minus FAISS dense exact: `-0.00205 nDCG@10`, 95% CI
-  `[-0.00429, +0.00019]`
-- RankQuant b=2 asym minus FAISS HNSW: `-0.00014 nDCG@10`, 95% CI
-  `[-0.00318, +0.00292]`
-
-Read narrowly: on this real retrieval task, ordinal structure retains nearly all
-of the dense retrieval signal, and the 2-bit deployed path matches the tested
-FAISS HNSW configuration within bootstrap noise at 1/16 the FP32 vector payload.
-The arXiv artifact set is not shipped in this crate; the self-contained
-clean-checkout benchmark below is the reproducible stress test.
+### BEIR retrieval (public datasets, reproducible)
+
+A fully reproducible harness over standard [BEIR](https://github.com/beir-cellar/beir)
+datasets lives in [`benchmarks/beir/`](benchmarks/beir). It embeds the corpus
+with **Harrier-Q8** (GGUF `Q8_0` via `llama-cpp-python`, CUDA), then measures
+ordvec's methods against two references **in a single Rust process** so the
+latency comparison is genuinely apples-to-apples — same machine, batch, and
+thread count, no Python/FFI in the hot path:
+
+- **`flat`** — exact inner-product brute force (identical retrieval to FAISS
+  `IndexFlatIP`), a pure-Rust SIMD GEMM. *Baseline, not ground truth.*
+- **`hnsw`** — pure-Rust HNSW (`hnsw_rs`, M=32, ef=128) — the portable
+  stand-in for the C++ hnswlib.
+
+Reproduce end-to-end (downloads the data, embeds, runs every method, renders the
+figures) — nothing below is hand-entered:
+
+```sh
+make bench-beir-setup      # Python deps + CUDA llama-cpp-python
+make benchmark-beir        # quality (nDCG) + scaling sweep + graphics
+```
+
+#### Quality — nDCG@10 vs the official BEIR qrels
+
+nDCG@10 is computed against the human-annotated qrels (not against `flat`).
+`Δ vs flat` is the paired-bootstrap mean delta; `*` marks a 95% CI that straddles
+0 (i.e. within noise of exact).
+
+| Dataset | Method | Bytes/vec | nDCG@10 | Δ vs flat (95% CI) |
+|---|---|--:|--:|---|
+| scifact (5,183) | `flat` (exact) | 4096 | 0.7551 | (baseline) |
+| | `hnsw` M=32 | 4096 | 0.7554 | +0.0003 * |
+| | **ordvec rq4** | **512** | **0.7549** | −0.0003 * |
+| | ordvec rq2 | 256 | 0.7471 | −0.0080 * |
+| | ordvec sign→rq2 | 384 | 0.7471 | −0.0080 * |
+| trec-covid (171,332) | `flat` (exact) | 4096 | 0.7574 | (baseline) |
+| | `hnsw` M=32 | 4096 | 0.7555 | −0.0019 * |
+| | ordvec rq2 | 256 | 0.7632 | +0.0057 * |
+| | **ordvec rq4** | **512** | **0.7636** | +0.0062 * |
+| | ordvec sign→rq2 | 384 | 0.7638 | +0.0064 * |
+
+Every ordvec row is within bootstrap noise of exact dense at **8–16× smaller**
+storage; on trec-covid the ordinal codes even edge slightly ahead.
+
+#### Latency — three honest views
+
+ordvec never touches the float corpus, so its per-query cost is tiny and grows
+slowly with `n`; `flat`'s cost is dominated by streaming the 4096-byte vectors,
+which is O(n) and **memory-bandwidth-bound**. That single fact explains all three
+views (trec-covid, 171,332 docs, 1024-d):
+
+**1. Single query (batch = 1, 1 thread)** — latency-sensitive serving, where
+`flat` cannot amortize its memory traffic:
+
+![single-query latency bars](https://raw.githubusercontent.com/Fieldnote-Echo/ordvec/main/benchmarks/beir/figures/bars_single_thread.png)
+
+`flat` 56 ms → ordvec `sign→rq2` **0.53 ms (≈106×)**, `bitmap→rq2` 0.62 ms (≈91×),
+`hnsw` 1.5 ms (37×). The scaling curve [above](#benchmark-at-a-glance) is this
+view swept over corpus size — the speedup *grows* with `n`.
+
+**2. Batched throughput (batch = 32, 1 thread)** — when many queries arrive at
+once, `flat`'s GEMM amortizes the corpus stream across the batch (56→4 ms),
+narrowing the gap: ordvec `sign→rq2`/`bitmap→rq2` stay ≈8–9.5× ahead.
+
+**3. Many cores (batch = 32, 32 threads)** — everything parallelizes and the
+field compresses; `hnsw` threads best:
+
+![threaded throughput bars](https://raw.githubusercontent.com/Fieldnote-Echo/ordvec/main/benchmarks/beir/figures/bars_threaded.png)
+
+`hnsw` 4.8× vs `flat`, ordvec `bitmap→rq2` 3.7×, `rq2` 2.5×, `sign→rq2` 2.1×.
+**HNSW wins this regime** — by a hair on threaded throughput. The honest
+ordvec-vs-HNSW tradeoff, all from this same run (trec-covid, 171,332 docs):
+
+| | HNSW M=32 | ordvec `sign→rq2` |
+|---|---|---|
+| threaded latency (32 threads, batch 32) | **0.23 ms** ✅ | 0.52 ms |
+| single-query latency (batch 1) | 1.52 ms | **0.53 ms** ✅ (~3×) |
+| index size / vector | 4096 B + graph | **256–384 B** ✅ (8–16× less) |
+| build time, 171K docs | **51.4 s** | **0.26 s** ✅ (training-free) |
+| nDCG@10 (trec-covid) | 0.7555 | **0.7638** ✅ |
+
+So even where HNSW edges ahead on threaded latency, ordvec gets there with **no
+graph to build** (instant, training-free, and rebuilt for free when the corpus
+drifts) and **8–16× less memory** — and it still wins single-query latency and
+ties or edges quality. And the two aren't mutually exclusive: ordvec's codes are
+index-agnostic, so they compose *under* an HNSW/sharding layer (see
+[Scope](#scope)) rather than replacing it.
+
+**Read it honestly:** ordvec's huge latency win is a single-query / low-batch
+phenomenon (and grows with corpus size); under large-batch throughput a batched
+exact GEMM is a strong baseline and HNSW threads very well. The durable wins are
+**compression at iso-quality** and **single-query latency that stays flat as the
+corpus grows**. `flat` is a comparison reference, not ground truth; nDCG@10 is
+the qrel-based metric. Numbers vary with encoder, dataset, hardware, and batch —
+the point is that you can regenerate all of them with `make benchmark-beir`.
+
+### Synthetic stress test
 
 ### Synthetic stress test
 
diff --git a/benchmarks/beir-bench/Cargo.toml b/benchmarks/beir-bench/Cargo.toml
new file mode 100644
index 00000000..13179614
--- /dev/null
+++ b/benchmarks/beir-bench/Cargo.toml
@@ -0,0 +1,28 @@
+# All-Rust BEIR comparison harness. Lives as a workspace member (NOT in the core
+# `ordvec` crate's dependencies) so that pulling `hnsw_rs` here never touches the
+# `-p ordvec`-scoped deps gate or the published crate. `publish = false`.
+[package]
+name = "beir-bench"
+version = "0.0.0"
+edition = "2021"
+publish = false
+license = "MIT OR Apache-2.0"
+
+[[bin]]
+name = "beir-bench"
+path = "src/main.rs"
+
+[dependencies]
+ordvec = { path = "../.." }
+# Pure-Rust HNSW (Malkov–Yashunin); no system/C++ deps. The faithful portable
+# stand-in for the C++ hnswlib (no maintained Rust binding to that exists).
+hnsw_rs = "0.3"
+rayon = "1.10"
+# Pure-Rust SIMD GEMM (runtime AVX/NEON dispatch, no BLAS/system deps) — gives
+# the exact-inner-product `flat` baseline a competitive kernel so it isn't
+# unfairly slow vs ordvec's SIMD paths. Default single-threaded (our rayon pool
+# owns parallelism); we never enable its `threading` feature.
+matrixmultiply = "0.3"
+
+# Release profile is inherited from the workspace root (lto, codegen-units=1,
+# opt-level=3); a member-level [profile] would be ignored with a warning.
diff --git a/benchmarks/beir-bench/src/main.rs b/benchmarks/beir-bench/src/main.rs
new file mode 100644
index 00000000..cbfac093
--- /dev/null
+++ b/benchmarks/beir-bench/src/main.rs
@@ -0,0 +1,1327 @@
+//! All-Rust BEIR comparison harness.
+//!
+//! Measures ordvec's rank/sign methods against an exact inner-product baseline
+//! (`flat`, identical math to FAISS `IndexFlatIP`) and a pure-Rust HNSW
+//! (`hnsw_rs`, Malkov–Yashunin — the faithful portable stand-in for C++ hnswlib),
+//! ALL in one process so the latency comparison is genuinely apples-to-apples:
+//! same machine, same batch, same thread count, no Python/FFI boundary.
+//!
+//! Two knobs make the comparison fair and reveal the scaling story:
+//!
+//! `--threads N`: query latency is measured inside a rayon pool of exactly N
+//! threads (index *build* still uses all cores). N=1 gives the single-thread
+//! story; N>1 the throughput story. Batch is matched across every method.
+//!
+//! `--max-docs M`: truncate the corpus to its first M vectors. Sweeping M
+//! produces the speedup-vs-corpus-size curve (brute force is O(n); ordvec
+//! sign/rank candidate-gen is near-flat in n).
+//!
+//! Output: `<out>/<dataset>/timing.jsonl` gets one record per
+//! (method, n_docs, threads) run, appended every invocation — the plotter
+//! consumes this. A FULL-corpus run (`--max-docs` absent) additionally writes
+//! `<method>.topk.jsonl` + `<method>.summary.json` for offline nDCG eval;
+//! sub-sampled runs skip those (qrels-based nDCG is only valid on the full
+//! corpus).
+//!
+//! Cache layout (one encoder per prepare run):
+//!   <cache-dir>/<dataset>/<split>/encoder=<slug>/
+//!     corpus.f32.npy  queries.f32.npy  corpus_ids.json  query_ids.json
+//!     qrels.json  embeddings.manifest.json  ...
+
+use ordvec::{Bitmap, CandidateBatch, RankQuant, SignBitmap, SubsetScratch};
+use rayon::prelude::*;
+use std::io::{BufWriter, Write};
+use std::time::Instant;
+
+use hnsw_rs::prelude::*;
+
+// HNSW hyper-parameters (faithful to the prior "hnswlib M=32" comparison).
+const HNSW_M: usize = 32;
+const HNSW_EF_CONSTRUCTION: usize = 200;
+const HNSW_EF_SEARCH: usize = 128;
+const HNSW_MAX_LAYER: usize = 16;
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+
+struct Config {
+    cache_dir: String,
+    dataset: String,
+    split: String,
+    top_k: usize,
+    batch: usize,
+    candidates: usize,
+    methods: Vec<String>,
+    out_dir: String,
+    threads: usize,          // 0 = all cores
+    max_docs: Option<usize>, // None = full corpus
+}
+
+fn parse_args() -> Config {
+    let mut cache_dir = String::from(".cache/ordvec-beir");
+    let mut dataset = String::new();
+    let mut split = String::from("test");
+    let mut top_k = 100usize;
+    let mut batch = 8usize;
+    let mut candidates = 500usize;
+    let mut methods = vec![
+        "flat".to_string(),
+        "hnsw".to_string(),
+        "rq2".to_string(),
+        "rq4".to_string(),
+        "bitmap-rq2".to_string(),
+        "sign-rq2".to_string(),
+    ];
+    let mut out_dir = String::from("results/beir");
+    let mut threads = 0usize;
+    let mut max_docs: Option<usize> = None;
+
+    let mut args = std::env::args().skip(1);
+    while let Some(a) = args.next() {
+        match a.as_str() {
+            "--cache-dir" => cache_dir = args.next().expect("--cache-dir requires a value"),
+            "--dataset" => dataset = args.next().expect("--dataset requires a value"),
+            "--split" => split = args.next().expect("--split requires a value"),
+            "--top-k" => {
+                top_k = args
+                    .next()
+                    .expect("--top-k requires a value")
+                    .parse()
+                    .expect("--top-k must be an integer")
+            }
+            "--batch" => {
+                batch = args
+                    .next()
+                    .expect("--batch requires a value")
+                    .parse()
+                    .expect("--batch must be an integer")
+            }
+            "--candidates" => {
+                candidates = args
+                    .next()
+                    .expect("--candidates requires a value")
+                    .parse()
+                    .expect("--candidates must be an integer")
+            }
+            "--methods" => {
+                methods = args
+                    .next()
+                    .expect("--methods requires a value")
+                    .split(',')
+                    .map(|s| s.trim().to_string())
+                    .filter(|s| !s.is_empty())
+                    .collect()
+            }
+            "--out-dir" => out_dir = args.next().expect("--out-dir requires a value"),
+            "--threads" => {
+                threads = args
+                    .next()
+                    .expect("--threads requires a value")
+                    .parse()
+                    .expect("--threads must be an integer")
+            }
+            "--max-docs" => {
+                max_docs = Some(
+                    args.next()
+                        .expect("--max-docs requires a value")
+                        .parse()
+                        .expect("--max-docs must be an integer"),
+                )
+            }
+            other => panic!("unknown argument: {other}"),
+        }
+    }
+    assert!(!dataset.is_empty(), "--dataset is required");
+    assert!(batch >= 1, "--batch must be >= 1");
+    assert!(top_k >= 1, "--top-k must be >= 1");
+    assert!(candidates >= 1, "--candidates must be >= 1");
+
+    Config {
+        cache_dir,
+        dataset,
+        split,
+        top_k,
+        batch,
+        candidates,
+        methods,
+        out_dir,
+        threads,
+        max_docs,
+    }
+}
+
+// ---------------------------------------------------------------------------
+// NumPy v1/v2 reader (2-D LE f32, C-order)
+// ---------------------------------------------------------------------------
+
+fn load_npy_f32(path: &str) -> (Vec<f32>, usize, usize) {
+    let bytes = std::fs::read(path).unwrap_or_else(|e| panic!("read npy {path}: {e}"));
+    assert!(bytes.len() >= 10, "npy file too short: {path}");
+    assert_eq!(&bytes[..6], b"\x93NUMPY", "not a numpy file: {path}");
+    let major = bytes[6];
+    let minor = bytes[7];
+    assert!(
+        major == 1 || major == 2,
+        "unsupported npy version {major}.{minor}: {path}",
+    );
+    let (header_len, header_start) = if major == 1 {
+        let hl = u16::from_le_bytes([bytes[8], bytes[9]]) as usize;
+        (hl, 10)
+    } else {
+        let hl = u32::from_le_bytes([bytes[8], bytes[9], bytes[10], bytes[11]]) as usize;
+        (hl, 12)
+    };
+    let header = std::str::from_utf8(&bytes[header_start..header_start + header_len])
+        .expect("npy header not utf-8");
+    assert!(
+        header.contains("'descr': '<f4'"),
+        "expected <f4 dtype in {path}: {header}",
+    );
+    assert!(
+        header.contains("'fortran_order': False"),
+        "expected C order in {path}",
+    );
+    let shape_start = header.find("'shape':").expect("no shape in npy header");
+    let after = &header[shape_start..];
+    let open = after.find('(').unwrap();
+    let close = after.find(')').unwrap();
+    let dims: Vec<usize> = after[open + 1..close]
+        .split(',')
+        .filter_map(|s| s.trim().parse::<usize>().ok())
+        .collect();
+    assert_eq!(dims.len(), 2, "expected 2-D array in {path}");
+    let n = dims[0];
+    let dim = dims[1];
+    let data_start = header_start + header_len;
+    let n_floats = n * dim;
+    assert_eq!(
+        bytes.len() - data_start,
+        n_floats * 4,
+        "data length mismatch in {path}",
+    );
+    let mut out = vec![0.0f32; n_floats];
+    for (i, chunk) in bytes[data_start..].chunks_exact(4).enumerate() {
+        out[i] = f32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
+    }
+    (out, n, dim)
+}
+
+// ---------------------------------------------------------------------------
+// JSON helpers
+// ---------------------------------------------------------------------------
+
+fn load_json_string_array(path: &str) -> Vec<String> {
+    let text = std::fs::read_to_string(path).unwrap_or_else(|e| panic!("read {path}: {e}"));
+    let mut out = Vec::new();
+    let mut in_str = false;
+    let mut cur = String::new();
+    let mut chars = text.chars().peekable();
+    while let Some(c) = chars.next() {
+        if c == '"' {
+            if in_str {
+                out.push(cur.clone());
+                cur.clear();
+                in_str = false;
+            } else {
+                in_str = true;
+            }
+        } else if in_str {
+            if c == '\\' {
+                if let Some(next) = chars.next() {
+                    match next {
+                        '"' => cur.push('"'),
+                        '\\' => cur.push('\\'),
+                        'n' => cur.push('\n'),
+                        't' => cur.push('\t'),
+                        other => {
+                            cur.push('\\');
+                            cur.push(other);
+                        }
+                    }
+                }
+            } else {
+                cur.push(c);
+            }
+        }
+    }
+    out
+}
+
+/// sha256 of a file via system sha256sum / shasum / openssl. Panics with a clear
+/// reason; never emits a non-SHA value that merely looks like one.
+fn sha256_file(path: &str) -> String {
+    if !std::path::Path::new(path).is_file() {
+        panic!("cannot compute SHA-256: file does not exist: {path}");
+    }
+    let mut tool_ran = false;
+    for (cmd, args) in &[
+        ("sha256sum", vec![path]),
+        ("shasum", vec!["-a", "256", path]),
+        ("openssl", vec!["dgst", "-sha256", path]),
+    ] {
+        if let Ok(out) = std::process::Command::new(cmd).args(args).output() {
+            tool_ran = true;
+            if out.status.success() {
+                let s = String::from_utf8_lossy(&out.stdout);
+                for token in s.split_whitespace() {
+                    if token.len() == 64 && token.chars().all(|c| c.is_ascii_hexdigit()) {
+                        return token.to_string();
+                    }
+                }
+            }
+        }
+    }
+    if tool_ran {
+        panic!("a SHA-256 tool ran but produced no digest for {path}");
+    }
+    panic!(
+        "no SHA-256 tool available (tried sha256sum / shasum -a 256 / openssl) — \
+         cannot compute the encoder-manifest digest for {path}"
+    );
+}
+
+fn rustc_version() -> String {
+    if let Ok(out) = std::process::Command::new("rustc")
+        .arg("--version")
+        .output()
+    {
+        if out.status.success() {
+            return String::from_utf8_lossy(&out.stdout).trim().to_string();
+        }
+    }
+    "unknown".to_string()
+}
+
+fn detected_simd() -> Vec<String> {
+    #[cfg(target_arch = "x86_64")]
+    {
+        let mut v = Vec::new();
+        if is_x86_feature_detected!("avx2") {
+            v.push("avx2".to_string());
+        }
+        if is_x86_feature_detected!("fma") {
+            v.push("fma".to_string());
+        }
+        if is_x86_feature_detected!("avx512f") {
+            v.push("avx512f".to_string());
+        }
+        v
+    }
+    #[cfg(not(target_arch = "x86_64"))]
+    {
+        Vec::new()
+    }
+}
+
+fn percentile_ms(samples: &[u128], p: f32) -> f64 {
+    let mut s = samples.to_vec();
+    s.sort_unstable();
+    if s.is_empty() {
+        return 0.0;
+    }
+    let i = ((s.len() as f32 - 1.0) * p).round() as usize;
+    s[i] as f64 / 1_000_000.0
+}
+
+// ---------------------------------------------------------------------------
+// Validate embeddings (dim == 1024, unit-norm rows)
+// ---------------------------------------------------------------------------
+
+fn validate_embeddings(data: &[f32], n: usize, dim: usize, label: &str) {
+    assert_eq!(dim, 1024, "{label}: embedding_dim must be 1024, got {dim}");
+    assert_eq!(dim % 16, 0, "{label}: dim must be divisible by 16");
+    for (i, row) in data.chunks_exact(dim).enumerate() {
+        let norm: f32 = row.iter().map(|x| x * x).sum::<f32>().sqrt();
+        assert!(
+            (norm - 1.0).abs() < 1e-3,
+            "{label} row {i}: L2 norm {norm:.6} not ~1.0",
+        );
+    }
+    eprintln!("  {label}: validated {n} rows (dim={dim}, L2-normalised)");
+}
+
+// ---------------------------------------------------------------------------
+// Output helpers
+// ---------------------------------------------------------------------------
+
+fn open_output(out_dir: &str, dataset: &str, slug: &str, ext: &str) -> BufWriter<std::fs::File> {
+    let dir = format!("{out_dir}/{dataset}");
+    std::fs::create_dir_all(&dir).unwrap_or_else(|e| panic!("create_dir_all {dir}: {e}"));
+    let path = format!("{dir}/{slug}.{ext}");
+    let f = std::fs::File::create(&path).unwrap_or_else(|e| panic!("create {path}: {e}"));
+    BufWriter::new(f)
+}
+
+/// Append-only writer for the per-config timing record stream.
+fn open_timing_appender(out_dir: &str, dataset: &str) -> BufWriter<std::fs::File> {
+    let dir = format!("{out_dir}/{dataset}");
+    std::fs::create_dir_all(&dir).unwrap_or_else(|e| panic!("create_dir_all {dir}: {e}"));
+    let path = format!("{dir}/timing.jsonl");
+    let f = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&path)
+        .unwrap_or_else(|e| panic!("open {path}: {e}"));
+    BufWriter::new(f)
+}
+
+/// Write one JSONL row per query (global doc indices; -1 = padding).
+#[allow(clippy::too_many_arguments)]
+fn write_topk_jsonl<W: Write>(
+    writer: &mut W,
+    dataset: &str,
+    split: &str,
+    method: &str,
+    k: usize,
+    query_ids: &[String],
+    corpus_ids: &[String],
+    indices: &[i64],
+    scores: &[f32],
+) {
+    let nq = query_ids.len();
+    let n_corpus = corpus_ids.len();
+    for qi in 0..nq {
+        let row_indices = &indices[qi * k..(qi + 1) * k];
+        let mut doc_idxs_str = String::from("[");
+        let mut doc_ids_str = String::from("[");
+        let mut scores_str = String::from("[");
+        let mut first = true;
+        for (j, &di) in row_indices.iter().enumerate() {
+            if di < 0 {
+                break;
+            }
+            let di_usize = di as usize;
+            if !first {
+                doc_idxs_str.push(',');
+                doc_ids_str.push(',');
+                scores_str.push(',');
+            }
+            first = false;
+            doc_idxs_str.push_str(&di_usize.to_string());
+            let doc_id = if di_usize < n_corpus {
+                corpus_ids[di_usize].as_str()
+            } else {
+                ""
+            };
+            doc_ids_str.push('"');
+            doc_ids_str.push_str(doc_id);
+            doc_ids_str.push('"');
+            let sc = scores.get(qi * k + j).copied().unwrap_or(0.0);
+            if sc.is_finite() {
+                scores_str.push_str(&sc.to_string());
+            } else {
+                scores_str.push_str("0.0");
+            }
+        }
+        doc_idxs_str.push(']');
+        doc_ids_str.push(']');
+        scores_str.push(']');
+
+        writeln!(
+            writer,
+            r#"{{"dataset":"{dataset}","split":"{split}","method":"{method}","qid_idx":{qi},"qid":"{qid}","k":{k},"doc_idxs":{doc_idxs_str},"doc_ids":{doc_ids_str},"scores":{scores_str}}}"#,
+            qid = query_ids[qi],
+        )
+        .expect("write topk jsonl");
+    }
+}
+
+/// A single benchmarked configuration's record — written both to the per-method
+/// summary.json (full-corpus runs) and appended to timing.jsonl (every run).
+struct Record<'a> {
+    dataset: &'a str,
+    split: &'a str,
+    method: &'a str,
+    dim: usize,
+    n_docs: usize,
+    n_queries: usize,
+    top_k: usize,
+    threads: usize,
+    batch: usize,
+    candidates: usize,
+    bytes_per_vector: usize,
+    index_total_mib: f64,
+    build_seconds: f64,
+    p50_ms: f64,
+    p95_ms: f64,
+    p99_ms: f64,
+    qps: f64,
+    simd: &'a [String],
+    encoder_sha: &'a str,
+}
+
+fn write_record_json<W: Write + ?Sized>(w: &mut W, r: &Record) {
+    let simd_arr: String = {
+        let parts: Vec<String> = r.simd.iter().map(|s| format!("\"{s}\"")).collect();
+        format!("[{}]", parts.join(","))
+    };
+    writeln!(
+        w,
+        r#"{{"dataset":"{ds}","split":"{sp}","method":"{m}","dim":{dim},"n_docs":{nd},"n_queries":{nq},"top_k":{tk},"threads":{th},"batch":{b},"candidates":{c},"bytes_per_vector":{bpv},"index_total_mib":{imib:.3},"build_seconds":{bs:.4},"query_latency_ms_p50":{p50:.5},"query_latency_ms_p95":{p95:.5},"query_latency_ms_p99":{p99:.5},"queries_per_second":{qps:.2},"cpu_arch":"{arch}","simd_detected":{simd},"rustc":"{rustc}","crate_version":"{cv}","encoder_manifest_sha256":"{sha}"}}"#,
+        ds = r.dataset,
+        sp = r.split,
+        m = r.method,
+        dim = r.dim,
+        nd = r.n_docs,
+        nq = r.n_queries,
+        tk = r.top_k,
+        th = r.threads,
+        b = r.batch,
+        c = r.candidates,
+        bpv = r.bytes_per_vector,
+        imib = r.index_total_mib,
+        bs = r.build_seconds,
+        p50 = r.p50_ms,
+        p95 = r.p95_ms,
+        p99 = r.p99_ms,
+        qps = r.qps,
+        arch = std::env::consts::ARCH,
+        simd = simd_arr,
+        rustc = rustc_version(),
+        cv = env!("CARGO_PKG_VERSION"),
+        sha = r.encoder_sha,
+    )
+    .expect("write record json");
+}
+
+// ---------------------------------------------------------------------------
+// Timing driver
+// ---------------------------------------------------------------------------
+
+/// Flat `nq*top_k` (indices, scores) for one query batch (sentinel -1 padded).
+type Preds = (Vec<i64>, Vec<f32>);
+/// Per-query latency samples (ns) + optionally the collected predictions.
+type TimedRun = (Vec<u128>, Option<Preds>);
+
+/// Warm up, time (amortized per-query over each batch), and optionally collect
+/// predictions. `search_batch(b_start, b_end)` returns flat `(b_end-b_start)*top_k`
+/// indices (sentinel -1 padded) and matching scores. Runs inside the caller's
+/// rayon pool so query parallelism is pinned to the configured thread count.
+fn time_and_collect<F>(
+    n_queries: usize,
+    batch: usize,
+    warmup: usize,
+    collect: bool,
+    mut search_batch: F,
+) -> TimedRun
+where
+    F: FnMut(usize, usize) -> Preds,
+{
+    // Warmup.
+    let w_end = (warmup.div_ceil(batch) * batch).min(n_queries);
+    let mut b_start = 0usize;
+    while b_start < w_end {
+        let b_end = (b_start + batch).min(n_queries);
+        let _ = search_batch(b_start, b_end);
+        b_start = b_end;
+    }
+
+    // Timing.
+    let mut samples = Vec::with_capacity(n_queries);
+    let mut preds_i: Vec<i64> = Vec::new();
+    let mut preds_s: Vec<f32> = Vec::new();
+    b_start = 0;
+    while b_start < n_queries {
+        let b_end = (b_start + batch).min(n_queries);
+        let b = b_end - b_start;
+        let t0 = Instant::now();
+        let (idx, sc) = search_batch(b_start, b_end);
+        let per_query_ns = t0.elapsed().as_nanos() / b as u128;
+        for _ in 0..b {
+            samples.push(per_query_ns);
+        }
+        if collect {
+            preds_i.extend_from_slice(&idx);
+            preds_s.extend_from_slice(&sc);
+        }
+        b_start = b_end;
+    }
+
+    let preds = if collect {
+        Some((preds_i, preds_s))
+    } else {
+        None
+    };
+    (samples, preds)
+}
+
+/// Finalize one method run: percentiles, optional topk/summary write, timing record.
+#[allow(clippy::too_many_arguments)]
+fn finalize(
+    slug: &str,
+    samples: &[u128],
+    preds: Option<(Vec<i64>, Vec<f32>)>,
+    dim: usize,
+    n_docs: usize,
+    n_queries: usize,
+    top_k: usize,
+    threads: usize,
+    batch: usize,
+    candidates: usize,
+    bytes_per_vector: usize,
+    index_total_mib: f64,
+    build_seconds: f64,
+    dataset: &str,
+    split: &str,
+    query_ids: &[String],
+    corpus_ids: &[String],
+    out_dir: &str,
+    simd: &[String],
+    encoder_sha: &str,
+    timing_writer: &mut dyn Write,
+) {
+    let p50 = percentile_ms(samples, 0.50);
+    let p95 = percentile_ms(samples, 0.95);
+    let p99 = percentile_ms(samples, 0.99);
+    let qps = 1_000.0 / p50.max(f64::EPSILON);
+
+    let rec = Record {
+        dataset,
+        split,
+        method: slug,
+        dim,
+        n_docs,
+        n_queries,
+        top_k,
+        threads,
+        batch,
+        candidates,
+        bytes_per_vector,
+        index_total_mib,
+        build_seconds,
+        p50_ms: p50,
+        p95_ms: p95,
+        p99_ms: p99,
+        qps,
+        simd,
+        encoder_sha,
+    };
+    // Always append to the timing stream.
+    write_record_json(timing_writer, &rec);
+
+    // Full-corpus runs (preds collected) also write topk + per-method summary.
+    if let Some((pred_i, pred_s)) = preds {
+        let mut jw = open_output(out_dir, dataset, slug, "topk.jsonl");
+        write_topk_jsonl(
+            &mut jw, dataset, split, slug, top_k, query_ids, corpus_ids, &pred_i, &pred_s,
+        );
+        jw.flush().expect("flush topk");
+        let mut sw = open_output(out_dir, dataset, slug, "summary.json");
+        write_record_json(&mut sw, &rec);
+        sw.flush().expect("flush summary");
+    }
+
+    eprintln!(
+        "  {slug} [n={n_docs} t={threads}]: p50={p50:.4}ms p95={p95:.4}ms p99={p99:.4}ms qps={qps:.1}"
+    );
+}
+
+// ---------------------------------------------------------------------------
+// Per-query top-k from raw scores (used by the flat baseline)
+// ---------------------------------------------------------------------------
+
+/// One chunk's contribution: `nq` rows, each a local top-k of (score, global_id).
+type ChunkTopK = Vec<Vec<(f32, i64)>>;
+
+/// Local top-k of a score row, returned as (score, global_id) sorted by score
+/// desc, with `id_offset` added to the local column index.
+fn local_topk(row: &[f32], id_offset: usize, top_k: usize) -> Vec<(f32, i64)> {
+    let mut scored: Vec<(f32, i64)> = row
+        .iter()
+        .enumerate()
+        .map(|(j, &s)| (s, (id_offset + j) as i64))
+        .collect();
+    let k = top_k.min(scored.len());
+    if k < scored.len() {
+        scored.select_nth_unstable_by(k - 1, |a, b| b.0.total_cmp(&a.0));
+        scored.truncate(k);
+    }
+    scored
+}
+
+/// Exact inner-product top-k for a whole query batch against `corpus[..n_docs]`.
+/// Same math as FAISS `IndexFlatIP`: scores = Q · Dᵀ via a blocked SIMD GEMM
+/// (matrixmultiply), parallelized over doc-chunks on the current rayon pool so
+/// the baseline both vectorizes and scales with the configured thread count.
+fn flat_batch_topk(
+    qbatch: &[f32],
+    nq: usize,
+    corpus: &[f32],
+    n_docs: usize,
+    dim: usize,
+    top_k: usize,
+) -> (Vec<i64>, Vec<f32>) {
+    // ~2 chunks per thread (≥1024 docs each) for balance without tiny GEMMs.
+    let nthreads = rayon::current_num_threads().max(1);
+    let target_chunks = (nthreads * 2).max(1);
+    let chunk_size = n_docs.div_ceil(target_chunks).max(1024);
+    let n_chunks = n_docs.div_ceil(chunk_size).max(1);
+
+    // Per chunk → nq rows of local top-k (global ids).
+    let per_chunk: Vec<ChunkTopK> = (0..n_chunks)
+        .into_par_iter()
+        .map(|c| {
+            let start = c * chunk_size;
+            let end = (start + chunk_size).min(n_docs);
+            let cn = end - start;
+            if cn == 0 {
+                return vec![Vec::new(); nq];
+            }
+            // C(nq × cn) = Q(nq × dim) · Dᵀ_chunk : B element (k, j) is at
+            // corpus[(start+j)*dim + k] → row-stride 1, col-stride dim.
+            let mut cmat = vec![0.0f32; nq * cn];
+            unsafe {
+                matrixmultiply::sgemm(
+                    nq,
+                    dim,
+                    cn,
+                    1.0,
+                    qbatch.as_ptr(),
+                    dim as isize,
+                    1,
+                    corpus[start * dim..end * dim].as_ptr(),
+                    1,
+                    dim as isize,
+                    0.0,
+                    cmat.as_mut_ptr(),
+                    cn as isize,
+                    1,
+                );
+            }
+            (0..nq)
+                .map(|qi| local_topk(&cmat[qi * cn..(qi + 1) * cn], start, top_k))
+                .collect()
+        })
+        .collect();
+
+    // Merge chunk-local top-k into the global top-k per query.
+    let mut idx = vec![-1i64; nq * top_k];
+    let mut sc = vec![0.0f32; nq * top_k];
+    for qi in 0..nq {
+        let mut merged: Vec<(f32, i64)> = Vec::new();
+        for chunk in &per_chunk {
+            merged.extend_from_slice(&chunk[qi]);
+        }
+        let k = top_k.min(merged.len());
+        if k < merged.len() {
+            merged.select_nth_unstable_by(k - 1, |a, b| b.0.total_cmp(&a.0));
+            merged.truncate(k);
+        }
+        merged.sort_unstable_by(|a, b| b.0.total_cmp(&a.0));
+        for (j, &(s, i)) in merged.iter().take(top_k).enumerate() {
+            idx[qi * top_k + j] = i;
+            sc[qi * top_k + j] = s;
+        }
+    }
+    (idx, sc)
+}
+
+/// Pad a per-query Vec<(idx, score)> ordering into flat `top_k` rows (-1 / 0.0).
+fn pad_rows(rows: Vec<Vec<(i64, f32)>>, top_k: usize) -> (Vec<i64>, Vec<f32>) {
+    let mut idx = vec![-1i64; rows.len() * top_k];
+    let mut sc = vec![0.0f32; rows.len() * top_k];
+    for (qi, row) in rows.iter().enumerate() {
+        for (j, &(i, s)) in row.iter().take(top_k).enumerate() {
+            idx[qi * top_k + j] = i;
+            sc[qi * top_k + j] = s;
+        }
+    }
+    (idx, sc)
+}
+
+// ---------------------------------------------------------------------------
+// Cache resolution
+// ---------------------------------------------------------------------------
+
+fn resolve_encoder_dir(cache_dir: &str, dataset: &str, split: &str) -> String {
+    let parent = format!("{cache_dir}/{dataset}/{split}");
+    let entries = std::fs::read_dir(&parent).unwrap_or_else(|e| panic!("read_dir {parent}: {e}"));
+    let mut matches: Vec<String> = entries
+        .filter_map(|e| e.ok())
+        .filter(|e| e.file_name().to_string_lossy().starts_with("encoder=") && e.path().is_dir())
+        .map(|e| e.path().to_string_lossy().to_string())
+        .collect();
+    assert!(!matches.is_empty(), "no encoder=* subdir under {parent}");
+    assert!(
+        matches.len() == 1,
+        "multiple encoder=* dirs under {parent}: {matches:?} — one encoder per dataset/split",
+    );
+    matches.remove(0)
+}
+
+// ---------------------------------------------------------------------------
+// main
+// ---------------------------------------------------------------------------
+
+fn main() {
+    let cfg = parse_args();
+
+    let threads_resolved = if cfg.threads == 0 {
+        std::thread::available_parallelism()
+            .map(|n| n.get())
+            .unwrap_or(1)
+    } else {
+        cfg.threads
+    };
+    // Per-config query pool: build still uses all cores (default global pool);
+    // query latency is pinned to `threads_resolved` via pool.install(...).
+    let query_pool = rayon::ThreadPoolBuilder::new()
+        .num_threads(threads_resolved)
+        .build()
+        .expect("build query thread pool");
+
+    eprintln!(
+        "beir-bench: dataset={} split={} top_k={} batch={} candidates={} threads={} (resolved {}) max_docs={:?} methods={:?}",
+        cfg.dataset, cfg.split, cfg.top_k, cfg.batch, cfg.candidates, cfg.threads, threads_resolved, cfg.max_docs, cfg.methods,
+    );
+
+    let enc_dir = resolve_encoder_dir(&cfg.cache_dir, &cfg.dataset, &cfg.split);
+    let manifest_path = format!("{enc_dir}/embeddings.manifest.json");
+    let encoder_sha = sha256_file(&manifest_path);
+
+    let (corpus_full, n_corpus_full, dim) = load_npy_f32(&format!("{enc_dir}/corpus.f32.npy"));
+    let (queries, n_queries, q_dim) = load_npy_f32(&format!("{enc_dir}/queries.f32.npy"));
+    assert_eq!(q_dim, dim, "query dim {q_dim} != corpus dim {dim}");
+    validate_embeddings(&corpus_full, n_corpus_full, dim, "corpus");
+    validate_embeddings(&queries, n_queries, q_dim, "queries");
+
+    let corpus_ids_full = load_json_string_array(&format!("{enc_dir}/corpus_ids.json"));
+    let query_ids = load_json_string_array(&format!("{enc_dir}/query_ids.json"));
+    assert_eq!(
+        corpus_ids_full.len(),
+        n_corpus_full,
+        "corpus_ids/embeddings mismatch"
+    );
+    assert_eq!(query_ids.len(), n_queries, "query_ids/embeddings mismatch");
+
+    // Sub-sample the corpus for the scaling sweep (latency-only; no nDCG).
+    let n_docs = cfg.max_docs.unwrap_or(n_corpus_full).min(n_corpus_full);
+    let full_corpus = cfg.max_docs.is_none() || n_docs == n_corpus_full;
+    let corpus = &corpus_full[..n_docs * dim];
+    let corpus_ids = &corpus_ids_full[..n_docs];
+    let write_topk = full_corpus; // qrels-based nDCG only valid on the full corpus
+
+    let simd = detected_simd();
+    eprintln!(
+        "dim={dim} n_docs={n_docs}{} n_queries={n_queries} simd={simd:?}",
+        if full_corpus {
+            " (full)"
+        } else {
+            " (sub-sampled)"
+        }
+    );
+
+    let mut timing_writer = open_timing_appender(&cfg.out_dir, &cfg.dataset);
+
+    for method in &cfg.methods {
+        eprintln!("\n--- {method} ---");
+        match method.as_str() {
+            "flat" => run_flat(
+                corpus,
+                &queries,
+                dim,
+                n_docs,
+                n_queries,
+                cfg.top_k,
+                cfg.batch,
+                threads_resolved,
+                &query_pool,
+                &cfg,
+                corpus_ids,
+                &query_ids,
+                &simd,
+                &encoder_sha,
+                write_topk,
+                &mut timing_writer,
+            ),
+            "hnsw" => run_hnsw(
+                corpus,
+                &queries,
+                dim,
+                n_docs,
+                n_queries,
+                cfg.top_k,
+                cfg.batch,
+                threads_resolved,
+                &query_pool,
+                &cfg,
+                corpus_ids,
+                &query_ids,
+                &simd,
+                &encoder_sha,
+                write_topk,
+                &mut timing_writer,
+            ),
+            "rq2" => run_rq(
+                corpus,
+                &queries,
+                dim,
+                n_docs,
+                n_queries,
+                cfg.top_k,
+                cfg.batch,
+                2,
+                threads_resolved,
+                &query_pool,
+                &cfg,
+                corpus_ids,
+                &query_ids,
+                &simd,
+                &encoder_sha,
+                write_topk,
+                &mut timing_writer,
+            ),
+            "rq4" => run_rq(
+                corpus,
+                &queries,
+                dim,
+                n_docs,
+                n_queries,
+                cfg.top_k,
+                cfg.batch,
+                4,
+                threads_resolved,
+                &query_pool,
+                &cfg,
+                corpus_ids,
+                &query_ids,
+                &simd,
+                &encoder_sha,
+                write_topk,
+                &mut timing_writer,
+            ),
+            "bitmap-rq2" => run_two_stage(
+                TwoStage::Bitmap,
+                corpus,
+                &queries,
+                dim,
+                n_docs,
+                n_queries,
+                cfg.top_k,
+                cfg.batch,
+                cfg.candidates,
+                threads_resolved,
+                &query_pool,
+                &cfg,
+                corpus_ids,
+                &query_ids,
+                &simd,
+                &encoder_sha,
+                write_topk,
+                &mut timing_writer,
+            ),
+            "sign-rq2" => run_two_stage(
+                TwoStage::Sign,
+                corpus,
+                &queries,
+                dim,
+                n_docs,
+                n_queries,
+                cfg.top_k,
+                cfg.batch,
+                cfg.candidates,
+                threads_resolved,
+                &query_pool,
+                &cfg,
+                corpus_ids,
+                &query_ids,
+                &simd,
+                &encoder_sha,
+                write_topk,
+                &mut timing_writer,
+            ),
+            other => panic!(
+                "unknown method '{other}'. Supported: flat, hnsw, rq2, rq4, bitmap-rq2, sign-rq2"
+            ),
+        }
+    }
+    timing_writer.flush().expect("flush timing.jsonl");
+    eprintln!(
+        "\ndone. timing -> {}/{}/timing.jsonl",
+        cfg.out_dir, cfg.dataset
+    );
+}
+
+// ---------------------------------------------------------------------------
+// Method: flat (exact inner product == FAISS IndexFlatIP math)
+// ---------------------------------------------------------------------------
+
+#[allow(clippy::too_many_arguments)]
+fn run_flat(
+    corpus: &[f32],
+    queries: &[f32],
+    dim: usize,
+    n_docs: usize,
+    n_queries: usize,
+    top_k: usize,
+    batch: usize,
+    threads: usize,
+    pool: &rayon::ThreadPool,
+    cfg: &Config,
+    corpus_ids: &[String],
+    query_ids: &[String],
+    simd: &[String],
+    encoder_sha: &str,
+    write_topk: bool,
+    timing_writer: &mut dyn Write,
+) {
+    let bytes_per_vector = dim * 4;
+    let index_total_mib = (n_docs * bytes_per_vector) as f64 / 1024.0 / 1024.0;
+    let warmup = 5.min(n_queries);
+
+    let (samples, preds) = pool.install(|| {
+        time_and_collect(n_queries, batch, warmup, write_topk, |bs, be| {
+            let qbatch = &queries[bs * dim..be * dim];
+            flat_batch_topk(qbatch, be - bs, corpus, n_docs, dim, top_k)
+        })
+    });
+
+    finalize(
+        "flat",
+        &samples,
+        preds,
+        dim,
+        n_docs,
+        n_queries,
+        top_k,
+        threads,
+        batch,
+        0,
+        bytes_per_vector,
+        index_total_mib,
+        0.0,
+        &cfg.dataset,
+        &cfg.split,
+        query_ids,
+        corpus_ids,
+        &cfg.out_dir,
+        simd,
+        encoder_sha,
+        timing_writer,
+    );
+}
+
+// ---------------------------------------------------------------------------
+// Method: hnsw (pure-Rust HNSW, hnsw_rs; DistDot on unit-norm vectors)
+// ---------------------------------------------------------------------------
+
+#[allow(clippy::too_many_arguments)]
+fn run_hnsw(
+    corpus: &[f32],
+    queries: &[f32],
+    dim: usize,
+    n_docs: usize,
+    n_queries: usize,
+    top_k: usize,
+    batch: usize,
+    threads: usize,
+    pool: &rayon::ThreadPool,
+    cfg: &Config,
+    corpus_ids: &[String],
+    query_ids: &[String],
+    simd: &[String],
+    encoder_sha: &str,
+    write_topk: bool,
+    timing_writer: &mut dyn Write,
+) {
+    let slug = "hnsw";
+    eprintln!("  building HNSW M={HNSW_M} ef_c={HNSW_EF_CONSTRUCTION} ({n_docs} docs) ...");
+    let hnsw: Hnsw<f32, DistDot> = Hnsw::new(
+        HNSW_M,
+        n_docs,
+        HNSW_MAX_LAYER,
+        HNSW_EF_CONSTRUCTION,
+        DistDot {},
+    );
+    // Insert (build uses all cores via the global pool).
+    let doc_refs: Vec<(&[f32], usize)> = (0..n_docs)
+        .map(|di| (&corpus[di * dim..(di + 1) * dim], di))
+        .collect();
+    let t0 = Instant::now();
+    hnsw.parallel_insert_slice(&doc_refs);
+    let build_seconds = t0.elapsed().as_secs_f64();
+    eprintln!("  build done in {build_seconds:.2}s");
+
+    // HNSW graph size is implementation-internal; report the stored-vector bytes
+    // (full float) as the index footprint, matching the dense baseline accounting.
+    let bytes_per_vector = dim * 4;
+    let index_total_mib = (n_docs * bytes_per_vector) as f64 / 1024.0 / 1024.0;
+    let warmup = 5.min(n_queries);
+
+    // Pre-slice query rows so neither timing mode pays per-batch allocation.
+    let query_rows: Vec<&[f32]> = (0..n_queries)
+        .map(|qi| &queries[qi * dim..(qi + 1) * dim])
+        .collect();
+
+    let (samples, preds) = pool.install(|| {
+        time_and_collect(n_queries, batch, warmup, write_topk, |bs, be| {
+            let rows: Vec<Vec<(i64, f32)>> = if threads == 1 {
+                // Single-thread: serial search per query.
+                (bs..be)
+                    .map(|qi| {
+                        hnsw.search(query_rows[qi], top_k, HNSW_EF_SEARCH)
+                            .into_iter()
+                            .map(|nb| (nb.d_id as i64, 1.0 - nb.distance))
+                            .collect()
+                    })
+                    .collect()
+            } else {
+                // Threaded: batched parallel search (rayon, this pool).
+                let batch_slice: Vec<Vec<f32>> =
+                    (bs..be).map(|qi| query_rows[qi].to_vec()).collect();
+                hnsw.parallel_search(&batch_slice, top_k, HNSW_EF_SEARCH)
+                    .into_iter()
+                    .map(|nbs| {
+                        nbs.into_iter()
+                            .map(|nb| (nb.d_id as i64, 1.0 - nb.distance))
+                            .collect()
+                    })
+                    .collect()
+            };
+            pad_rows(rows, top_k)
+        })
+    });
+
+    finalize(
+        slug,
+        &samples,
+        preds,
+        dim,
+        n_docs,
+        n_queries,
+        top_k,
+        threads,
+        batch,
+        0,
+        bytes_per_vector,
+        index_total_mib,
+        build_seconds,
+        &cfg.dataset,
+        &cfg.split,
+        query_ids,
+        corpus_ids,
+        &cfg.out_dir,
+        simd,
+        encoder_sha,
+        timing_writer,
+    );
+}
+
+// ---------------------------------------------------------------------------
+// Method: rq2 / rq4 (RankQuant full-scan asymmetric LUT)
+// ---------------------------------------------------------------------------
+
+#[allow(clippy::too_many_arguments)]
+fn run_rq(
+    corpus: &[f32],
+    queries: &[f32],
+    dim: usize,
+    n_docs: usize,
+    n_queries: usize,
+    top_k: usize,
+    batch: usize,
+    bits: u8,
+    threads: usize,
+    pool: &rayon::ThreadPool,
+    cfg: &Config,
+    corpus_ids: &[String],
+    query_ids: &[String],
+    simd: &[String],
+    encoder_sha: &str,
+    write_topk: bool,
+    timing_writer: &mut dyn Write,
+) {
+    let slug = format!("ordvec-rq{bits}");
+    eprintln!("  building RankQuant b={bits} ({n_docs} docs) ...");
+    let mut idx = RankQuant::new(dim, bits);
+    let t0 = Instant::now();
+    idx.add(corpus);
+    let build_seconds = t0.elapsed().as_secs_f64();
+    let bytes_per_vector = idx.bytes_per_vec();
+    let index_total_mib = idx.byte_size() as f64 / 1024.0 / 1024.0;
+    let warmup = 5.min(n_queries);
+
+    let (samples, preds) = pool.install(|| {
+        time_and_collect(n_queries, batch, warmup, write_topk, |bs, be| {
+            let batch_q = &queries[bs * dim..be * dim];
+            let res = idx.search_asymmetric(batch_q, top_k);
+            (res.indices, res.scores)
+        })
+    });
+
+    finalize(
+        &slug,
+        &samples,
+        preds,
+        dim,
+        n_docs,
+        n_queries,
+        top_k,
+        threads,
+        batch,
+        0,
+        bytes_per_vector,
+        index_total_mib,
+        build_seconds,
+        &cfg.dataset,
+        &cfg.split,
+        query_ids,
+        corpus_ids,
+        &cfg.out_dir,
+        simd,
+        encoder_sha,
+        timing_writer,
+    );
+}
+
+// ---------------------------------------------------------------------------
+// Method: bitmap-rq2 / sign-rq2 (two-stage candidate-gen → rerank)
+// ---------------------------------------------------------------------------
+
+#[derive(Clone, Copy)]
+enum TwoStage {
+    Bitmap,
+    Sign,
+}
+
+fn bitmap_vecs_to_csr(vecs: Vec<Vec<u32>>) -> (Vec<usize>, Vec<u32>) {
+    let mut offsets = Vec::with_capacity(vecs.len() + 1);
+    let mut candidates = Vec::new();
+    offsets.push(0usize);
+    for row in &vecs {
+        candidates.extend_from_slice(row);
+        offsets.push(candidates.len());
+    }
+    (offsets, candidates)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn run_two_stage(
+    stage: TwoStage,
+    corpus: &[f32],
+    queries: &[f32],
+    dim: usize,
+    n_docs: usize,
+    n_queries: usize,
+    top_k: usize,
+    batch: usize,
+    candidates: usize,
+    threads: usize,
+    pool: &rayon::ThreadPool,
+    cfg: &Config,
+    corpus_ids: &[String],
+    query_ids: &[String],
+    simd: &[String],
+    encoder_sha: &str,
+    write_topk: bool,
+    timing_writer: &mut dyn Write,
+) {
+    let (slug, label) = match stage {
+        TwoStage::Bitmap => ("ordvec-bitmap-rq2", "Bitmap"),
+        TwoStage::Sign => ("ordvec-sign-rq2", "SignBitmap"),
+    };
+    eprintln!("  building {label} + RankQuant b=2 (m={candidates}, {n_docs} docs) ...");
+
+    let n_top = dim / 4;
+    let mut bitmap = Bitmap::new(dim, n_top);
+    let mut sign = SignBitmap::new(dim);
+    let mut rq = RankQuant::new(dim, 2);
+    let t0 = Instant::now();
+    match stage {
+        TwoStage::Bitmap => bitmap.add(corpus),
+        TwoStage::Sign => sign.add(corpus),
+    }
+    rq.add(corpus);
+    let build_seconds = t0.elapsed().as_secs_f64();
+
+    let stage1_bytes = match stage {
+        TwoStage::Bitmap => bitmap.bytes_per_vec(),
+        TwoStage::Sign => sign.bytes_per_vec(),
+    };
+    let stage1_size = match stage {
+        TwoStage::Bitmap => bitmap.byte_size(),
+        TwoStage::Sign => sign.byte_size(),
+    };
+    let bytes_per_vector = stage1_bytes + rq.bytes_per_vec();
+    let index_total_mib = (stage1_size + rq.byte_size()) as f64 / 1024.0 / 1024.0;
+
+    let out_k = top_k.min(candidates).min(n_docs);
+    let warmup = 5.min(n_queries);
+
+    let mut scratch = SubsetScratch::new();
+    let mut out_scores_buf = vec![f32::NEG_INFINITY; batch * out_k];
+    let mut out_indices_buf = vec![-1i64; batch * out_k];
+
+    let (samples, preds) = pool.install(|| {
+        time_and_collect(n_queries, batch, warmup, write_topk, |bs, be| {
+            let batch_q = &queries[bs * dim..be * dim];
+            let nq_batch = be - bs;
+            let needed = nq_batch * out_k;
+            if out_scores_buf.len() != needed {
+                out_scores_buf.resize(needed, f32::NEG_INFINITY);
+                out_indices_buf.resize(needed, -1);
+            }
+
+            // Stage 1: candidate generation → CSR (offsets, candidates).
+            let (offsets, cand_flat) = match stage {
+                TwoStage::Bitmap => {
+                    let cand_vecs = bitmap.top_m_candidates_batched(batch_q, candidates);
+                    bitmap_vecs_to_csr(cand_vecs)
+                }
+                TwoStage::Sign => {
+                    let cb: CandidateBatch =
+                        sign.top_m_candidates_batched_serial_csr(batch_q, candidates);
+                    (cb.offsets, cb.candidates)
+                }
+            };
+
+            // Stage 2: pooled subset rerank (allocation-free).
+            rq.search_asymmetric_subset_batched_serial_into(
+                batch_q,
+                &offsets,
+                &cand_flat,
+                top_k,
+                &mut scratch,
+                &mut out_scores_buf,
+                &mut out_indices_buf,
+            );
+
+            // Pad per-query results to `top_k`.
+            let mut idx = vec![-1i64; nq_batch * top_k];
+            let mut sc = vec![0.0f32; nq_batch * top_k];
+            for qi in 0..nq_batch {
+                let src_i = &out_indices_buf[qi * out_k..(qi + 1) * out_k];
+                let src_s = &out_scores_buf[qi * out_k..(qi + 1) * out_k];
+                let copy = src_i.len().min(top_k);
+                idx[qi * top_k..qi * top_k + copy].copy_from_slice(&src_i[..copy]);
+                sc[qi * top_k..qi * top_k + copy].copy_from_slice(&src_s[..copy]);
+            }
+            (idx, sc)
+        })
+    });
+
+    finalize(
+        slug,
+        &samples,
+        preds,
+        dim,
+        n_docs,
+        n_queries,
+        top_k,
+        threads,
+        batch,
+        candidates,
+        bytes_per_vector,
+        index_total_mib,
+        build_seconds,
+        &cfg.dataset,
+        &cfg.split,
+        query_ids,
+        corpus_ids,
+        &cfg.out_dir,
+        simd,
+        encoder_sha,
+        timing_writer,
+    );
+}
diff --git a/benchmarks/beir/beir_baselines.py b/benchmarks/beir/beir_baselines.py
deleted file mode 100644
index 28f08a8d..00000000
--- a/benchmarks/beir/beir_baselines.py
+++ /dev/null
@@ -1,459 +0,0 @@
-"""
-beir_baselines.py — native Python/C++ baselines for the ordvec-beir harness.
-
-Methods
--------
-faiss-flat
-    Full-float inner-product exact search via faiss.IndexFlatIP on L2-normalised
-    corpus vectors.  Inner product on unit vectors == cosine similarity.
-
-hnswlib-m<M>-ef<ef_search>
-    Approximate nearest-neighbour search via hnswlib's HNSW graph in cosine space.
-
-Both methods consume the cached ``.npy`` arrays produced by ``beir_prepare.py``
-and write results in the shared top-k JSONL + summary JSON formats defined by
-``common.py``.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import pathlib
-import time
-from typing import Any
-
-import numpy as np
-
-# Allow `from common import ...` when run as a script from the repo root
-# (the Makefile invokes `python3 benchmarks/beir/<script>.py`).
-import os as _os
-import sys as _sys
-
-_sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__)))
-
-from common import (
-    find_encoder_dir,
-    load_ids,
-    load_npy_f32,
-    slug_for_method,
-    summary_json_path,
-    topk_jsonl_path,
-    write_topk_jsonl,
-)
-
-# ---------------------------------------------------------------------------
-# Latency helpers
-# ---------------------------------------------------------------------------
-
-
-def _percentile(values: list[float], p: float) -> float:
-    """Return the *p*-th percentile of *values* (0–100)."""
-    if not values:
-        return float("nan")
-    arr = sorted(values)
-    idx = (p / 100.0) * (len(arr) - 1)
-    lo = int(idx)
-    hi = min(lo + 1, len(arr) - 1)
-    frac = idx - lo
-    return arr[lo] * (1.0 - frac) + arr[hi] * frac
-
-
-# ---------------------------------------------------------------------------
-# faiss-flat baseline
-# ---------------------------------------------------------------------------
-
-
-def run_faiss_flat(
-    corpus: np.ndarray,
-    queries: np.ndarray,
-    corpus_ids: list[str],
-    query_ids: list[str],
-    dataset: str,
-    split: str,
-    top_k: int,
-    out_dir: pathlib.Path,
-) -> dict[str, Any]:
-    """Run faiss.IndexFlatIP search and return a summary dict."""
-    import faiss  # type: ignore[import]
-
-    method = "faiss-flat"
-    method_slug = slug_for_method(method, None, None)
-
-    n_docs, dim = corpus.shape
-    n_queries = queries.shape[0]
-
-    # ------------------------------------------------------------------
-    # Build index
-    # ------------------------------------------------------------------
-    t0 = time.perf_counter()
-    index = faiss.IndexFlatIP(dim)
-    index.add(corpus)
-    build_seconds = time.perf_counter() - t0
-
-    # ------------------------------------------------------------------
-    # Query — one-at-a-time to capture per-query latencies
-    # ------------------------------------------------------------------
-    rows: list[dict] = []
-    query_times: list[float] = []
-
-    for q_idx, qid in enumerate(query_ids):
-        q_vec = queries[q_idx : q_idx + 1]  # shape (1, dim)
-        qt0 = time.perf_counter()
-        distances, indices = index.search(q_vec, top_k)
-        query_times.append((time.perf_counter() - qt0) * 1_000.0)  # ms
-
-        doc_idxs: list[int] = indices[0].tolist()
-        doc_ids: list[str] = [corpus_ids[i] for i in doc_idxs]
-        scores: list[float] = distances[0].tolist()
-
-        rows.append(
-            {
-                "dataset": dataset,
-                "split": split,
-                "method": method,
-                "qid_idx": q_idx,
-                "qid": qid,
-                "k": top_k,
-                "doc_idxs": doc_idxs,
-                "doc_ids": doc_ids,
-                "scores": scores,
-            }
-        )
-
-    # ------------------------------------------------------------------
-    # Write JSONL
-    # ------------------------------------------------------------------
-    jsonl_path = topk_jsonl_path(out_dir, dataset, method_slug)
-    write_topk_jsonl(jsonl_path, rows)
-
-    total_query_seconds = sum(query_times) / 1_000.0
-    qps = n_queries / total_query_seconds if total_query_seconds > 0 else float("nan")
-
-    summary: dict[str, Any] = {
-        "method": method,
-        "method_slug": method_slug,
-        "dataset": dataset,
-        "split": split,
-        "n_docs": n_docs,
-        "n_queries": n_queries,
-        "top_k": top_k,
-        "bytes_per_vector": dim * 4,  # float32
-        "index_total_mib": (n_docs * dim * 4) / (1024 ** 2),
-        "build_seconds": build_seconds,
-        "query_latency_ms_p50": _percentile(query_times, 50),
-        "query_latency_ms_p95": _percentile(query_times, 95),
-        "query_latency_ms_p99": _percentile(query_times, 99),
-        "queries_per_second": qps,
-        "faiss_index_type": "IndexFlatIP",
-    }
-
-    sum_path = summary_json_path(out_dir, dataset, method_slug)
-    sum_path.write_text(json.dumps(summary, indent=2))
-
-    print(
-        f"[faiss-flat] {dataset}/{split}: n_docs={n_docs}, n_queries={n_queries}, "
-        f"build={build_seconds:.2f}s, p50={summary['query_latency_ms_p50']:.2f}ms, "
-        f"QPS={qps:.1f}"
-    )
-    return summary
-
-
-# ---------------------------------------------------------------------------
-# hnswlib baseline
-# ---------------------------------------------------------------------------
-
-
-def run_hnswlib(
-    corpus: np.ndarray,
-    queries: np.ndarray,
-    corpus_ids: list[str],
-    query_ids: list[str],
-    dataset: str,
-    split: str,
-    top_k: int,
-    out_dir: pathlib.Path,
-    hnsw_m: int,
-    hnsw_ef_construction: int,
-    hnsw_ef_search: int,
-    seed: int,
-) -> dict[str, Any]:
-    """Run hnswlib HNSW search and return a summary dict."""
-    import hnswlib  # type: ignore[import]
-
-    method = f"hnswlib-m{hnsw_m}-ef{hnsw_ef_search}"
-    method_slug = slug_for_method(method, None, None)
-
-    n_docs, dim = corpus.shape
-    n_queries = queries.shape[0]
-
-    # ------------------------------------------------------------------
-    # Build index
-    # ------------------------------------------------------------------
-    t0 = time.perf_counter()
-    index = hnswlib.Index(space="cosine", dim=dim)
-    index.init_index(
-        max_elements=n_docs,
-        M=hnsw_m,
-        ef_construction=hnsw_ef_construction,
-        random_seed=seed,
-    )
-    index.add_items(corpus, num_threads=-1)
-    index.set_ef(hnsw_ef_search)
-    build_seconds = time.perf_counter() - t0
-
-    # ------------------------------------------------------------------
-    # Query — one-at-a-time for latency measurements
-    # ------------------------------------------------------------------
-    rows: list[dict] = []
-    query_times: list[float] = []
-
-    for q_idx, qid in enumerate(query_ids):
-        q_vec = queries[q_idx : q_idx + 1]  # shape (1, dim)
-        qt0 = time.perf_counter()
-        labels, distances = index.knn_query(q_vec, k=min(top_k, n_docs))
-        query_times.append((time.perf_counter() - qt0) * 1_000.0)  # ms
-
-        # hnswlib returns cosine *distance* (1 - cosine_sim); convert to score
-        doc_idxs: list[int] = labels[0].tolist()
-        doc_ids: list[str] = [corpus_ids[i] for i in doc_idxs]
-        # Score = 1 - distance (cosine similarity)
-        scores: list[float] = [float(1.0 - d) for d in distances[0].tolist()]
-
-        rows.append(
-            {
-                "dataset": dataset,
-                "split": split,
-                "method": method,
-                "qid_idx": q_idx,
-                "qid": qid,
-                "k": top_k,
-                "doc_idxs": doc_idxs,
-                "doc_ids": doc_ids,
-                "scores": scores,
-            }
-        )
-
-    # ------------------------------------------------------------------
-    # Write JSONL
-    # ------------------------------------------------------------------
-    jsonl_path = topk_jsonl_path(out_dir, dataset, method_slug)
-    write_topk_jsonl(jsonl_path, rows)
-
-    total_query_seconds = sum(query_times) / 1_000.0
-    qps = n_queries / total_query_seconds if total_query_seconds > 0 else float("nan")
-
-    # hnswlib doesn't expose a clean bytes-per-vector figure;
-    # report None and let the caller decide.
-    summary: dict[str, Any] = {
-        "method": method,
-        "method_slug": method_slug,
-        "dataset": dataset,
-        "split": split,
-        "n_docs": n_docs,
-        "n_queries": n_queries,
-        "top_k": top_k,
-        "bytes_per_vector": None,  # HNSW graph overhead is graph-structure-dependent
-        "index_total_mib": None,
-        "build_seconds": build_seconds,
-        "query_latency_ms_p50": _percentile(query_times, 50),
-        "query_latency_ms_p95": _percentile(query_times, 95),
-        "query_latency_ms_p99": _percentile(query_times, 99),
-        "queries_per_second": qps,
-        "hnsw_m": hnsw_m,
-        "hnsw_ef_construction": hnsw_ef_construction,
-        "hnsw_ef_search": hnsw_ef_search,
-        "seed": seed,
-    }
-
-    sum_path = summary_json_path(out_dir, dataset, method_slug)
-    sum_path.write_text(json.dumps(summary, indent=2))
-
-    print(
-        f"[{method}] {dataset}/{split}: n_docs={n_docs}, n_queries={n_queries}, "
-        f"build={build_seconds:.2f}s, p50={summary['query_latency_ms_p50']:.2f}ms, "
-        f"QPS={qps:.1f}"
-    )
-    return summary
-
-
-# ---------------------------------------------------------------------------
-# Per-dataset runner
-# ---------------------------------------------------------------------------
-
-
-def run_dataset(
-    dataset: str,
-    split: str,
-    cache_dir: pathlib.Path,
-    out_dir: pathlib.Path,
-    top_k: int,
-    methods: set[str],
-    hnsw_m: int,
-    hnsw_ef_construction: int,
-    hnsw_ef_search: int,
-    seed: int,
-) -> list[dict[str, Any]]:
-    """Load cached embeddings for *dataset* and run all requested methods."""
-    enc_dir = find_encoder_dir(cache_dir, dataset, split)
-
-    corpus_arr = load_npy_f32(enc_dir / "corpus.f32.npy")
-    queries_arr = load_npy_f32(enc_dir / "queries.f32.npy")
-    corpus_ids, query_ids = load_ids(enc_dir)
-
-    # Sanity-check id-count vs embedding row-count
-    if len(corpus_ids) != corpus_arr.shape[0]:
-        raise ValueError(
-            f"corpus_ids has {len(corpus_ids)} entries but corpus.f32.npy has "
-            f"{corpus_arr.shape[0]} rows."
-        )
-    if len(query_ids) != queries_arr.shape[0]:
-        raise ValueError(
-            f"query_ids has {len(query_ids)} entries but queries.f32.npy has "
-            f"{queries_arr.shape[0]} rows."
-        )
-
-    summaries: list[dict[str, Any]] = []
-
-    if "faiss-flat" in methods:
-        s = run_faiss_flat(
-            corpus=corpus_arr,
-            queries=queries_arr,
-            corpus_ids=corpus_ids,
-            query_ids=query_ids,
-            dataset=dataset,
-            split=split,
-            top_k=top_k,
-            out_dir=out_dir,
-        )
-        summaries.append(s)
-
-    if "hnswlib" in methods:
-        s = run_hnswlib(
-            corpus=corpus_arr,
-            queries=queries_arr,
-            corpus_ids=corpus_ids,
-            query_ids=query_ids,
-            dataset=dataset,
-            split=split,
-            top_k=top_k,
-            out_dir=out_dir,
-            hnsw_m=hnsw_m,
-            hnsw_ef_construction=hnsw_ef_construction,
-            hnsw_ef_search=hnsw_ef_search,
-            seed=seed,
-        )
-        summaries.append(s)
-
-    return summaries
-
-
-# ---------------------------------------------------------------------------
-# CLI
-# ---------------------------------------------------------------------------
-
-_KNOWN_METHODS = {"faiss-flat", "hnswlib"}
-
-
-def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
-    p = argparse.ArgumentParser(
-        description="BEIR native baselines (faiss-flat, hnswlib).",
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-    )
-    p.add_argument(
-        "--datasets",
-        nargs="+",
-        required=True,
-        metavar="DATASET",
-        help="One or more BEIR dataset names (e.g. nfcorpus scifact).",
-    )
-    p.add_argument(
-        "--split",
-        default="test",
-        help="Corpus split to evaluate.",
-    )
-    p.add_argument(
-        "--cache-dir",
-        default="/home/ndspence/GitHub/ordvec-beir/.cache/ordvec-beir",
-        help="Root of the embedding cache produced by beir_prepare.py.",
-    )
-    p.add_argument(
-        "--out-dir",
-        default="/home/ndspence/GitHub/ordvec-beir/results/beir",
-        help="Root directory for top-k JSONL and summary JSON output.",
-    )
-    p.add_argument(
-        "--top-k",
-        type=int,
-        default=100,
-        help="Number of results to retrieve per query.",
-    )
-    p.add_argument(
-        "--methods",
-        default="faiss-flat,hnswlib",
-        help="Comma-separated list of methods to run (faiss-flat, hnswlib).",
-    )
-    # HNSW params
-    p.add_argument(
-        "--hnsw-m",
-        type=int,
-        default=16,
-        help="HNSW M parameter (number of bi-directional links per node).",
-    )
-    p.add_argument(
-        "--hnsw-ef-construction",
-        type=int,
-        default=200,
-        help="HNSW ef_construction parameter.",
-    )
-    p.add_argument(
-        "--hnsw-ef-search",
-        type=int,
-        default=200,
-        help="HNSW ef (search) parameter.",
-    )
-    p.add_argument(
-        "--seed",
-        type=int,
-        default=42,
-        help="Random seed for hnswlib index construction.",
-    )
-    return p.parse_args(argv)
-
-
-def main(argv: list[str] | None = None) -> None:
-    args = _parse_args(argv)
-
-    requested = {m.strip() for m in args.methods.split(",")}
-    unknown = requested - _KNOWN_METHODS
-    if unknown:
-        raise ValueError(
-            f"Unknown method(s): {sorted(unknown)}. "
-            f"Supported: {sorted(_KNOWN_METHODS)}"
-        )
-
-    cache_dir = pathlib.Path(args.cache_dir)
-    out_dir = pathlib.Path(args.out_dir)
-
-    all_summaries: list[dict[str, Any]] = []
-    for dataset in args.datasets:
-        print(f"\n=== {dataset} ===")
-        summaries = run_dataset(
-            dataset=dataset,
-            split=args.split,
-            cache_dir=cache_dir,
-            out_dir=out_dir,
-            top_k=args.top_k,
-            methods=requested,
-            hnsw_m=args.hnsw_m,
-            hnsw_ef_construction=args.hnsw_ef_construction,
-            hnsw_ef_search=args.hnsw_ef_search,
-            seed=args.seed,
-        )
-        all_summaries.extend(summaries)
-
-    print(f"\nDone. {len(all_summaries)} run(s) completed.")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/benchmarks/beir/beir_eval.py b/benchmarks/beir/beir_eval.py
index 1d80df15..a5490405 100644
--- a/benchmarks/beir/beir_eval.py
+++ b/benchmarks/beir/beir_eval.py
@@ -516,12 +516,31 @@ def write_csv(
 #: Static family / implementation / search-type metadata for the matrix.
 #: Keyed by the method-name *stem* (params stripped).
 _METHOD_FAMILY: dict[str, dict[str, str]] = {
+    "flat": {
+        "family": "dense (float)",
+        "implementation": "Exact inner product (== FAISS FlatIP math)",
+        "search_type": "exact brute-force (SIMD GEMM)",
+        "headline_role": "baseline (comparison, not ground truth)",
+    },
+    "hnsw": {
+        "family": "dense (float) ANN",
+        "implementation": "HNSW M=32 (pure-Rust hnsw_rs)",
+        "search_type": "graph ANN (approximate)",
+        "headline_role": "candidate",
+    },
+    # Back-compat: the older Python-baselines lane used these slugs.
     "faiss-flat": {
         "family": "dense (float)",
         "implementation": "FAISS FlatIP",
         "search_type": "exact brute-force",
         "headline_role": "baseline (comparison, not ground truth)",
     },
+    "hnswlib": {
+        "family": "dense (float) ANN",
+        "implementation": "hnswlib M=32",
+        "search_type": "graph ANN (approximate)",
+        "headline_role": "candidate",
+    },
     "ordvec-rq2": {
         "family": "ordvec rank-quant",
         "implementation": "RankQuant b=2",
diff --git a/benchmarks/beir/beir_plot.py b/benchmarks/beir/beir_plot.py
new file mode 100644
index 00000000..e7719d78
--- /dev/null
+++ b/benchmarks/beir/beir_plot.py
@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""Render the three README benchmark graphics from the Rust harness output.
+
+Inputs (produced by `beir-bench`, written to `<runs-dir>/<dataset>/timing.jsonl`):
+  * a SCALING sweep (one dataset swept over `--max-docs`, fixed `--threads 1`)
+  * a SINGLE-THREAD full-corpus run (`--threads 1`)
+  * a THREADED full-corpus run (`--threads N`)
+
+Outputs (PNG + SVG) to `<out-dir>`:
+  1. `scaling_curve.{png,svg}`   speedup-vs-`flat` as the corpus grows — the
+     bands climb because exact brute force is O(n) while ordvec sign/rank
+     candidate-gen is near-flat in n.
+  2. `bars_single_thread.{png,svg}`  per-method query latency at 1 thread,
+     full corpus — the controlled apples-to-apples bar.
+  3. `bars_threaded.{png,svg}`   the same at N threads (matched batch).
+
+No fabricated data: every point/bar is read straight from the harness records.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import pathlib
+import sys
+
+import matplotlib
+
+matplotlib.use("Agg")  # headless
+import matplotlib.pyplot as plt  # noqa: E402
+
+# ---------------------------------------------------------------------------
+# Presentation: stable method order, display labels, colours
+# ---------------------------------------------------------------------------
+
+# (slug, display label, colour). Order = legend / bar order.
+METHOD_STYLE: list[tuple[str, str, str]] = [
+    ("flat", "flat (exact IP, 4096 B)", "#444444"),
+    ("hnsw", "HNSW M=32 (4096 B)", "#1f77b4"),
+    ("ordvec-rq4", "ordvec RankQuant b=4 (512 B)", "#2ca02c"),
+    ("ordvec-rq2", "ordvec RankQuant b=2 (256 B)", "#17becf"),
+    ("ordvec-bitmap-rq2", "ordvec Bitmap→rq2 (384 B)", "#ff7f0e"),
+    ("ordvec-sign-rq2", "ordvec Sign→rq2 (384 B)", "#d62728"),
+]
+LABEL = {s: lbl for s, lbl, _ in METHOD_STYLE}
+COLOR = {s: c for s, _, c in METHOD_STYLE}
+ORDER = [s for s, _, _ in METHOD_STYLE]
+
+
+def _read_timing(path: pathlib.Path) -> list[dict]:
+    records: list[dict] = []
+    with path.open("r", encoding="utf-8") as fh:
+        for line in fh:
+            line = line.strip()
+            if line:
+                records.append(json.loads(line))
+    return records
+
+
+def _dedupe_last(records: list[dict], key) -> list[dict]:
+    """Keep the LAST record for each key (later runs overwrite earlier ones)."""
+    out: dict = {}
+    for r in records:
+        out[key(r)] = r
+    return list(out.values())
+
+
+# ---------------------------------------------------------------------------
+# Graphic 1: scaling curve (speedup vs flat, vs corpus size)
+# ---------------------------------------------------------------------------
+
+def plot_scaling(records: list[dict], dataset: str, threads: int, batch: int,
+                 out_dir: pathlib.Path) -> None:
+    recs = [r for r in records if r.get("threads") == threads and r.get("batch") == batch]
+    recs = _dedupe_last(recs, lambda r: (r["method"], r["n_docs"]))
+
+    # flat p50 at each n is the reference.
+    flat_by_n = {r["n_docs"]: r["query_latency_ms_p50"] for r in recs if r["method"] == "flat"}
+    if not flat_by_n:
+        print("[plot] no 'flat' records in scaling sweep; skipping scaling_curve", file=sys.stderr)
+        return
+
+    mode = "single-query (batch=1)" if batch == 1 else f"batched (batch={batch})"
+    fig, ax = plt.subplots(figsize=(8.2, 5.0))
+    for slug in ORDER:
+        pts = sorted(
+            ((r["n_docs"], r["query_latency_ms_p50"]) for r in recs if r["method"] == slug),
+            key=lambda t: t[0],
+        )
+        xs = [n for n, _ in pts if n in flat_by_n]
+        ys = [flat_by_n[n] / p for n, p in pts if n in flat_by_n and p > 0]
+        if len(xs) < 2:
+            continue
+        if slug == "flat":
+            ax.axhline(1.0, color=COLOR[slug], ls="--", lw=1.2, label=LABEL[slug])
+        else:
+            ax.plot(xs, ys, marker="o", lw=2.0, color=COLOR[slug], label=LABEL[slug])
+
+    ax.set_xscale("log")
+    ax.set_yscale("log")
+    ax.set_xlabel("corpus size  (documents, log scale)")
+    ax.set_ylabel("speedup vs exact flat  (×, log scale)")
+    ax.set_title(
+        f"ordvec scales: speedup over exact search grows with corpus size\n"
+        f"{dataset}, {mode}, single-thread, Harrier-Q8 1024-d  (higher = faster than brute force)"
+    )
+    ax.grid(True, which="both", ls=":", alpha=0.4)
+    ax.legend(fontsize=8, loc="upper left", framealpha=0.9)
+    fig.tight_layout()
+    _save(fig, out_dir, "scaling_curve")
+
+
+# ---------------------------------------------------------------------------
+# Graphics 2 & 3: per-method latency bars (single-thread / threaded)
+# ---------------------------------------------------------------------------
+
+def plot_bars(records: list[dict], dataset: str, threads: int, batch: int, n_docs: int,
+              title: str, fname: str, out_dir: pathlib.Path) -> None:
+    recs = _dedupe_last(
+        [
+            r for r in records
+            if r.get("threads") == threads and r.get("batch") == batch and r.get("n_docs") == n_docs
+        ],
+        lambda r: r["method"],
+    )
+    by_method = {r["method"]: r for r in recs}
+    slugs = [s for s in ORDER if s in by_method]
+    if not slugs:
+        print(f"[plot] no records for {fname} (threads={threads}, n={n_docs})", file=sys.stderr)
+        return
+
+    p50 = [by_method[s]["query_latency_ms_p50"] for s in slugs]
+    qps = [by_method[s]["queries_per_second"] for s in slugs]
+    colors = [COLOR[s] for s in slugs]
+    labels = [LABEL[s].split(" (")[0] for s in slugs]
+
+    flat_p50 = by_method.get("flat", {}).get("query_latency_ms_p50")
+
+    fig, ax = plt.subplots(figsize=(8.2, 5.0))
+    bars = ax.bar(range(len(slugs)), p50, color=colors, edgecolor="black", lw=0.5)
+    ax.set_xticks(range(len(slugs)))
+    ax.set_xticklabels(labels, rotation=20, ha="right", fontsize=9)
+    ax.set_ylabel("query latency  p50 (ms/query, lower = better)")
+    ax.set_title(title)
+    ax.grid(True, axis="y", ls=":", alpha=0.4)
+
+    for i, (b, ms, q) in enumerate(zip(bars, p50, qps)):
+        spd = ""
+        if flat_p50 and slugs[i] != "flat" and ms > 0:
+            spd = f"\n{flat_p50 / ms:.1f}× vs flat"
+        ax.text(
+            b.get_x() + b.get_width() / 2, b.get_height(),
+            f"{ms:.3f} ms\n{q:,.0f} q/s{spd}",
+            ha="center", va="bottom", fontsize=7.5,
+        )
+    ax.set_ylim(0, max(p50) * 1.28)
+    fig.tight_layout()
+    _save(fig, out_dir, fname)
+
+
+def _save(fig, out_dir: pathlib.Path, stem: str) -> None:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    for ext in ("png", "svg"):
+        path = out_dir / f"{stem}.{ext}"
+        fig.savefig(path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    print(f"[plot] wrote {out_dir / stem}.png / .svg")
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main(argv: list[str] | None = None) -> None:
+    p = argparse.ArgumentParser(prog="beir_plot", description="Render BEIR benchmark graphics.")
+    p.add_argument("--runs-dir", default="results/beir")
+    p.add_argument("--scaling-dataset", required=True,
+                   help="Dataset swept over corpus size for the scaling curve (e.g. trec-covid).")
+    p.add_argument("--bar-dataset", required=True,
+                   help="Dataset for the single-thread / threaded latency bars.")
+    p.add_argument("--scaling-threads", type=int, default=1)
+    p.add_argument("--scaling-batch", type=int, default=1)
+    p.add_argument("--bar-single-threads", type=int, default=1)
+    p.add_argument("--bar-single-batch", type=int, default=1)
+    p.add_argument("--bar-multi-threads", type=int, required=True,
+                   help="Thread count for the threaded bar (must match a run).")
+    p.add_argument("--bar-multi-batch", type=int, default=32)
+    p.add_argument("--out-dir", default=None)
+    args = p.parse_args(argv)
+
+    runs = pathlib.Path(args.runs_dir)
+    out_dir = pathlib.Path(args.out_dir) if args.out_dir else runs / "figures"
+
+    # Scaling curve (single-query, single-thread by default).
+    scaling_path = runs / args.scaling_dataset / "timing.jsonl"
+    if scaling_path.is_file():
+        plot_scaling(_read_timing(scaling_path), args.scaling_dataset,
+                     args.scaling_threads, args.scaling_batch, out_dir)
+    else:
+        print(f"[plot] missing {scaling_path}; skipping scaling curve", file=sys.stderr)
+
+    # Bars: pick the largest n_docs available for each (threads, batch) regime.
+    bar_path = runs / args.bar_dataset / "timing.jsonl"
+    if bar_path.is_file():
+        bar_recs = _read_timing(bar_path)
+
+        def _max_n(threads: int, batch: int) -> int:
+            return max(
+                (r["n_docs"] for r in bar_recs
+                 if r.get("threads") == threads and r.get("batch") == batch),
+                default=0,
+            )
+
+        n_single = _max_n(args.bar_single_threads, args.bar_single_batch)
+        plot_bars(
+            bar_recs, args.bar_dataset, args.bar_single_threads, args.bar_single_batch, n_single,
+            f"Apples-to-apples, 1 thread, single-query — {args.bar_dataset} "
+            f"({n_single:,} docs, Harrier-Q8 1024-d)\nall methods, one Rust process",
+            "bars_single_thread", out_dir,
+        )
+        n_multi = _max_n(args.bar_multi_threads, args.bar_multi_batch)
+        plot_bars(
+            bar_recs, args.bar_dataset, args.bar_multi_threads, args.bar_multi_batch, n_multi,
+            f"Apples-to-apples, {args.bar_multi_threads} threads, batched (batch={args.bar_multi_batch}) "
+            f"— {args.bar_dataset}\n({n_multi:,} docs, Harrier-Q8 1024-d) — all methods, one Rust process",
+            "bars_threaded", out_dir,
+        )
+    else:
+        print(f"[plot] missing {bar_path}; skipping bars", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    main()
diff --git a/benchmarks/beir/beir_prepare.py b/benchmarks/beir/beir_prepare.py
index 70591412..d597332b 100644
--- a/benchmarks/beir/beir_prepare.py
+++ b/benchmarks/beir/beir_prepare.py
@@ -254,6 +254,155 @@ def _write_npy(path: pathlib.Path, arr: np.ndarray) -> None:
     np.save(str(path), arr)
 
 
+# ---------------------------------------------------------------------------
+# Vendored BEIR reader (no `beir` package dependency)
+# ---------------------------------------------------------------------------
+
+def _download_beir(dataset: str, cache_dir: pathlib.Path) -> pathlib.Path:
+    """Download + unzip a BEIR dataset to ``<cache>/raw/<dataset>/`` (cached).
+
+    Uses the public BEIR zip and stdlib ``zipfile`` so the harness does not
+    depend on the ``beir`` package (which transitively pulls the unbuildable
+    ``pytrec_eval``) — keeping ``pip install -r requirements.txt`` clean.
+    """
+    import zipfile
+
+    from tqdm import tqdm
+
+    data_path = cache_dir / "raw" / dataset
+    if (data_path / "corpus.jsonl").exists():
+        print(f"[prepare] Using cached raw data at {data_path}", flush=True)
+        return data_path
+
+    raw_dir = cache_dir / "raw"
+    raw_dir.mkdir(parents=True, exist_ok=True)
+    url = (
+        "https://public.ukp.informatik.tu-darmstadt.de/thakur/BEIR/datasets/"
+        f"{dataset}.zip"
+    )
+    print(f"[prepare] Downloading BEIR dataset: {url}", flush=True)
+    zip_path = raw_dir / f"{dataset}.zip"
+    with requests.get(url, stream=True, timeout=300) as r:
+        r.raise_for_status()
+        total = int(r.headers.get("content-length", 0))
+        with open(zip_path, "wb") as f, tqdm(
+            total=total, unit="iB", unit_scale=True, desc=f"{dataset}.zip"
+        ) as bar:
+            for chunk in r.iter_content(chunk_size=1 << 16):
+                f.write(chunk)
+                bar.update(len(chunk))
+    with zipfile.ZipFile(zip_path) as zf:
+        zf.extractall(raw_dir)
+    zip_path.unlink(missing_ok=True)
+    if not (data_path / "corpus.jsonl").exists():
+        raise FileNotFoundError(
+            f"BEIR archive for {dataset!r} did not unzip to {data_path}"
+        )
+    return data_path
+
+
+def _load_beir(
+    data_path: pathlib.Path, split: str
+) -> tuple[dict[str, dict[str, str]], dict[str, str], dict[str, dict[str, int]]]:
+    """Parse a BEIR dataset folder, mirroring ``beir.GenericDataLoader``:
+
+    ``corpus = {cid: {"title", "text"}}``, ``queries = {qid: text}``,
+    ``qrels = {qid: {cid: relevance}}``.
+    """
+    corpus: dict[str, dict[str, str]] = {}
+    with open(data_path / "corpus.jsonl", encoding="utf-8") as f:
+        for line in f:
+            d = json.loads(line)
+            corpus[str(d["_id"])] = {
+                "title": d.get("title", "") or "",
+                "text": d.get("text", "") or "",
+            }
+    queries: dict[str, str] = {}
+    with open(data_path / "queries.jsonl", encoding="utf-8") as f:
+        for line in f:
+            d = json.loads(line)
+            queries[str(d["_id"])] = d["text"]
+    qrels: dict[str, dict[str, int]] = {}
+    with open(data_path / "qrels" / f"{split}.tsv", encoding="utf-8") as f:
+        header = f.readline()
+        if "query-id" not in header:  # no header row → first line is data
+            f.seek(0)
+        for line in f:
+            parts = line.rstrip("\n").split("\t")
+            if len(parts) < 3:
+                continue
+            qid, cid, score = parts[0], parts[1], parts[2]
+            qrels.setdefault(qid, {})[cid] = int(score)
+    return corpus, queries, qrels
+
+
+# ---------------------------------------------------------------------------
+# llama.cpp GGUF embedder (exact Q8_0 weights, same llama.cpp as OrdinalDB)
+# ---------------------------------------------------------------------------
+
+def _embed_llamacpp(
+    corpus_texts: list[str],
+    query_texts: list[str],
+    gguf_repo: str,
+    gguf_file: str,
+    n_gpu_layers: int,
+    n_ctx: int,
+    batch_size: int,
+) -> tuple[np.ndarray, np.ndarray, dict[str, Any]]:
+    """Embed with the Q8_0 GGUF via llama-cpp-python (same llama.cpp + weights a
+    native-Rust llama.cpp encoder uses), last-token pooled and L2-normalised.
+    Returns ``(corpus_emb, query_emb, meta)``.
+    """
+    import llama_cpp
+    from llama_cpp import Llama
+
+    llm = Llama.from_pretrained(
+        repo_id=gguf_repo,
+        filename=gguf_file,
+        embedding=True,
+        n_gpu_layers=n_gpu_layers,
+        n_ctx=n_ctx,
+        n_batch=n_ctx,  # embeddings need the whole sequence in one batch
+        n_ubatch=n_ctx,
+        pooling_type=llama_cpp.LLAMA_POOLING_TYPE_LAST,
+        verbose=False,
+    )
+
+    def _embed_all(texts: list[str]) -> np.ndarray:
+        vecs: list[np.ndarray] = []
+        for i in range(0, len(texts), batch_size):
+            chunk = texts[i : i + batch_size]
+            for e in llm.embed(chunk):
+                arr = np.asarray(e, dtype=np.float32)
+                if arr.ndim == 2:  # per-token (no pooling) → take last token
+                    arr = arr[-1]
+                vecs.append(arr)
+        return np.vstack(vecs).astype(np.float32)
+
+    prefixed_queries = [QUERY_PROMPT + q for q in query_texts]
+    corpus_emb = _embed_all(corpus_texts)
+    query_emb = _embed_all(prefixed_queries)
+
+    def _l2(a: np.ndarray) -> np.ndarray:
+        n = np.linalg.norm(a, axis=1, keepdims=True)
+        n = np.where(n == 0, 1.0, n)
+        return np.ascontiguousarray(a / n, dtype=np.float32)
+
+    corpus_emb = _l2(corpus_emb)
+    query_emb = _l2(query_emb)
+
+    meta: dict[str, Any] = {
+        "gguf_repo": gguf_repo,
+        "gguf_file": gguf_file,
+        "gguf_quant": "Q8_0",
+        "llama_cpp_python_version": getattr(llama_cpp, "__version__", "unknown"),
+        "n_gpu_layers": n_gpu_layers,
+        "n_ctx": n_ctx,
+        "canonical": True,
+    }
+    return corpus_emb, query_emb, meta
+
+
 # ---------------------------------------------------------------------------
 # Main prepare routine
 # ---------------------------------------------------------------------------
@@ -268,30 +417,40 @@ def prepare_dataset(
     batch_size: int,
     ollama_url: str,
     cache_dir: pathlib.Path,
+    gguf_file: str = "*Q8_0.gguf",
+    n_gpu_layers: int = -1,
+    n_ctx: int = 2048,
+    force: bool = False,
 ) -> None:
     """Run the full prepare pipeline for one dataset."""
-    from beir import util as beir_util
-    from beir.datasets.data_loader import GenericDataLoader
-
-    # ------------------------------------------------------------------ #
-    # 1. Download dataset if absent                                        #
-    # ------------------------------------------------------------------ #
-    data_path = cache_dir / "raw" / dataset
-    if not data_path.exists():
-        print(f"[prepare] Downloading BEIR dataset: {dataset}", flush=True)
-        url = f"https://public.ukp.informatik.tu-darmstadt.de/thakur/BEIR/datasets/{dataset}.zip"
-        data_path.parent.mkdir(parents=True, exist_ok=True)
-        out_dir = beir_util.download_and_unzip(str(url), str(data_path.parent))
-        data_path = pathlib.Path(out_dir)
-    else:
-        print(f"[prepare] Using cached raw data at {data_path}", flush=True)
+    # 0. Skip if this exact encoder's artefacts are already cached. Re-embedding
+    #    a large corpus (e.g. trec-covid's 171K docs) is expensive, and several
+    #    benchmark targets touch the same dataset; `--force` re-embeds.
+    slug_revision = gguf_file if provider == "llamacpp" else revision
+    slug = encoder_slug(provider, model, slug_revision)
+    enc_dir = dataset_cache_dir(cache_dir, dataset, split, slug)
+    required = [
+        "corpus.f32.npy",
+        "queries.f32.npy",
+        "qrels.json",
+        "corpus_ids.json",
+        "query_ids.json",
+        "embeddings.manifest.json",
+        "sha256s.json",
+    ]
+    if not force and all((enc_dir / f).exists() for f in required):
+        print(
+            f"[prepare] {dataset}/{split}: cached encoder at {enc_dir} "
+            "(use --force to re-embed); skipping",
+            flush=True,
+        )
+        return
 
-    # ------------------------------------------------------------------ #
-    # 2. Load                                                              #
-    # ------------------------------------------------------------------ #
-    corpus, queries, qrels = GenericDataLoader(data_folder=str(data_path)).load(
-        split=split
-    )
+    # 1. Download + 2. Load via the vendored BEIR reader (no `beir` package
+    #    dependency, so `pip install -r requirements.txt` stays clean on a fresh
+    #    machine — `beir` would otherwise pull the unbuildable `pytrec_eval`).
+    data_path = _download_beir(dataset, cache_dir)
+    corpus, queries, qrels = _load_beir(data_path, split)
 
     # ------------------------------------------------------------------ #
     # 3. Stable ordering                                                   #
@@ -315,9 +474,7 @@ def prepare_dataset(
     # ------------------------------------------------------------------ #
     # 5. Embed                                                             #
     # ------------------------------------------------------------------ #
-    slug = encoder_slug(provider, model, revision)
-    enc_dir = dataset_cache_dir(cache_dir, dataset, split, slug)
-
+    # (slug / enc_dir computed above for the cache-skip check.)
     t0 = time.time()
     if provider == "st":
         corpus_emb, query_emb, enc_meta = _embed_st(
@@ -336,6 +493,16 @@ def prepare_dataset(
             ollama_url=ollama_url,
             batch_size=batch_size,
         )
+    elif provider == "llamacpp":
+        corpus_emb, query_emb, enc_meta = _embed_llamacpp(
+            corpus_texts,
+            query_texts,
+            gguf_repo=model,
+            gguf_file=gguf_file,
+            n_gpu_layers=n_gpu_layers,
+            n_ctx=n_ctx,
+            batch_size=batch_size,
+        )
     else:
         raise ValueError(f"Unknown provider: {provider!r}")
     embed_seconds = time.time() - t0
@@ -406,6 +573,32 @@ def prepare_dataset(
             "transformers_version": enc_meta["transformers_version"],
             "torch_version": enc_meta["torch_version"],
         }
+    elif provider == "llamacpp":
+        embeddings_manifest = {
+            "encoder_provider": "llama-cpp-python",
+            "encoder_model": model,
+            "encoder_revision": enc_meta["gguf_file"],
+            "encoder_slug": slug,
+            "embedding_dim": dim,
+            "dtype": "float32",
+            "normalize_embeddings": True,
+            "query_prompt_name": None,
+            "query_prompt_text": QUERY_PROMPT,
+            "document_prompt_text": None,
+            "n_corpus": n_docs,
+            "n_queries": n_queries,
+            "corpus_sha256": corpus_sha256,
+            "query_sha256": query_sha256,
+            "embed_seconds": embed_seconds,
+            "gguf_repo": enc_meta["gguf_repo"],
+            "gguf_file": enc_meta["gguf_file"],
+            "gguf_quant": enc_meta["gguf_quant"],
+            "llama_cpp_python_version": enc_meta["llama_cpp_python_version"],
+            "n_gpu_layers": enc_meta["n_gpu_layers"],
+            "n_ctx": enc_meta["n_ctx"],
+            "pooling": "last_token",
+            "canonical": enc_meta["canonical"],
+        }
     else:  # ollama
         embeddings_manifest = {
             "encoder_provider": "ollama",
@@ -463,14 +656,47 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     p.add_argument(
         "--provider",
-        choices=["st", "ollama"],
-        default="st",
-        help="Encoder provider: 'st' (sentence-transformers) or 'ollama'.",
+        choices=["st", "ollama", "llamacpp"],
+        default="llamacpp",
+        help=(
+            "Encoder provider: 'llamacpp' (GGUF via llama-cpp-python, CUDA — the "
+            "canonical lane), 'st' (sentence-transformers), or 'ollama'."
+        ),
     )
     p.add_argument(
         "--model",
-        default="microsoft/harrier-oss-v1-0.6b",
-        help="Model name / HuggingFace path (for 'st') or Ollama model tag.",
+        default="mradermacher/harrier-oss-v1-0.6b-GGUF",
+        help=(
+            "Encoder identity: HuggingFace repo path. For 'llamacpp' this is the "
+            "GGUF repo (paired with --gguf-file); for 'st' the model path; for "
+            "'ollama' the model tag."
+        ),
+    )
+    p.add_argument(
+        "--gguf-file",
+        default="*Q8_0.gguf",
+        dest="gguf_file",
+        help=(
+            "GGUF filename (glob ok) within --model's repo for the 'llamacpp' "
+            "lane (default: *Q8_0.gguf)."
+        ),
+    )
+    p.add_argument(
+        "--n-gpu-layers",
+        type=int,
+        default=-1,
+        dest="n_gpu_layers",
+        help=(
+            "Layers to offload to GPU for the 'llamacpp' lane; -1 = all "
+            "(default: -1)."
+        ),
+    )
+    p.add_argument(
+        "--n-ctx",
+        type=int,
+        default=2048,
+        dest="n_ctx",
+        help="Context window for the 'llamacpp' lane (default: 2048).",
     )
     p.add_argument(
         "--revision",
@@ -510,6 +736,11 @@ def _build_parser() -> argparse.ArgumentParser:
         default=42,
         help="Random seed (default: 42).",
     )
+    p.add_argument(
+        "--force",
+        action="store_true",
+        help="Re-embed even if cached encoder artefacts already exist.",
+    )
     return p
 
 
@@ -543,6 +774,10 @@ def main(argv: list[str] | None = None) -> None:
                 batch_size=args.batch_size,
                 ollama_url=args.ollama_url,
                 cache_dir=cache_dir,
+                gguf_file=args.gguf_file,
+                n_gpu_layers=args.n_gpu_layers,
+                n_ctx=args.n_ctx,
+                force=args.force,
             )
         except Exception as exc:  # noqa: BLE001
             print(
diff --git a/benchmarks/beir/beir_report.py b/benchmarks/beir/beir_report.py
index 1b4ad65c..817a9fb1 100644
--- a/benchmarks/beir/beir_report.py
+++ b/benchmarks/beir/beir_report.py
@@ -52,10 +52,11 @@
 )
 
 REQUIRED_CLAIM_FAISS_NOT_GROUND_TRUTH = (
-    "**FAISS FlatIP is a full-float dense retrieval baseline used for comparison "
-    "purposes — it is NOT ground truth.  nDCG@10 is computed against the official "
-    "BEIR qrels (human-annotated relevance judgements), not against FAISS "
-    "results.  ANN-recall-vs-FAISS (fraction of FAISS top-k recovered by an ANN "
+    "**The `flat` baseline is an exact full-float inner-product search (identical "
+    "retrieval to FAISS `IndexFlatIP`) used for comparison purposes — it is NOT "
+    "ground truth.  nDCG@10 is computed against the official BEIR qrels "
+    "(human-annotated relevance judgements), not against the `flat` results.  "
+    "Recall-vs-`flat` (fraction of the exact top-k recovered by an approximate "
     "method) is an optional diagnostic metric only; it does not substitute for "
     "qrel-based evaluation.**"
 )
@@ -192,7 +193,7 @@ def render_main_table(summary: dict[str, Any]) -> str:
         "Encoder (provider / model)",
         "Method",
         "nDCG@10",
-        "Δ vs FAISS",
+        f"Δ vs {baseline}",
         "95% CI",
         "MAP@10",
         "Recall@100",
@@ -261,7 +262,7 @@ def render_rollup_table(summary: dict[str, Any]) -> str:
     headers = [
         "Method",
         "Mean nDCG@10",
-        "Mean Δ vs FAISS",
+        f"Mean Δ vs {baseline}",
         "Datasets within CI",
         "Mean Recall@100",
         "Bytes/vec",
diff --git a/benchmarks/beir/figures/bars_single_thread.png b/benchmarks/beir/figures/bars_single_thread.png
new file mode 100644
index 0000000000000000000000000000000000000000..5fb4b371497ba030681fd3236bb793dcf3ef7924
GIT binary patch
literal 82096
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
Q5B|8IsgKLYUJv}g07qGPQ~&?~

literal 0
HcmV?d00001

diff --git a/benchmarks/beir/figures/bars_threaded.png b/benchmarks/beir/figures/bars_threaded.png
new file mode 100644
index 0000000000000000000000000000000000000000..8f14a29138172529e91e54357012d84a3e470a2f
GIT binary patch
literal 87751
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%0DjLcCI@4y-
zD`-#HN(+&`*)+DT1#crBR`GtuYL2z3x5$mS2TRGJwk+KdY&K*cfT&V2edWo=%au63
zo7V)kMC?)<RuVc2BA+bG$%&CgEblfY(;Q#UO#a{iwD{rmH!L0@B4fVj!Psj{zP4-z
z;-9xZww?Uz%L90XTe5~0=4Pz^ocXS%>`_ju%5YuA&6fqzLwp@3tG7+7tALI?)!a&@
zBd{jscet%azxVGf?`v-CRIt^}aoZ7RRptb{$g2*mA7;?4Z9OhyvywMpIcT6|;uk+o
z%Ifz=Fq#?~yf{BQRWAuPae~P=OCO`>jYL83EuvmZHn)ny@*1EN9+r6;=k!k<`qPil
z6sw553mW#kT4rQuN!V~9*h2n-lTc@bwC<q{B|}u!{eFuXs@c`$IC)xgqm#{M5`0qd
zcdbmZ?-d}`LF0^Lx9{d*Ph~y)nfY&zrxH{x1TI7H?vYtI;|?eUSyOISVevR7MUosE
zix&%&khiQHBpYG<felpCSU-fODDS^B?f7FsXN4?aiKMNwBWDUXqjNA`=6&)jccs``
z=UF(X3fyc?H6&S}JIF4BZ}&0Fl`6nB?`U>f(R~nb#mZ*ed9CF<yk1IYcyS+S-kSeh
z8|Zi2o17x;(iBJTaGAbDFqUg<N{4x#w0mGk4W415Adr!<M`P-mMu=XT9PWgAFRudJ
zbDjpit9$>fn{yOj;w{>2t)3S`b#)qU1_cRbPCPHrV3@_{=h+v{T?>a=#wNea;vT1Z
zgrW6wJ>ZGn-jaKA+FcW1s9XA?q+I2|t;mhLiB~tzN@)scwkF%Igk2SBngxPbq4BKj
zjf2$S8BI(>F?JBr>aKfNZy4XTk~weX8hN_@_zodN#o4nEZ|53$^lR2N@b27Dc<!=>
z3CkL^f&r>hxDpQ?V!ijK$nAo*c;&$D+RMh1GwIEzPOkBMvq#1{QnyG)*g#|A&cA$j
zZg_HzYutxQndi;cmQ4Zrubw=5{5w^P^m<j7`)~&LMZO3A6-`o3N&5F6>1p+wFvw2L
zcQkPGsyb3Fs#nt`2xk8ERHqnYix%+Q$R+vK{BWP?X;fTs&y^BrNb*>4(aWnUwQ50g
z>%Iqb@Y7&xT*Fc%1Do8?dpg-S>H5tY@YBwnGD9)tONP2Vs7>B&-^m}<K`+r7<XnuK
z%{0G%Y7f7Lld|5s^w4MTjmayG$3j*)KZHm7Oe~~lE~mfYd#=!LG#0Ll`hYnSjq$*2
zeHO46dLjPNhukf2S$@*Yx3u-k@R?5P<u@|Ew#}5|^j4w-ddJwUl_xr3FMQW`$%`d&
zY-I_X)p%#COJ4Rpiq%N2xxqrdT6=UZR$R~7%b2dxL5aTKlL1?Ih0?IWSbg~R5&FoV
zUWdu8A;mjXhP3)iEe-d?YxVs&Q{_t?cD(D&4l^}{G|3wWxtG7?y!MeStC!s;VX>vS
zw5|?LEr(-wJnU@&TW}`+2b5sIvR#&EbAM6l73JN=QP0+5d(PtaHyK|A3}>#9XPp{W
z%zT+ix0lQPEuTu!XdStMm6BW~hknT$%*=4SIr)L}XN4b$aOr5iCgE3tQ2FNyBw?#r
zDC_M<T6VjT!33dn+)(C|v&r(t6;^^z<PFJ9w-j+lKcWsPXj1oE0z6T3fLAv$fOQ@q
z&QA|0^VqP5@Y%N^2=l=}amSfu0ppqiL>q9?kTz-F-4ecdhk2l1Y*y!;1J*&{*DqT3
zU5-{hS@OWnj2pK4cmVD4)Q`x3`%|SS>)qFN=5thI{Zgeoszyg&0Yrh!IR@YOp98Yj
z3gj3hP#_2Dfwo8h$6FB40Gz_(KY#vgRv1%cD@9acUeDCnA^`+APFN&L)pvUUE_3dg
ze6-cL%F!&l$1)GJk#i~deDAvpWPc*01J3-;PsG$huif3W89o4V)BKdxuXw=}L>oXB
zlq>AmLpE`T?Wi{J2`}Q{IP~248G!LPHVLP1sdW?kKqA`$1ZvU`Je|G2zrOat|1GPY
zivqNOvj+@kZUWFWhshp59{h+-9Z}=<^Z|-xZ5wAfQOd3#&e;G$Y&kIZkT&UviG!UU
zPLxMB)~!371(~1b^UJX6wd(l+(WAU`-5ix~Vn~#cPY;)(&aiyjmB1i1cWtnGgKlY@
zgU&r7YF`=ig(mrd05o%+-#-pFiw+l(JK26eM`7Cl%)>(fnwL{VY$8+B;?>)Pu%iQ#
zt2gF>fV0Nw40!h$w$Zvj8A)`baE2HoRM<qOuiVr@!F-bm63FBuPRhqJ8`6!3f5JM?
z%xW~Hf#ZnKe6;gnj%nXW3<r$N-|#t)$)o(@)38ZEQcrQ~2hn;!?S9$vx9M-Z$)?nZ
zD+cZlPGV+q7wCv4z-exIn+-GnZ~8IvYPAElkDH!PN6|)c%58Bv0jti_yx=8xV+W$Y
z;T+(`YKAc&*kCzppg{<69Q;OsVY!)SA|NM{)+p^7q8t=3>?d~C6-xhvw&#HDm=Gbx
z&Pl}#-E79zp*EdufESMZ+m}FK5;EIllXT4~R}5o1bNmBZ`vE99e)J&$kKF~pt?%4-
z^nle)uCynRj6wnWyx5?0)4fKnw*V+cPyb0z;&K5Q@_dL*04&flAZ*4Qh{Zq4FbQTp
zy&Rk#9Ba8a)gG~fxpluKqT}0UgQY<GU<BtG4Nb4^c)Q-qD_wg1m0y4JA<;CEIXhfJ
z22(T7II0tRf*{m02cQ7$>x;Fv0FjdZhDun=#6D!eJ$U$K;AqZ$PkQJ~XH}P)>0Sll
z4YsqB9oW2)Ku8be`?*N#B9)=^2iO~Ua|=37*+-8To^^Z%O7u}a2C+PliZa`V&|?o5
zNzJpUo1{E8E~b_p?993i9`$%H1X6sbExy_HgidBz+HECVsL)+U7g#YFqcoQ{5k$fp
zR&5als`N<X+r!1@w5czEqaw6i<1w<Vu>$Bi!xvo=zA4dUQCmwn=ZrT!n)kMI=`~XC
zHBoP9MJWVR9SLbMbPYpP8x|RF(p<jcMP@Fw^PE3bl)KIm9L1wIL(hSQp0IYfl}Z11
z*=s36B1l7XR|DIg@Mc!4?G|ncNSL7#X;4wq`;yz4Y!{#noEu#*lwQG(bL+mrImC7W
zm+Q7V@G?Pn7uZb}K}X(X=Et-#zhI*L?>IN=%Ph*Ff8K{$Be3XJlp#2>j3p;@izK>&
z%6&aZbnJNeY!M^{KHDw`Bx8A#9dGG0wT~Y*WzYrVB=$+oqi=BTHLT~Q_)*YtsNF}B
z-jCkO-v=&+!qDF-@S$Y})=W2n7q)Gs7rn*Fb(Go%%*0KaNAO72jkiEuxO@HJXY_5n
zFSUf3Yd}wLDju8<2fjr=urh*8;$vz(X#n~yLmVBC>B94gGMN3~tsucDC*y|Qi=^g1
zKk+)zy|yg6n=Qq}Kg4c(!4SX}328Ao-Is8~?Ky1`_S~)F&?KE^{iUZKH^!E=6s<v_
zvU(o(vYXe6?ineJk7=D=7JED@s$XH`QLLA*YP)c(W;c@YCmkJ>N;LM?=bG!;mHRp3
zBFk5xtje9mJ<4JtDzxLY+PaY3qGHeFrX|mQFVYk#K0(;N{MbGH&LY*YZbNly!Oq+S
zGrO4Qt=dqdsxIKvkBGy^T;KR=(ceT27O`h}Q~(*H0^(j9ZcHl{s9()nYQku<HI(@t
z)@@;XI2>7SR%lu|WzqVuFh3uNe@SMoKGQ3t8_~Myny6UhE-~o9BxpRvtypHri#WG)
z6$kbZ%2Z+BcWm$3s3G&NU3@MSqrWTgMPL8{dQMV~j&lS6s`YadHK|3@Imv&E`reMe
zYx?&~!130cR=-{CY&6pV%_O5Y$fxX8s*jAxG;N#|+J1EU;vFC|1D$jIVD~K31N)J3
zQ=dO(Cp8S(^s~%uTwWV-TkPw&a3MMjY2I2sUn6jBYc}Bgv@Y^%vV8-$>P#IlD4kNm
zON^?!q3`R<k`n3)!4RC%c&taJiONG}1LJ>KJW!WjB7*bKcUV@vzjj<yi=c_s9Ba|&
zD?Ux}S-d=voq{T>L5rT|jEIhZ(<I0XHYaz1nsrobyTuqZ;rwU}DU!UOJD6wubmM^m
zLHe|A)*repk+WjXpIow^(-b>%fDtL?h=|w5C=<{Y>4LN3r8~8LnLbWxTb>O4byxVt
zqy0e7-8{(UcI}W#UnJ0+pLXjk>^x?lBL+a6@@L3F4#hdj=syh+2|te?qg8L&V;lA?
z#|n?(#BYCcKflt8n~li+cS*`%{b8-&k*hB<=k%L@-|?AVvB(P}I(8GWNFN2gSQ#<J
z@uRer!WjBvb)NcoW7qsrHwH1ju?8upHNU4lrij(!8&VQfoBa>I;8R%*P=#;IIW;U%
z1$B<>6nm-b5*fP;Vo{TlpP#)dAS-d{(Yz@Wrn@Il%1kPMoKIE^Wz|c^d^I#v-QS5m
zX2=-(QMC42tdK_vSb}K<c~MXuz2{GOYRiV8R|NOB3(%_iokDt!im%O@w8nq5Y*ZBT
zynO8l{Zx9hQp$SUQ|SVUitJ|;8OfJRR{e#q$gSRA-BY;7M^I%6(UjR|5D=$k1;%y%
zZ~fstG78$9{XaJ&B3MMat?%-a#bhv(bkPP1k&s-=q`oQ^aQ8M@WsXJB9u_5G7OV4`
z-A+l=Yuf@9hXa0^8s^7i))Xm^qQ-?F>P_(rB%e~lQCk;D-sxq{F!_*F#z{Dvne5UU
zrED;4Tu@7Ul=PK^gzsHD^Se(4^7&N8<N_q$SeI_^-_5<^{Vbf07+xFBYLNLa#6}`~
z*Y5u{*|s)*RfVU{5oJxwF7=vUufT$e>0TlTh3UDk{AQ{4KlLHN0eVqSd*uD%JgF;9
z#`kv_tXU0s`0Buw0>Lv93>c}_AP|Gcv5MIxZcbMdCVv9}(?5_Ztxn9R0RUCC$+}yX
zy)j;#azoPf>7JQ^%ifxHwFem3|3%!CW{?+1jC3cYbja4nz*JQOlAt5WGLVSE9;$Ey
zE$RVqFli-AK8|ijO97`+4cK|F#LsiUpo*KWd=(<;f6~yp_RPV^QU<B9Cgu-JdNq)W
zQy=&yss4-rgb#Hv!8hkY0~G#WeC{I++wb+!{Qha1bVtrb-o%`Y80Z`Km$7CvoU*fz
z_Q!PdUUq)8-ud%`J9`MHf+2S4JV5^PK<a}V3WfHL4j&wWw?#RcUO=4Y#fYT3xL+un
zFC8l}8hzatU-KFdbf+ZXlc7!(qq!7gM7I_@L$GxqEk(5LlkN<no)i2_dH77~N?@ye
zio33a8;C)hRFC*`8SMGSM5+D369L1r@C^~G*JzI%51k^t!cXYFp8&dA*EvkbtU23)
zN1q2mNO&BGfaNu}n>S$D_}oSZo}<(=6@oX<WLqKZwS#8>7>%AblD%VCAp5ey;k9rf
z-9Pd@IStkE+3`LG;oP$G5eMALy|02M6SNo(kO!fZ#zx5=^P;yyWxAs{IY*C_ErF>1
zpWjdP`pv;l|D$eRE(4wr61Wz5KM#S|n1Cy-NB^sJL`@h1iPLLor8l+*1UjD2gVYRy
zk7#o547vf}ge>6?I6LuVCu(=0w9*#sB+?GxAQ9`+L;#ln5|1B|dt1MgMDPaz<NAh2
zuB!v=xOy#Of(85l)*XDK*N!DIK!E_zC_*9?;Gtuu#=lJSO&*w-)^9{C>-_V}EhMnc
zr~m%bIByRmyQ;nf3}++|??w#)Wbs;>EH#;wc=`RqmnFyPsvidc+!2gx-n^6xgU^DP
z#-Wt^+JZ@?rDBZSD2PaI_9cnr2N;9!)^=_VF_yAg3sP1War5q@>iAYV*~9h(eecO(
za4cN@Lbpfj*m|99iP@G#jkHJW&z-NKkXPAel)k5Gu7L0$98iH{Ca7tmlfe;y^YOO^
z*h#uLfSw!SI8)PWw#^`5@S9vdsPSkeWhqq+L=5lzX&)Uc)I|_mFJXxCU0!a+Fz_p`
zjvn#cUC0c9HVjJR9+?Bp_z$EKgbmjSfX%#;MM5pf-oseuOX&~1R+4P|_=4LFS7`i*
zb$!<D)QlB3_rZh8C9sOVx#FB6WK@+ybJ?5h(c8Cgks+M^Q{<5f-hjGcU7T(pl&R!>
z1M-hk`;)~4jQWahX2B&}+s0K$&5b=F1+x#0p@Ql0y{!{%0p}S@`1Mg9bjw@=dN5wb
z*K@w&Whd9!qkN6je=zr9#htvAi9n&b%^}|zkoxf%OJKZu$h95(lg!-eSKLmzu0gSZ
zAX=S{oen_!R`*INN{~G@ocL`{F%nHQqQn{3KuncSD?@(h<=8TSqa63?c{D^(_0AIX
z+-je^j==+b03Zd;(Ti&92*+P{h+!r^bEKczDrYE&5T$^U{+XA44u0(wpsv>TE9=>>
zG_Iyqt7ngWD+I)iPZ(L_G&l1bNTcG5V}}6Ci2}wW!ffgihzM9{53~l1>%r;l&l4Z~
zrfq-?;Co{0Uz15;p3_#IzJ{^6#0N*r#MTXrf(R(qc@acn!~hi@=@;Ieu`f@O#<hs7
z)p+92j$3W#{?fA`vta`e%<CS*-NJygqaM)Pr^R{nV)@mdsPo5ee5V!?1r1OnmRr4Q
z*B98tF`~$i=b%)v^F)VtPV>#tp0_WEkD7A|zy6dYZ1rqtXZ-03uoo*aPYKi!#oU>0
zE59q%+s0dT39Mo!k?!7OIa-9uJq7i5V~-3m%dwiWs+b=az6=zqwn>-IHoVPt^gjcB
z{<LwR6bHC3Jtu%_+O{T=R8`ePwp=ip2I1qAX{x>ip(w8wK&rd%Eo}f^wWIkQ{$0oS
zEV=>MJf}$vy|xBdolbgVc|z1X=i36>%0b8UJOP;JFbl+@Zl(OK2Z!|9%8yU_HK0;R
zkeWr=-u;^FXE&QF4ObFvnIIBF>_fiPqi7u#b5Mopj#+sQ-Ag@DA?yY?`;>_#FlctR
z9Egts-|WVs!`hv4s}QH8ZZjV4JdZ@+Yk`r6S|l>vPZRrKqHQ+Oemz}(Ds`?>AX!d8
zsDbp_vP-f*D9aPn1~{}ti$qPi)3I~^0`Bj>E`?c*npr6;Chz1rPGQ}e-Pf;)vTauN
zL920-WiaUu!mI9Z%I4q4r480u08PTP`pO)iC0T>3T!#Zyr4HCMwzFmqn28dq>K$>V
z1qWXv;*%m9j}hzeJglT3sIkjVoJ+Zgs(5u=h~4LsrH>zpGbC126B|-f>K!E=SQ7zk
zYo4>g+Sk3;&Rxm3>=nd3+;@k?6BuSD?T%+OLyk`>(a673m9Oyd{E$fc!n=Iw5@Yz7
zSr7Jg{FkxtaxE5^x&KjaKq4TUd}!a~HrWJxO6Cn&zbV@6dt+S_u@m{igeUB)9u9t>
z8*Ntc#!fdQFwt@IRkF?9(+zK5wJe21b{I!?`Db@@!`t2>3{qDi*{2_n&C8;T<HEME
za}d`J-8ye^m;E!4$t6QEX)|myRHbAbbW?JPMD_6kwaSyGPa_u^0IgGH6^ak!f!``N
zmPAvZjwJ`&F?H(#)Bg@@gG%U*N8o1ibM6Fae2SPoQ~6OY5-yl>u>4?5u~uURBmh{;
zjS`aSOkFx4k1<scvrWv0YQR+~H=Ji(I%)7++*AMfhnQbr)=R1f{sD*&s~gbq0a*$*
zK;oK-fkMjUsye&zUqCY&$yi#?0%EhpIGEv%qcjJ}$sNyd=vM4`kw`8*3}V<iAF<J`
zXuM<(kOAITD}q-7Sw|lMB7EO6mO$xr`GImedkf}e!rJysd=0Ir9|(Zaf4k@_<QgQF
z5)Ywf>T*Aij%%L;dQaM#bHB8jYkc|JrEbqz@QLsG!~_60b?T)YAo5;>z!w*hHECoi
z<pv-{?lfA)_o|`&T~K~mZ&BTF__K~FfS6E-1UPK%Aa5R4;N!-}c=(Szg26$%wF!i#
zdC<=09?_;1rakw>Y7e&hYB)#zAI|n)f;{B_G~8=+VhIrT+TF{K(8b=#@P_sfyjX|q
z`*<A4*Jx-7X<irwf<`cm8C=4BkIkuJj<8uTs&@PN{Fzj~S_H=05I{JrWFXv6Y*N?F
z+W9_Le9W%*tJ<>ICYdh&?Odw~o3Z;v^y|5=TFso%E#5!9*R0hVUbRL_CYZXawzvsk
z>)pSN>@hBTk`CICavpEp7PA}Um5$s%^WPt<cb@kmT<?Frf3J0yP7E332}p6n+}Z3Q
zfOyRTFXooV2!Udr9va7>_kEz5X_`rG%3MNHz-9eF`#bKAWM^}IG=2#Q)TO0T6Ub!`
zDC>rsZNOBva@57Y3hw@J5O_lU6R5mSp+XCEXx5QHb!j*xJ%-C5kSFz0W0QChDt2Z!
z>ciHvMru`=eEcE0Jwc-=_6biJ+K0L6-7saCbkYz+u_5d&#I_~)z{54SNdav+C1ra_
ziH8S-ZFlJM-<r~h!nKRTLfVhK6AX8YfmK_sm8ozx>HaS*jm*4A^KZO<Unw;Nr}}l`
zebwoA2-5xgUyUrr96gdvU<QUVdyPPp0R%bWv2F4ib6M(+2;<!r14{s2^Vu4HwIy3(
z{U*#(fn2EpmRk)=w9-xh!#Xg@gA9|CcdgK+M}Z#99+^STWg>Kfa93zu7NuV!E9_SV
zl_E3CR{ha{H13YK_w1Qc>ctNt?rU1o--NgB#0Qp#((`mT{~Z2NM*0<fQwbDXHX`k#
zH+ZIgEYYOZXlg#J@;>1odD4Efwx_P~MWksd$Y78rJnx~j@@z`>G}fS5DpkzaFbdM{
z{t)>9jj#YPZV5|PE3|udCMw8oI7?{K{!<Dmns=-iT(Em*=R0}`eKLb6(@K@$9isO#
z9jom1jb<;Zvlc}i#PR9=i6}+{MmnQC(&I=}a$*SHuPV!8tBK`xw+vcB+FyCuuN7#{
zXGiuj8!bwhAI)jz0jD14+fCYQqyen56=>{2$NSr7n^2eBly2zrsnbaP>dAidjv@<|
zdGyYl^K3-9mG@?4&!)>vo0l_^Z#xG&ZepmjOE*C(&l0iqs5@12Z5QL$O<=pkR5Awt
zD`P(5<FU%>^9Dv?y|`Y#a>{OJwC~-LI`jtdRGRjSDOeN{&3PZ?xv}x!0iPwK*GO<-
ziiV}_GT(!9i~eoXUyVM&x?1h2SJv7Sri7KG{qIY?9SW_?%e?v6RW`O+w><VM2$24u
zezyL4)b}OR^}~_gaOvqG_ZAlUUq6RZB_zr;NXdkbp)K1Agfxwd`v~6@eO@eVTCj<F
z(_??!5cPIrvON7Jn?i@qoOZy@4`xK=ipDYkAxRmO3JXuBO*1t<DhA5KZa~s5+nHKb
z*_x()BNrFhAxG}L0rPN3It99&6GAF8GZ6$6{Q%OAY#uBW#@v(PBaRZlK1oMtc9xhn
z3LEW4xpU@7w?*r4C#1j^>TYjPYW0=Gdcp1$e`<|4hdaWq81d9+R!!>&Z~v{scFBVD
zO=101&X8(LAO9uhc75`EXiaT@v$bp`mEStyE%OdlxX*#_uh-h1AK+|s%!jW1UE@z|
zl$MiM?NHReBaZ=8I%R=VkzVwi`obD0G#MR~?ACaX+F92EcCrr7v8e7dnDB=!HM}HE
z*|1Mvsj7E>EcvSY^101uwU3|&st4c~7LW2spGP2xvy(i_7dtlRH{=Zcf-i)wWqIIa
zp#1OkA3v19mLre(^HBADeg+m&_ituezXmytrYpXp=@K&@?EUyFVeJXY86T;5mFN#g
za2+TInQeFhqNFO*Ju>#%4=ilqmyFN;#$TL_Y1=ET+bm5V;Ow(VCMUmAg2i3hvG*0!
zpVu1}B6p=E#%U;-AMRU!l9WpLSLW*+N{v;n!Cu68^~~KId271rgZ?`r88<)!lO%DD
zRo&0na*E$L+&cX&H9uB|7?e5aN-=cpz7Rv)$Wd~CyhW=bbyfBA3rHGZf*3j8{2wP|
ze5EtKTnn^#sryPggEwb(-fR0b=4Ho*rTZWA^)3-Z6rO%_xrSPIzi61XsH>5ZnU`?{
zZw)}m<(~3TmMO(n1-Eq2;X=o2Y)84wtP{%0rI!kOeJMmnlwCE<Y9mdp-)kH{0aC5#
zWqpcHHZPqazBre_a^kiRGQW8!GsvLnA+=}zqmd)!WSZ=oCOQq&kwCtButu1P{K|NJ
zQ+l+w!EU4LnGUJBQ+odIP?y;sZUuu0FPO@MqBHGkyo9W40$eN^K`Iek4u>nwbGMb5
z`=N;-t^J(kO43neb7Uu!?QTWk3%iR*K<1d-uZ#6~c6!xcRlYzyIV)H}p#!^&@qkzW
zu)LZvYWU?lBm*`i*a$d<AElB^N>kWsyN~j(`;)%t_VNUL$kv}Gpcy_uAw60=%0ZSc
z3ORPIe>K7rrVM%w*LE)Vo>O9bnqM}hAKy<P-o{DU@LfHm(mx;fEi3V9%Iv1|IML^}
zv&0x01wm8#e0S9@yi6D`cUw?dpW3YI06qzW`*lb<%(`BpV$F$vqeW7umxV$F>f>>7
z<de^BH{fZ-Z|oWhS%OqtT|jf%?~!C5U$7t$k7!8a*8KMHCDBkL#=cM@TF)XmRb+-*
z!C=GVlsOS&#QnS8bk)%>K#WNQX>J}bIS?MJV{Yy0cAl=v#r8wL_>>S)A{Llcr}bbf
zuJK%El3)$Ef<yV&XjhCzt4Ut)wY$#_+j_L3st2S5{;U_m`Sv#&fgglg8WU<evGnEt
z%ISZ2YuSs~1F#)Jl^!0L()#3_ktSG^d*P|?P{w0!0Dm5b=;DHf?I-S`Oe{)Pgupt3
z3SRanO&fsP7jcCL-GF6{&kI-rDBwsJ1twe7c@&$(z<i3M-DurSfRU)BzxkS{-_-%8
zTv^+J#{Sp~pdMs&689YZz`U;Od9m-#Wbc$d-0BNIcb+Z=+Daa<Y*dfaT6>DaH$em#
zU%!fnY*04XjTeP(QR{s6k*E1@yKHd7N?)dvoan`Y?YPH7r#1fOS*Hp>;|bC*AH4@Q
z(dLljyLO@qj-66lpM0EXHv0!1vyHn!_*SB$VTP0T`u+B^Q{cY*V3SM6n)IN6l8|@2
zBbYqMhHcU)#Xer;EHhL_kRz=34T!spgu$0Yk-+i?VJ?5X@iQ^>oKcPu0m8-+-g#f)
z#<K$4xTC}di^!Pw@$INbmQjXMZTtAAC1|hxWPiFS8T^Z`bj8&OsmUSaykl(O7=Zx1
zM2GV<S%i<?YNRa!8Cr5z*;t6=i#`^x2X!*@+sctOgHn_&pg7fhhVs<e2rgg~=ao=~
z$5mo_26gVy@l9vRSJ1R!$bD;eI_;q;FxQBb_W6X(F@WgUT_A<BxF!Mw8tgX+;h76{
zybmZrA>d|FlAfE1>`0)soGs*;g0&%4V{3$2Y6<^Z6);XmkqBRDbx4lRdyVhs2W{uU
z>`H+@iDY7#K;&cI;M}mPZA}JrjC+@v8s0J_s)TFU(Njl4mPq5MOgFj)o5RsIpm7qn
zRRICJW-1CvX_NIWi2X@i`ZHVjBrz2~b~BF6jCm!n9PDgPIZ1%@;q{y_c7#T%8n_$7
zj}8~!uYku>)A!J0LoYUYwuy@A>D~zBb;Tg_FF>}ei82<U9@>Nhzivh+7O2$ZO|>^>
zD0r+;!-}>A)RvCS5GsZWRA^Ak@TOZ3EN;zL#%nvHwebqJN~zfL$7gOJLS3aR|H}c$
zbL$m%40j<RC{72g%z!ghFeGlzwoSTpHdvIcU0;ZlJU+E;<LbZ*&M@DQa{pOk-i9^>
zrtX9D%f_BP&EYdj0e~Jnjj|_Nuji#p#=%sKmQ@JMjmONyfLn7C2>9Bf>Pi~{k>o<x
z#q$5J#QL#|;FRj4<f(qWNiSe~Bt_fx*~x$1mjEVXKOo|cWKWE@z*giPRYJ&{^@l}n
z6<TEtf2auT4Q`F{QWSKax_Yw@la&fyMR!lCYeN92c3BNLPF-8k)frT`n=Eq#D?&G1
zeYNG)Yg)Yq*?YoSUPbK^4sa6Sf>-WN%1XyAhm+l5CW=pM1KDmThdX+y;Iz*$gXBar
zR%idtEk1@fERVb@5L;mV3g{JZHNcskq@Db*^GlWIee&$WMHx(%xMT+n%oOu<#5eky
z8W5tgSk3!9L4Xgn34!l;0`)jRNweU0tX3KVZ$#W@7IB;rP3ibk^}^kCqDWuB_gZmD
z@!m6LRx0EPXwvwAR0sQ0-i4*ANO!m~MwulrlYw84ci3A|SnWRay%NtCDeb5|QrVaz
z%(5Z##SY@e=-K55rF5xk0zb3gspW{a1pVx&>jRv6p1jrlL5B3~mQy`SgHde)UqCJI
zXf9&?`_o32bfIaTvSpI#%*U3_klnut<}-u2^Y$P*>)>h23ryznQ;u4>A`m@@iHCJ~
z!Ez`>+*Z_5U>VdDJd%WO^5|EwL72)H6K{ywY*UYM{i`(1ZmSx;!)v4+RCnxK*L*z!
z%^_=hh!7NWPMlU!8dUzu1_E~<oq@!k&m8p8Yd(6(**jg{^-ts?^i>Y306#rrvj+bg
zX<s>oWOSdb{0HLF)ouDRH6_1DCw9ypV=Rn}dKv#4U->KejD-~HkGzL@uS)!Njl~h1
zs+7p5&sMoX;<vhkd2V6s38n&!KKwp0bN$14YQ5W|VZIQ>)QWnXvwFqpn+qx;4hox*
z^{r=vyU7%;25ikP6U8b()l^3CS@AT#{6}eQu=)EgedP!|a8_+WM4iL=<o}k77hQKI
z?I%9Pz#C#mDw_Q_I*GZ>&EPDJ1@|geV3JBMVJymH%~KoJgG`xgp)X?eq%OGeR4oeI
zDYUM#&s$~O5vPHZ=21U_i0%34RC~LJ7$iLeVq0|wHH4J$=}eVXn4@^nJq|0~V7t87
z3HN`+f5%scT=}yfY&-b_9R>^QuK5Gi+hbR3k_nM+#E-1fGA8boQ3$?=UU9dXLOm6K
z(Bz9H<qGT%XggYABb2;LkXZYhn~{_JZ0(P3XTJ5q^WE{)@s`fFIEuce?PCzL-0UX<
zDYBrldu3WiG+=wXPTkP`EzxJ5;eKp}w)kc*o@3jH(_vQ0L>e+@>{>(a*re0{WKW6n
zh>L4CY_N(jD7ai;F?QJ$go(;pPw^=6>&#x+%FKqqbrwqsgrjsnYToJim?O#-1;P2>
zn|-U^Ba@J{-W~b_U+N}w%CtI|?u<O%5b)K=NP*a$6@^rN_i*^6&+P|r>TO3l;5fz6
zh<YE`5as&*I=K3Zf*7S5bS`{!M@2$wZwOw9)9R1k_aX{9vW7k1K;{%Fx;=Z3Z}y?8
z%sD+AojkTHSKt3eTIJrtN@Stgudc~{Z7Y{`@=pV|f%#$ubbe<}VoJwx3pXboD?<C_
z29fq;HTyzQT(y{dzwHi+Grbj+YW0yAXqLPD<b_$Q<eaWUsjCyg+V_IY(9H<o0T@ml
zLl)6)O9E>QpQ{+%W3EgsKZYOspP#}5c0cCm(6AUPE5V%@Np$JEfMSvu!r}9?toQ|*
zC5my<Pec7z(0ETY*rrLT(F1G1gc8I%Xj4qA_Vv%C8i9|$YK>hs2)sG>z_8+e%u4Dn
zR<{=QFjzZxOgI;Wi@|iHE;U(iNvX{qc7xArwZFw<>|QU#Phq?(nyBrG_kFsv_P14}
zOzp`*Gu7WDo3u(gN9L_8<$k$q1T&AyKX{Ls@(;gG!fMh!qs+O*>~F?csrMrSla2V~
zlQ<3_l{p!ab+(Qus^el7ZJ+FUBudG{R9B?dq6JkTUG~G3U@)pM*`hT)N9E7&m3^#N
z#F@9bq9QD-`)}8J8T%Ncfzibn)arb7%uD%<e%Bzq6>Pu1;570v%XZDQ%PP^%3(~<6
zaPk&)&p@KFMpLseBQ%n6F*&dqCnh;x*tbjtKU+o2OVhz4qroXkq}2r^VAJ)es*1`I
zIey8HIX{z7XKc~YGFk<@CN59LfCi`d*7s%vZ^oa`UyE(E?51mMW81uJm44!{!Q>m8
z4T_#bUt1E`?XvP&H)8JTfPRksHST}Ouulb^`s6JSo|RiKm49y7y`QCpnY1kJ6LctB
z@J<<4e|^O+Ew9bP#s}DW+%m3#%UWVwV;66hCcpwOq*fG@hb0&0GKyi|cEA{W)l0}O
zd0f5^*7XVXc5sMwaif}n*jJh#u$m?|l0sFU-K_nxuxu?O(<~g1-h&n5rm(p49(k*&
zOkG!1hJs8>|1<Xs*^};WTzq@5rUfh414*;8#)@LL#Nmc^SOFri&PGO<8uDVSM%VrF
zbAD%~uhMxr%Z*V2X!dXuf5A~jW>_2-sy<td7xtprd&63%WS}qWsKvHbrYnf_kjn0j
zIm?T#IY`)ds|9{(A-<Y){V%Awh4Fs5@t(`G-LD!EAu~*jL%Pb`*UD&L@NW5OBsrj)
z+RchO|2hd@ls+GA)M%Lb7?><(zk<_Je%$wlZ=t~Y6yWL1^ZMd=#!3!~PZz;lrD@!=
z&)v^sf(vJ43^>-$#q;luT|n*Q=@YB4f?cfPP%Zt-CSzmV+X|vHJBmEqO(q5JTcnR7
z6o;Pc$xo*G@mfiL5q2EA$ipyK$}oBH_Ec~xW?Wk)P#?H(W-_-7JC#_BGlN*sv1~Ni
ztS*^rLG5BammGu{wtO|zp{Sp!E<U!?jGLi9C}E;;jTsKNhJVOg8u65^=#}urD#QOO
zCixX<GZsxmZ}AJz>$LH~c#8})3SzD2UQVjo-!E!j-TKqKs2e713S&y>Q@T__nVVPT
z3cw$QBmV#J_U6%8u5bUawAD^&q_#?FB7_iyNV`Fq%A7eunTyC6YB!QpGTbs`xXtrC
z)1Wd$<{?9qS;$QIea@TxJl|)ncfId=*1OiP|5CW_>pHLVJdV$Fgs<H+me-IOQL%nd
zdDCh~hcxocN}9mh&NxZS{*>$nnU|#z?|%K;i979kzIe%hd1xJVIWa~d*~PtZ_B`uL
z)_~P~`-OzG&smpvg|vIwDG6??WosNO$d*d;qyLsTy0M<_SHtm##<ObG6570n)s=;s
zM&xbRj|bMJ91%WdrD?e?CDbMc(y@~Hgm|$brj^1OH{AKzT<H@or0h0qcyhDo%PsZx
zp_*2Yq}EbfIr#&D2b4@dvc~fT_C@yPpLuuh`&eOoAP=K1w;OdxV0gPiw??0fW>TDS
zl-TZHUUA0bVhSd+tH;|`>{xEA8+PDSkXGMzL2c=S?%f_=J}Mt#n=G8ndj8^?+xM`T
zJ>GYj4Hd1FbF-^UI92BE6z@pQcU?)9it9Qat$9G~OzyKk+1U3C$_utk^K5%%8x{Xd
z+Dd5u_>O4GB{p%p^tVROTN3izWOg>5t-8Nq&+pOmkB_@=34;P=lK{(c2oosxdv7Ug
zTzk1!c=?HC!opG2t8x`2eU86eZJMyB?Ssmu?UmxpMj>2Hq0de+Bwepb$O{nr@QKaj
zQPR)}PHA`d`%v#Sd4+SV<sL}lu+6PjHh!R>#{8oCdcB;IEz3zx>9SXfZQF!DoPV^(
zD5U3&?5JAhnjp`fH~SA>*+3Rj%jP=gbK|?OXX$Xhm}!6B{Ibqroc@PtROCJuoBC6f
z!j%k{#@eoE!5g$Hhr$#aaO)>WoY!fCExaEhId+v*D{ZcY^>xrL#z@ioOr`3WPT$WY
z$o%7Sy+2tc0$Eu_jXa=au_yP6nuP>|O<n%!B3X;5mWAxRZ@JInI&_tKvj!<D4=1f$
z)>@73wdij*hM*-rSBTNg%t=k;pG*y-KYCr~=AR2ho9vg`a;E>x`048<kwY?D_Ppf#
zXFO2ORN~cz>KmbA&YFB|m+HjhDCvD^aaXTqx1TRa=gZ(56aCw$F!DyrmMa}mE}`^0
zS|&|9VsfQg6j<J$SvPy@LXCj*yRCD+<J05kH@!s0LGz$m(Pf6M%>O7-)4YcGR-b15
z)Uwd;q^=`pA<nqNv{msSM{@8vYp&wNOKE)vNkYTK{aB!#9xccEv#DK|D3?2j4x-y!
z#vv@!Ff4YnchuB1?%PYRO0kfu-2(1G=dJ{#^Ew3Xj4JJxFCW~crot~@bh!TM^$x#=
zaLW}v+fTe(!SI`Tf6X=NWil>)TRH1;8$>-U+xxbkEwJz7@XFL-6Sw_*ts`=xwtZAG
zs5^%mmAi_1DX70d?e)I#{8J$(G>lpjuWwR%XU!H~ceJW)pl&iDJ}aW;nsTj5!wWA7
z#;};%9KzBnoBbLdBS6D!mDSt{w%2vnZhzeJoHx?(g_tf^;Cc5WylJ|P*L9@NSRQRl
zuMxhL$vVe37FauUyo7Ub+w}?pAb^m3*p`)R{Jm^VgGl_)$)a5@oSMfp8z6ybwK1#I
zY7Kpcx5sdF*%@W{{_A+Rcl@(z)8A`_;P(=j+xr*_*i(ms5NdKV-}BSQg|}Pu#)^ti
zO4$z;K(X~eK?uZdAqY2#p43y~H_?^sL8eig(a+|zcQ@chToI)E^K*_1IQu{I=GX3&
z954f9{oaThpnw&m49B~n@iOTkrt5M@S>BI8!rZrW9_!T3<&M_MeKJ17kZbNg+hMbp
zBn-TB`TBr!Bb!~Z+p_tp9X(*)3OVE{|7g!6o2C5*Z2QecgebK73^H@}UTdzc+573d
zLE^X2_ZuZG-fLkTggvw1swW8@@@eoVVin{Ye($kGd(;6m+Xdy&n!N3#JGTM@r5}}H
zH>jxx0q83QB7Q4GS0=7e4qZa^eb=O!K?XE2f9U~px$UK#Z-0$QEN**6jkERUqlgZS
zsIu)WUbc|k!g=yUt0gi#Zt?jQe!J1`!1>8`3@ujcq*ZP&hu-N7<V|(p@^=0b?`uwr
zB1+c@t3l;_5%Z?botE#s*ftdT`A?5_&%Tpz_+?nF|5@O8hyMP@M}OUC>jIf^cDNk|
zP-o~{*5!3Ho|x5U>K}(Mbp=~PUebf_LWo{EHm|Q1f8j}|3)`OboquMSlQ<Dxo!mpz
z*2$!z`Mz>U(wl6pp*)*uh}U>_G1xLBaF6s_J?p)bqooD}raPHi<p{IjtF?JB7A+*d
zzRTn>nJYfAQj%LeaiC+z^2g&_`BSQtlXNAVJejTon^?(KcrHY8gX;tmL8d21#Xi1!
z`<5Zd7@x(3Q{ly*;x`T6brrhI-hEM+Db1F5f)yg|Bq?|LU5!t?ZkNafic|*o-_a`4
zq;e@!r`~;<KA!!>won{K82iz)ACE{`KN(?&5NNxmG-O})&!4K!hq)vS@APL#H}9i(
z^$qWhbn3j)J!Bf)qo90|Um%tzLfoZ{{!`m|qlf#Av~T#T9MQRP`+8P&+mqGIgHwsV
z3Nkf1C)?^(pD5Jt_{64W#1{SY-cOOf#I)4&e<vJkb5}O@O||qf2|vJY)ZX(kf>Iuv
zqZ(ZmC2quhAWrOLOX>A@s{PVj!<xs+IBZVo>pY_?NRm6!c1=~}>Cd0NYhU;(-#GXD
zc;t_BWs}=i84dJ)blUr^FRkBcb;I71tY<atvI;YP&u9~+`3)x9%ZfM73*Wq0dH7L(
z=Dn+I+p-5aQgj!tuhe{fC$}{&FEF=X%&PsU)`AgKAej&Drfwc*%~0^E@1*>**LMDi
zQszI7?KMF<!fzGthEepmS08VU%Uor|x!-J8O1w0$pX5EtZsIsI*4Y2-d~1qe@|eRI
z+up3uqRjC#u4yj?x72CNH0zpDqs1F%Ud#mbO-9(RkDc&uxDhd`pwQ(OXcy6({jw)3
zA)cd6pz-F3O0`4s^=^to8fA7@M;SA{>i#(;FIFH=71}-6ojzpSf4rHIG}Dn4+l*dB
zbBZN+6c3f>@&7sSg!i-4gHI_R9&L;5%q-+#+Qj!-rkQ;!$Ay)9T6}$`BdVzJn-Z40
z*ts-rJ=dC&I^{FYJSDCY#onUMeMxQn_E>BEL}y#$$zQDbtv1QuC=;V)YKkVy24~Yl
zs_kN2!UVl+D;Vo<U$)M&8oc*hIDCL((B}DgSXbrD+VSA7xWV0@9po<F+wnx^XZNGG
zxn9Oj_v<BPi-e5|WA5Dkc<Fk3*mS?Gi(gr(ns1@zv7RYv{6VI0BPP4}M*A|g#+)Y~
zEuLpkt0JnBo~{$i`ZOZh)U9ZjFIeuA5@8`VS|{@J;Rnv=si|XZ+$UrL?o)zO@7I5>
zZvB1mY6r7<(WWyUIjN0xe<*feEh|=13oLECTx}QLVYYwkxqc<qD`ih>N3`Er4{D{a
zJ)v`>=dT1?A^lf>I7vnqJ)ce*ywLIZrr8XyeO051huk}57f!Kr_0!pc7UQg{-{ju4
z72Eg{TtNLrnBIpS+obBQE5&pj6q{B`^SD@fPf(04{kl@v?sm8zh|rPoi_^y!b>F4N
zzokD`3O&ymlhS9qruP}8zVGfW%6dhWzchmQrdY02GjZ0pDcgt|S}<C3^+XgK8TYYn
zeqRBtGhV++<uB*z|59|hU2%Fm175K^LdTOTJcdL^Yl6%e5}v0-wx?X@ykL9LTeSCP
z^h05uTB&g@w|E5&>9VgmFruz<Tqd>R6f_DeRYH{+LhE0LWVQaNkTU6z=~f$2Gt_mi
z3J9cVa<4v9xxM}<r_hSt5!bryr%U+9@5XgCNvTB{d$mlabS!uC^q_jtRF)^*s9sW~
zC$2fs{<eF)$u&p1-j%HX6)qS(^1qH0<N^*Xr546#1)-EFTsR>O9*Y5n-n)Kd!zS3J
zF_QAm?(p+WQi%v{1fr{K<GZN&WThBzJ&f6l3y67d<OriLpYY|?w14u}$05km{O#%g
z{(}B5g(3d`%3<V^KEP@B_06g@ScKAWUW@|T4?t?5KO~Bj-KQS<gAegX!5IKsWgsE7
zzJpouO<PKdG}t-SlJAhlD(RffD&d&koMol={tGec&T8X?t<5k~uZ5pM8AsTK1506&
z>(9NY>K+X+Y=QRF0bbzBXvJ`%CzS^XDhI1k#Xdi6gIM(>OHe_^(5o8~X)WRjFXDi`
z2s6JWQGY?EXq0-n%JOIasKO|e8vzLS3am&}OVFHfKrn|%!T!a^8Xy_GQMEG;hgBDH
zuZYY`Agj$T&;-UFCgXjlkEcQ#OM$O|0<xcidH^S>mwyF(AGB|m>U*mk#%-D8)=2Up
zK`|ME%GjV-Eqmz2-JLiD*%sij_c9h({9SHM#?HG;-cK!l&iCxBdL;vGd5r_@1>z0Q
z78f&}QjxlJ67Fcz<&7T}zsuX#Ab2EFcl!_Mvr>W&Eq&3>JqfCr)^3zW?;L9uzbMth
zP>3&H4$*V$jl6Jf>*80><ZabMwQ(4qT8MPgMAF;)IVUX!AzUAPdG$RLkl&XQyd-VD
z_;%Vr`;H`JxL@_tG?)FplH2hI?dQCIXnJbHxd#rV>TnkuNSs~#;p~IU^@!SHeD7k?
zr&~I|B~2_%M`u{($<NP{1^s9oauWZzGqCtSyhnrzp;|Lst^;|Z0Cb;+2)bWHRA8jw
zK<s3ukH7HZPxlsd=QnadY4;wqQ?)h}fveh+l%u>zW@Z3<An})(7XM=ef`Y(R86yIV
zs+DC)q6SyBTean8xX>a!B+Qns_6NNl40u^ph$^{SJqdDHdo~|YO&6;Ey;nKKD1PUR
zLU>eT4MV=c-d3QOenoNC`TP4P|M{QPQ6mnHf+O4_a<Gg3;^I%2y8EYdJv7Raac(Zj
zo=K4MwRGcgymM?=`u8%1LQA-2W{*Oo4h>;|{Se6u*j(h-YMIB|@b4R=#5WAh)r|nc
zhZE6c9ZXSE&XTi^5Lj0Le=$UMr%7UNA9pR5=Kr`TB5J9QLn@*%v6K}z!W>b7Wh)2x
zy#joq5#ZnH_{FC{S9B!ALoU*dD5;UnM?r8B?Oi7Cug?LE8bj4GHye4$rAL-J;<KHj
z6p3P-v)Xt@q&BVvlbrl|@q^KE?dpQiK<iTW$<#A<mwrLm@t3@d|7<7|vtvrBjsHW)
zF;~-n@3h7lIf|G<pa^eRBN1M6z^%8CsF7xT!1%u(X&lzVhJr3=zAH(nLdt(F3v2fz
z;PBH6J0zX$Z#BMnA!<WGMhRjPTl{fZr3U}r@blLS|GJUjzvtb;+Zu%+F_!WV#*7gB
zrdC1bEZcu-@k-y1jrjN*Iy)pltno?z-w#=Ep=!tC<(~;CR)=78(B^-9x+lD`DU09l
zcAdL^xgIo^X;pa5&JAiTr+pv$>IY|)-$6xwY786My9z}74R(+ywzu&XHXk50{uF;9
z<<;goE7a(zQ7*&{U|hL%6np_~a|O9ve&|Ydu@A472uC@|6Q-kcTeEq}v^CS>WRfV7
z<b=>MoKYG5oUDJ_0kwVwWZ0LG6Wj0V0`unCwa#4j4S6@Lw)wOo?C+KlsJw6o)ckUg
z-G^%$(|#VEVRA7z;ey|;#Isgnra%<^WRpePCWq}JoYD<bK_zF1vjN@&^OWD{Ndlp@
z+oMq{<}#DcWX|<I@<;52lrS#j6EY<dS85kRywWr-%KGsMi(0?QKeqUL=px+wPhNv9
zpliViZ_+AV*;QqIBtRzz+6v-er~tz1Jy7gNuS@uB5>dlc;Q(7fJvy_J->{(?gE^ca
zvB&shSn_ouHZ4+GhS(tGab8<g^Jp?UlQh6pw{#Of7~|;<cEDNl*im=!JI=6iwOF1T
zPtCM!Glh*#pSa}&V<Dq#?!NFx^Wy*UJ}y*f2$7yhwJKGPwKiG*L~Xi>@`4k{A0c9E
zz<n2Db!Y63%ejP?zY?#gUxUZuqjpPYbml6LLvLgZ#eEl4t+K;6!Izus&yf7sF$H-M
z;+C@+?mRAZrJ7xt1lW|4OvCDT=+{i6V*dW^MV-UO(@Z~W4IAt10=oHc3?2Ce^7G)^
z?EaDvckF1*i!5zCND00&Gov?ZlfK=tlK3*_79hNwZzSsHonGy=2e&qST5#ql<jj<~
zd2V1&lb?<ASO0Q{Ke|u9cx|owF=IvJIqh!i!J9|!eBIE?F&s(vWOMv~?Uy&kQwdY@
zEV$Pr=bM*!1-vHm*ib8BP4sE-SUd&X_TEPVwB)7}EIew5&^_mA<k=-uT0ivgNK49V
z-Y;}kp523)%K)eG`n2g-^>@e^dgb|-z^k#IPkUlbxN4eWlsRcwL;@ia7evEej_<<b
z@^I8#d<q)J6ZU`Q65zKSQmTh#*)W9V;IGn#hnsm#LkfD$dLQ`8+P;Sh{IcWZPYVb=
zwmyR+i1tTGy&_O7_RoC#{&NhgJ#*+TIEHQ2;C_=7st%iT1>P$8>cwh}{q{qL&N#Sj
zCo~ua_8rtRB_VJ*I0QH{xb`WO91zxD6QRqI1VT8?`iIOYazOldowyq@^K0>KXSXwG
zuTv~w=hMlpTeIV6lQ#5ztLV>h-{eQxprtaZI7IjQ-nz+!q#c`#;8y4&a$>9cjr}m-
zx%vYM2tc+~$02a@=~f->3o|5T8tu2ma2zb2T@c)+E=#>=A@h90V)^8D;KFC(sTDaA
zv4ahQ7t5Q|KelLni-YjZxa1at$bL|y>doyN(~QbDtMVp7X>phBbV>YMk1ewcI}t1j
z7T?LdQ?~qT^j}2}e{r5J5Qno|u(@1rsj7Bcqy1S@JyBaEdc5=YItu*9Q>$C6D8l6{
za<P#buP&9|G-f@jI5K@z+ubD!HI>~9Je4<21rTRGP>|(A{)Hjm(l#&XT<X^d5WqZ5
zn&lC{Qp9}{?nAREshuiSFH>C6iAQer>qq%zp}D69$g(iTt3^fOMa5pe>vn3Nzdlw1
zsllm`q)do5lrPpvHP=f0)Uj*H<6o7nH^2XSbLz{=Q6M4|Qkp@(9%%ieteIUcqV9pa
zn9%vltHtdG4kBmuAQ5W=Nm0lz_BU;eaTp*GU(0j1PS65zu+JD|9-u89_MpkWp5J&b
z#-QrEUf$aw2uvr+rD4I5?f!EF^i)FERcdTNycTD-suwsBfr~S=QkfiW2#At{<VFsg
zgGFbV;#Jupp8JuMYjCa~BzVr?{x6`4JwBw;evey|>=Vx<l3)yr7X=mcUi+kz4>lU(
z-ROdmLH>cp9uLw<J(Ku}v)|llhpol~xc##Vyn>;H=|b5(K6y0uqB_(_6%Y+{@63{Z
zyrZi(DkKw!?+XEn(Wj&2MX5bppBF8reZC=p@~4O9UhMBJE4)b7*E7hj|EN80+=5!w
zd`_HU_!r)!fgiMW%`SA`q0<bfN*AJQ4#PWt2uD@A{F}P(W;of5VOKOpnMXyrV2tR^
zE`&lo7$0!IzuzswVjOmc$CJ6Y<W0lG0cN;%$}Zz)2xE4}o-lg(M$V+carbnd#Ozlp
z(dSE?p<kGoOhcBV5Yoz(6EuZwNcyIcni{3=y9>k~cA`PVjW5!w(kZv>C_@#qe}8@4
z7A@N5!(NUzS9bjA^-qbOiBKPwHON`dObnU@K8b0RW;%?D3TO8H`}FFNSEaa9r5xp#
zaYz?<XPPyBBs!k!P-Qnvp)&R}SG#m?Et^4R>2nD+B)g6RQEO!nyrn~Itb_7nB(+gP
zTl~h)^kqK|x7)uyiettuA7a1{YqlS$hJ%WxOqj?Z=8_fFv`72C%s}^>Y=-wq`O^I3
z{EDOTTlAa-+OJA!p0Dx<3*NFkChIhV*9-JTt!{pl;lha)vo3@gWVL4A(tYXZCg+7!
zI_>d;Cr!>>n4!d{IWpAGhg-EQ9U^-^kI{EKU7Nbm>&)o!AafSEidq%Ev?9sPb3f`X
zqfckhf8H(}(!KF|nMq0gd!=M9Z^6x~oaH%Cn^fSt&2OJ)Y>LgX1e|NJ+5a#dO9I-p
z=|CkJJnz9Y#}{KY{lsXt;41t?W$<V{k8*7#Dw#mofZmwrEPlRdgB??`I(eBcYE^b6
z*^R1F+t2Wny?A<&?O>1a<UA_43J8$RpPjHudoSrS)1-fQ-Oe3p1Q))Vzo0YB+td%J
zaC9NbGa08|GsVzU@^ij}jSW`AyX%YR@B91s4UQ0<45q~$`yQElD)!V~1o_?{k9WV%
zWhQg#>+`oiY^R3xx4kGp7#sWr-TV5k33%%&pL^K*W0dT~D~eTC#-o?$g7|Oz@a@GV
z!}BmUdk)*;#(cGiGaIx5ui$0Nyev95=xDngIq1_w5=4X;Xd{^`<K6c*qncu(kD1Dg
zlZY}HZ&6sc<LH$vEyb$vM2GOWA=OZ+Wm-qt>pQI9jvTgXHy0|Yq1>{8TX6L7GnGug
z)FMLnAJa;vpQqh5Lk2~LLW+pR)(MyT6O3wabeA2J@L9Iv<RzS{U3e~IE8SGmZ=(L2
zSkTNc4Im<}`2^h!<43M`x*dBz4kr->^<%Ta2uW6Cs*{8-kR<R4;c=(EMm_m%4KgKH
z6fn!>{><$ka2}&j#3qJ1j(sTKXvSDZZW9TJvdaOW^pBo!k#_AR+Et~7MbqnnN_f!r
zl<vbYpmqvb<nsws56A3<ozQ=|Cdc4-BvAComW(Y%XTkivTEiw*w>e4O*e_T$y}du!
z>8Aj;z0~H5SR?7LO<Ew3^BY_y7*oE{lbY1&@8@V-Cm4dP?p0#<&v#M62M)26l6JWA
zSB*W4eW6TsMpeNQtY$3ag4`;0eUxrdjlJgn$hN;BvR!WRpiRAUbYIuo!KE5|49;BI
z)x&%H|2|)WU_5l*H7I2-Az?*)6#IJM(|xiOf=-}+N46@Qi(T+19mK{a1gKnuIME(>
zcz7JH07g)WID}1}S{bIQHW2ccUeC#bceikU#*9D}&j{?Hu#I-r@wg(v3}pY;A}zQ9
zwbDE7Yj0U_<Al3V7YX6c3xlRgc}-Fh#|D~f<@^tp)FBMphhMM#05U6lc+@`<krfq>
ze!kZQqSG$K>>NZDZ<9a0{~$|$aU(>U<m{2da=9d?L;Lutj0h*F6T9)#oCJ+*8|K!{
z&lYv~6~XjR2I>hSpac3+z8x9dD_)VFDiLuq;=!egq47vn5qVu6I33wb(*581>6DYL
zH)6_}_H*CIM~~c*GaK!y%zW?-S&Wx%t3DOFtN<~lD=jJiqMwrmYTNlxKQgw!Sd;5W
zCYGi@(mE@B-U=iAob2f~Ab+-<Y$Z;oFX_%Wu7yz37Ay!e5wa!_*uOtweR+(_X|JY~
zF~Gur+<<TujOJ+XhX^j%1));zE@}ly;Qv=JDSbfi`nBLD#&wX2v2~3#iU1LNmIpZ3
zX@erhezvu)NG6>yNssZ*`<Yu_bij+M_wsLs)-feA0fH~*`$nOgzwL$W1}<nt4G;<E
zs}|blW$!<mLiIwZaAsBFdi%}=DH&RPj+zTU|Kx&I(cEThZH7Fb2ayI-M7*_rN+~D_
z5tPlE7m1IUma#^175UELbR8HY1t}x*{)@}axV3l2285SS5E1_1Z;&+le7QZlU3F5?
z*`7*YY$)HyDjoPHTbVxg=lC(K(_;%H<cC!VVdJf7;e>#ib;c&;{Vi7XJIad+l2&g0
zeadx2zy7n5m4|6!G{-&DoBo{VcF<bzTIFK(N-mP+yKU?#(rzfk4q1|n1mnySzAaNN
zc{h@Z&QimTOwrnGZ2Xh<;Wbvvvpq54I&#S1&7UMw)juw&uq7W6KV1{8R#`|>9pyn4
zw#!M`88_Bq)0^UAAI5g4cgiaoLyzCCAe%jGjITv(m>Zu(96qw;%rar4I0DklBSC1B
zGBgyVd&>K5Y7o=;7ws4R`Ix*bB*5QzE1LAW&3Q=>Y)_+bu+T|FvBzLx5WQ8quX3bd
zvfbm#4hof6BzN6Y96h6cu7YRSHET^-S6Q$`UQzXYtZG~Zh`mZEA_jgDYxPl-=o@%<
zE`Bi8hxJqRHLHzeC8obWn_pm=5`#F^BDiN9E-eZWfM)h)(4oKGqu%_6pLe2pd^@Wr
zPjph(Gepx&79}ne)M;CT;Iy09WxUyja$w@+%q7!@F<&RJUkc#pdUQpUwjsSYeLwZL
zZ%^|lMa3y><ex?Mm?Q3gVZ1(0JrI(;kDH^_OEGgHXQNy{_UTorxhmr3Fi&TGR0lG1
zg74nL8Wi24$2T{V^y;}|&_Hh5vgI<c!!NG#qt_+m9{S2l{GD61*k0b+^KErNizlm4
z1rSP$+T#p9911V41d7H=pPb{z)D01+Yg0=i;l<^ApQ$7jr=4RhG938@t@~x-cE7EQ
zf)Psdcmaa`@kZ=SY;QusvJn}bvfMnjH3Poy+U#rJ>|b;BP(#%Vou_{%narS8FS5vt
z=?XCY8Qo%J>c!ghZ7=N}Pq}_|mJF$ipxdHy_1U`L$9SwWLVMZ-ZF%(yKRd%#Ba&Pn
zdVKk|gTE%cv#mNLg)SDmd4D?wFUkCn!f_#%5Iqd}VDg93<}E46R+R33Ii%~J4JfT~
zMQURHFPYZ7aKRGt@{%b#G=ndy<<f2EB*brG%QHr^l-V54*v7-&eN&xwL56A>VfUlf
zPsyD6qi{VTk>`v3Qa_+%b{IuG^__$*v{p(=O^N4W@fLYD_v>M3{EY!am=r9oPQ$It
zSu1P2O<iq=+JiI~_t^+KLCEyhIzRbA!)2w)*oW^JDn7X}Zu;k54y{ac4#X+P(;#H2
zu2s$?S5tpMx^%50S&;)R8A#4xV3h(2SqU`p)G)2{^zKuNSC=+y*JV2weAEOzixEl#
zQvfS9j@P`sOeO`9h-Cwuos{Y6y4%TTlUjl7<1?EW9b;Ixt!J#%r>#Ac2hmGd@&DIR
z`2WZ*pv)qhLNj~;@tlh-G2Py?Yd2j2JD*%78N%Q2Yzexr;roU`4S!Ee|6c)~f%PV#
zF_~GI2V_35hncZ+2}gSk*9ues{b!fx0h66mTMt`m$8)ZtJ$||fm!)PFW2TIq9b&TQ
zP$5_1?AUL(h(x=2hKwM8o?}}Nw=&h!1S3=OZ%zIOtRwqi39_T(+BBu)t4=6}S9exd
z8u{t?cFrLM!=Jp?Kyu#vCz1=JiXnkrNT2L`K;vmA`L(Ux#1-}5P;O#rBeu#xvdL~A
zn*%`AD2bU7lGITmnioaB1{W%N%pbZ@S1S%QXJpzLhxSnc4avoiW;pB#fM}*%Qax7X
zgCscjw@yVca!gDE^iizr#^xbn77vR(6$%==Ts**o<RD0mijitW-)TlTlI6OHbI7Q@
z33*v1IFxYBB}fcEnxDY~Q3@tFs)|CJmG}sd{Q)(LN-Z#&g$05zqLF%FN+GgsGNoir
zoFD~PvVb)N7EE9+$7vRo#b+e7qG~EuBaP~!wrutys~%avRfsWuY${2J2cWpZs6K=N
z7I*;Kb5W@!L1;{lKi)riP4urK;d1L3@|gc1(QW}p9jsMG7eBq!inY#d7#uX=Fx*+P
zN-!Ds_p(PvIrM&;>z$d$C{V)WppBP9IV_(}Qod$CgI&_{*ISm1a;&v#l%~mGHe9;K
z%}mb3%uGBkwAobz2)0d&z^>jE=D{b3e(#XFj_q?ojhy9IDKf)3Fk!_|K#yIaO%el`
zs!>%PsP|i9H+tEJBaPh|9l0(<%v|6bMz?%`yu8~kC@DJDf0yBhPyVphvv|Benf@-J
zc-sSjP&d;BP*fL}G5ehClOAPvdWH((oVII3omYY9Y2gx&>an$<im;Ps&yl%bApld^
zto;Rz%HC`f*>04};Pe|kdKbbgi~*v|>ys8`^?aW0o_Ybd`D4ygSMz@W^1Zj<%Fuhr
zGnlPlNJr#RlKvryPh;anUENniwJ$HXMol$al=ZHXSo-gUPaaCbdY{!(UKh-`MyyXq
zIVq<TvB#o=3#7GKr<`f7VFQG@G_IMdKQ_?g!qk1mnJK*Y0X1ns_?UG07e{8>Al@F=
zp<f{1+9kIaMCl(o5W+Rl@r=S`7Wm+8CjK5Dz92L+^q}g^<eSWQLl0d3n6>sgx7|kc
zap&jzHWxmY=QJF_DXpB_TmLDJM8TjF;3%-!Qd6e3dLJxW6U|QUi}%fKjOSx_%kI+q
zlp~o}KD}xfQR?K$Aini36iNpnOgbpxICiEc8|SPLk^NY7Wus6HeN9U52^CQQ6o7SW
z4SB;;3$>ptc*;Gw!mtW1dEZ1z{O&o$m0M;iqXW{)>1b<)Jp)i=)f6oT@x-zxtNF5v
zSCoup!)@})SS4~_qns65h)fO*ZEfva`Y_~dwz{yiC0PlaYgF7YOQI`CY7Km#HDsI_
z6-=ARY#eD)k+~v>1%IgbL7zm-$7d7)?l>NA#+JA?7eoQw+FZ1f_LHPG|LLp)8&MZ*
zD_COjDQ^c<n+l=V$_$;u#v&gg=|b?QuPj^6@uI^{V~AVFCdNEuYh<6JX~<Z?;D`cl
zE=2xL?qVC|Js)|+on!o|Jq8u|k9>RA+V>ljKroj^s$o9$_NVjf%OzA!oT*#x=EQrj
zIFkK^Bb_;TxmzX@U|&S&L?E#u4M7?SWXC2jN*YvHotpK*a%~wGT-vW~Bd*NUz`bQc
zx+WpSPzv4nsci%0)T|@+6pNABEBo=Y)k29%T`~gSPm+K($e$a3e|HV5!EG&==u%zm
znE<sYEWK+QhlV4&JQ?kJznD7ws0?f*nCtxClc?Uk93{&>%EULm2M_&bR<Hc!HI*tJ
ze}IrJ?b`tHn4)C3tkt7iPSj2m)Sn`KMvI4=RNsS9uG~%KtL7IZc4K2{+}VRf<tJnm
z+=srf-kU-aq^lZynTEnWb5eob2YZ@7cG70*dx+-@7pWs9;ozqRiXM20W_O|vQ;1oj
z66j)T>#iXoX`brEZF&q9eISDx5*J%}!UT&|csvG{K2}78|7B-ka6BXuiNI>)eKy9N
zmoD_zDH?jf?7~ctPfFO89CY{w|I(Pn{HInQVnH944rnVM@gSKOek0rEvW)Km6DLD7
zoTf4#mk3P_ZNTD=TuqT2kIB3~7%)W0I!TIS&!tE%9jL4z0&;a3?TF`w<dQ8QDgH+V
zF-n;^_aYVOYfA9Hd@P7Jl#cb1-H6;tH*c<4k*iWyh@LkknAXbE(Rn+%C(X~zwq9&R
z;-Wsu80!D9xGv~SHqpSh|E7*zShD;G|G1<hIN!Kbjl^(h$;gdie-jxcjxvIZ3!+cY
ztRg)kD|}@xi`72e`}3@NjHYC?4B<)VL(s4)$Et9p!7)VAuTXl@5y66xQ5iGo-2a2o
z^GqV^Hq;L&5QGWSD0VB!iVYbr(hU)~ba#%{;$y_+LH8tZcP-sy{vZU6l<lJP{4sJ>
zGekI<zVMh;h~vM{dcNU|n~3xJ3`jq8D6g^Y>e49&RygO?I1a*fGlfn;^plHUet+IQ
ziB=ErLlD_BiwEO%m{#-Q9`2&oLwS-`1u>-n4o%toNf8WS)bj&YBl%yy@ArJtFXuJm
zLmeG*F!q_Z<<{el(J+Xv7d9USfJmn`>k=TBFg0jaJ;s-)UpJrC&Mf@8pG9m2>f`(Z
zL~W=6$6RmbPbL*iXpW*72*f>q`=6E0NmgC7rO6t)Bm;^Jx#EJ{Gl!sXi_#oAsk>{O
zMH#I(^eiqYDJld-i=WbP$}<Tf8fjr0M>|^APbZbT#u-qBWNg5!b76Gp;x<R8w0F2Z
z>RiZ`(@TG^x!l?R=y3aeKvau=1Wx{2<QdA4iK^s}H+;qa{zi-^T>N6dMiLK4{`@cg
zBlu}j6N`eEH?7*d`0W~Uu`3H@Fh-AH>MdDTR>+79Y)SifUw&dN&qg9<Nr#2<^r@Q1
z;<vfU9gsGyx(av;ypm8?RLD(1;#2~#B0G3$@xMrI_U>~}A_T8w7LKr`TF-6Gr@Cv{
z08)Y%`z$)|39Jx6f}infclqhvd@vrd1cs%rb|%|kJ_<7`OsJ@uMKZmX;4$wn%k@Zh
z6N*^DEjrhq1W3B%=3w-j`OqWBLG+I)!EB3H;VtH#bkyM&jf+6{8;E7nR75~cQqZFM
zuv)Qp`xO+pZ2iqk`vljvsb5MBeu4!)3==4#0s*U12w1<OIQPboCF#z5UM#6dQj?jP
zoJCPR2;l`62HBkwqn1Fi_=T~MJ6kxsq56neyV!iu3F>zCqiMq&9RWfs2rz9ulw2U8
z>pb$-81s&(xOqg)k-4@B)seEJ;?l+6iMY^d2878N+F>dh-pr4U1R0P&+-68nKdps0
zWQo!E9Q65Fuh(rov_Eq5Qro0)zG6A4Q4f*AlmLK8!4*JDyP}vBZ9)LEY^Hzsz1ucV
z(2y#}rOoF4b4VZ(@s7-Dry0wS7B64dRICOj_{7=}@f((?k(w{?FEvi7+5RgFHM1-&
zAc?+|2u}6>JH@2OOAkMHt#izoIfz3HBs3Pk#BQ-%kJfy}4lZ4xA?51?ysoKL5ZB)S
z&&OV$q}L&dd>GOHXwru9#bdL-(d)kbZy`|qR2e3Kk{L{7=1e6p8#xf=^7x^0ndYl5
znPYSx2%M$$<g?0I7^uv`B#{v8e0iR3=_BJ{sK-deXOv8<4$ISzcOb`V`tr6jao_=H
z1TpZm!1!J$y5Gx%NVXBo#?G-!Ef4I5JjkL;g#(M9?~LfR!Zk1Kgn@F{pdJYXZ^GH$
z4-dN#{+AGpX^-tSrM<Qb9B#Y*EXepEe%?WB#yMz>E~ffr{j1pG*dvY;`NMM_KNBG4
z)g19|AbePbP|&rOo1s|Mpoy&9R31gWIr@!9Sg61<f8?|cf)H!LG-#>I9mgbxQhyxh
z0R#tPQG(9lK6Mhxu;x&8l=_u`do1|!1_TKZLqud`ZsjOQnm`f;O(tz{&Et4K^O$VK
zT`(02g{iiXVRIWEI|242W40(LNGJqq#w9Zp1TgnrEvwcox>+!nhZB+tb%5ecG29Wu
z(_ECq@UIh?^(KHY;rr9+_tvm}UFXQPKXUg>)@N&v0GvP;6noU@qcBjOJ}TkYJ6^_<
z)YR!K_`zoxbpe#5#cVK@iB3u_qMbq#M1A>mOo0^|^JRC^3)v5M-Y=a4r&WnV%A648
z@GF}?&OwmS0|=*VpWajUorE*jk^n#$7i_YVHfzS2%ZZ$NXGT1eu%85w(+<(dGkP|>
z+_qt{Ga3ZYCS&YUyGMwvx0^HAez&fTxRD8$knC}8CLv&nvzi8=6wN|Z_Z&D6`NLPH
z<+#LOcmV@R_=4xoW9{u%Hn!O-$;*#dJA;S2yIuWom`{c+j0G)}7eD<A5T0Zo$+(+M
z;c$k}qlEaMfCifzcQ}0C5I9eg0s;a0QJWlbl~Se8c=x5|UvE@B&M&-W&E}IeL9J-e
z_d4wmTSeRh=9QtK9Cw$@=89{Bvmw<dAp)ci$qNViKnf+?zA7`d%twc#jD9&CdmQO*
z0Z)7K?&&0xYN-fOpD4I0`Fr>T4g5AY9eTtqd<j*&HE!PMX<m=jj%T3>88mxP@9ZyP
zL16`zG^eFuhA#I}<7~R=g`0?zAwK&<sM%MEF;(i7&w!N*K)1>_@Eh0fy=u80q9O$e
zOe>sKS0Qj7d)eS9uI%}MgL!LarKBIGg<L5y4>}lk_;jQB?u~>3>P21+HV!W?BwJdX
z{sfS9mgN3aka+%?$)TN}(yup)Hl5%cLk6254C#~WoFF;b_C{HL(~X*h1&DkGb{c~O
z6bbG5jgp6^E75x`x>fJ>700mNe%H#XPu4xcLv40*Ll)eaMzc<O$V3;5V4{dBW|}*7
zjhu#hHe2{+yvAHp4Bq~JeWk$BsU5R?i`Y(Ad9^oQ^@2j>r+DL1qnU5p<`WsUP*ARg
z0fw_z$Aa&U7>|tv7)(l#&fiifrD@`j=Uv+|*V79UBLP#vg0C{OfJNGTI<+N$G{Fl_
zHImuT24wC~&+d3;d7aBcwz&}i$CJvYt>Sj^h+4RiUo{5)yQM;aDJrxE(j&99tntE0
zq24avhFaXQ&ILKBTZCy;Zt~TTv!kl3ZWC);!^CfVn>okK@^wcq9`lpg7rkd&P<XUP
zRM*g)oF+%5-m*iLdK%qj_OkpP&yqW27m7FwIlXesoqh*5N&nvYv0PMg?)jTbmboT<
zWa_pnJJ(+~HViV>aNN_{P}axzmgUu>^ma1d)#7v`$pl%hW7_bA)XRlYtL^FNQn$99
zR2nLEm+|AX==vBGcxC!FsRmZOu{{xka$6*C1_K_`4hMdg-@x+m7zQ2;US;GnIbzEf
zUYuLDCp(qFv>}@Ag<u9tbd9_RTFL;#KKdgXk8?)jP~t5+F+D}P@34tv)dCL*aX|XW
zKqYfQqKU-ZSZ(J0Lh%rL9Mu+?ehqhS&CY25bisOzICo7_-I?b!K_$=qWqbJ$P^gLT
zko%^6V$%(Z;J*L;XZF75Kaa+VMmj!YWRa>3GHH7hge=PHXX8?_E2$jYH8HC)m!??b
zn*~>00q$xLc_|r;JyEA71A8A79(Jh$H|Ei}o#9UseM>fO045JYn*-<sKT7HyPG?U3
zRbvLYE0>L<u5wpfgi<q|(LW^FZGH`Jecb>AG!mH{Ml__DmIOUqU@6DNPAyX1DJQ>W
z^hf!YUun?}REi+?rguiuu?KG5vg)fg#&4L{e{M_NJu4QX__!*!HQLzE^kFk<&FDrR
zd~hYs;Ekiq96@Ism+QG}b8DdsdnU2&aN=PX32&#QGf#FuP&l{c2abuyE)8s*WVG2r
zuwa3h-N2P0rT#xI$nV~7y^iiZH*>n0T6z|%Uw9+)Fr(jw1e;|HaVmnvG0?{4fLF1g
z`qF>TeXz0jDx(;eedJc{#An-WDd82o1xX4PuRa}V|CarcEB$vnCXfsWwWTX>l6iiv
zdV$1Alt<Au3pZ+C+WCcX7JU@^;M=1*Q8-Q}nr$U^G=+!#EPH5rd9UBY&wYEHQFBiG
zbI7}If40~~ch1z86#X8BL<Q4=<NVU6W^8{Yh`;%C=+hr`?0c{QTUi{HPTJRSBF&VW
zJDmIACfRRXugjnBy?^}(LxE54kDw%aWyZgAc7(iM<-37u^RT#aoMN9=`woM1NLL@I
zI*)AM=F#Ow$DGV4s3O>(tt_nbl)`LZ^P!K9T>IqZ|N4$OQ?e6B>%JF{{}r>TN{U-9
z&VeVpi`R6=LoEds2_`#fErwpz+1KI_;b`3P${~@wla$n#ID3Pyls*%r*1tG7JQW)n
za7#W>_j1H*F7Z}|$ow%%yQ~Se$&3VsOjx;uV4xBLZm#7|N*0a1!;v!=`Zg$LWYn#w
zt)EaDWNO=`de=8K7KG{cdS~rrtz<Mtyk-Ws?$yfr6{`+d$F&Ds_dAk&<8(cvvYVW3
z{!dho_6#HAS-RqAbOt{tWSmADD5G*jm*HoDgdk6z%#YP$!Qox^az`Sm_u5D4M?{W)
zMixEOR>HsP@d(y@0XS`*mYDxz?V%UCwNA(%K0j2U%jXod^)4>4SG~f_IfgFrmTs)O
z0FVLKPMi=L6A>BMr!uF^(@%W@`DiCT2j5zg8)b*7T8wy2-|h=<d%-ubT5S(XH*413
z(&wdcp*|s}@2=+#iI(6Bp1-KQ7EQ?|aCv(_n$e|mi>Csqpdw@g3Kx1EvCPK^i7%v5
zZ+eM6r{%W^XjHB{m64^wtaoSl`7UZO`?2Zon_A1$7{7@>SsV5B7fF1@@s`H+@rnkA
zoc~3q3w8J$m8`;g&n2U^vJxxl)bHj9)~noGLvDJ6x-`G=I&F9p3wYvokD9K1x#Nk!
zDfvw-@k*6U!qV5}+3JL9A;23P+TBJDT3&-B@mGxg3`$#mFuFMmspPeAkeNxn0NGW_
zWs|(#n<6v&z4moE)YXXv0ugTN7lou53RP}Nl?c>-8&i5DXUiTg*9Tm_>7&6dBbifz
zFTAF=5_!_RV=$x49iCKvZkeQt1WYhxZ|^4o50$4UjXh075p-yF+X>pZ$)Q>_XP1c7
zH*YO-ys||~u_F~9<$l7IuUuSPr(}4!#gZxxxcGoVYt1VxiS8^=drEIWk{GM?4>1WF
zH5Iz#&E<g*CcwLZXw1IhJMoyQj2}VA&ijo^z^c!GGxK{T<=bzfS4O{a3{i5Ey%Do~
zXbCN6zx2SNlZR_rILte594E+kp`t1KqmbU|=u)dy^Y?Wfp1VEc`<qTka1*%@p#{3I
zHq(+8Yj!$Tj&HK=2^Uqg`iWo-eZoQH@J7ez6%`VJQ2gbk20TKpRNa8YIM4ouH8OGn
z7=RQrp)DSF5VaG5+f$>iK?vVu0^EqZWELB4xC5e%X+;H8JeD{sLcD8d(706queeP7
z1u$tEI$iS0AO$sk%HghB^es{xOwP|S5=@c=$i@(;%3BV|SXOfj)NskmVxThTFcagx
z5jrydCxQr}4eUa7D*~KC2>&EPkXwMh!suNeAAUivz3%9+n+Y<x$iQ?i^~4v`18G%q
zfUYjh&yf*8T?puUG<_X6!~1xk7>6-3)F(vYU0wRcKzqhk#zAoG8*j3o#|%%qiyCMt
z2(^mmWINOa6_*}M7zf{+G1+GR6nZ6pl)`~z>^7#vyge3gdiN%p88SvL)8`gZWWODo
zokPJ;fdLYhi6CVB709z@J%UjiZ!W5|%5r8vs+7Ed?)fMUpW%vtxpYGG!swebWXd)X
zDu`Ty_~i1fNtPz$0A|fc_1%Sxzxnr&>w*yUipd%m@!5pP_;sd-4!3o!+a0=3r5_-W
z9SFn>E|qBS-j<BGX5{`d^)W&0gaqq1$6ioukn~fIRFCHQBIqwhF|5WP5AZc@Y>N5C
zwYW%)=$K3B!*5HXJvO$?{<4Bpw4hGPn!51zvYXkXC6@;PYcZI3k;XP)=F5P6Qok$1
z8`4oM=%pGyU{Vn_sd;1U67%f^wBR+)NH*KRd(X0%Aa5(Gt-rt52LfV%4qkt`o~cN0
zWU*iQgeDpvv{(-V@Df{S#z?iZ-T17JH!v`M91qQH4P~SrG1j3;Xw%z*hjpQA%~Uvp
z)Atf><*X%GB-!1F?_)*atxxg-exfJ^Z5R5nQD#&ne)Nmm5c_os`<yV;OX1D17?}XS
zwcr-LQXT4D{<5<kV{;5{Yl93JZrpCuY_6;6MOZvUXSFP-TE&9`9-(MULfI!WOOPXt
z{lnnFzg{@E5e?dT=qfYDOUU%mZ7&!jQPp=n;0#V?{Xz(ID2380x9Oa&2Yx<RYqO8J
zZg~Xd#6yY%G|$zWvx_io;MT`Wul`v@l&m7k<peClpbyUFX$3ybwy15J7f_Gv;9}`f
zqLWKCDmPARA*=Xiq+=3%Z|wc&56V{3qa)mCmrZ=}@!a**N>yI5gOR#>!7ZA)y2&tS
zZ!8$PrTf+Nc1*Lue(sw|p{nSAzZE2Mc)BxBA)qQ~VFArf$H#Nyg>@B5&AMgmC>^9`
zP7{nQ!k-*1#-4o%ij|wjr@*!TF4=3f?n&7jrPHc_pX5C@^O{TWvV{1N4fe91K1=*&
z|LA%3{fzcOM;!!9`rVVzu~!)<J2}~?T(rcl+l5y1FyeU&EplUwwu)W9lG;G-sNfal
zci1ovcS-zBPv_=&_D;9X7e{HfwlgpmY&yiELf4Ns^4CI=qjp)1(q?~R?h$cgvH#d<
z>dr7R))VPvM^p~jeRe8i)Z9XUpKXg7h6qi}LCE#a37%LV2I@P+B<hFMZ;GHtRZaJP
zw>$sCe0n->Tdw6Y$D=V&ta3hSN6>PTMUTZ>oS&8R6@ny-K#|x&KO(`(UzndYMnHFF
zu&>##9!F(o%*P^=4F>y7WqKdB-3uEK5LU!ESC*0+<r|wSQm{XbP)>6HMcrz2>LGK=
zf|*15KwmaN1hIS~zowBgQDT>>-;dawmtT|n9`&LzOTKZ&_7!RVrq3B*@13D`KBFuI
zNxHPm9|JX_l_$%5#(LRHP*edxqGp!soqb7HcVeA{A&D)e0oicfkwL8-e+H8wT$#Fl
zf~81}vb?PhlSb;>e%p^59^L}g(|h!kgk0>ZE&^i<Wzq&1RX|j6+3DqWA!E7xYqmRx
zyGrYutcH>4MD#RiP|wc4Aa|`8qpm|^4^v5LbQD|be4|-iw0_?DDlm`*t(tju7Eac9
zpf$%BoS3IJFi`XJ0~FD%dNisC{Kb&UEX8<0Fe#pQoG!<_Sy1cEJdr7{tji~QsN05H
zEuq&CDUSo}a{L}s9W)1ls#N5H3IQ&wS<%0pVT}26ZNDy~Z_H&GhHuP&^dpMCl1|x|
z6&F^MbR=Y^+v_C`;Xoq!60!MHZAdmL1mbLw^}h9vC$OXWE`+h~QQpvr&b--UP3pw@
zkLZspAcG>lr;Xa3^zWTj@?_slk~H*OZPq)C4LtTB>O@9~*+Lo&QH^5?e%1Qh_A(Vh
zh1x02=Y{z{_nU^{Yl4pniOjBan$eNL6y7pTesVS&?C(02Nj!%ke*Ahn#$1GDuf8?G
zbM1O5H$;R#hKGonFhK%Ro=@qz%=nIo$>K(|b7mp400RTp*vGgHpzB<3bp*R$dc?*x
z<QPui0dnY8v9C*>O*LEhj(+{mRHy<o*QyZ0tYA(3jH1<9I3!bF|JUI^9H|=u)q#Q2
zF(o>4z>Fj9MG$P7+uXX^_GpQ3>E#>VN3eg`ic;m-Tp^k#29(yf*}2EmFJkYH;D>lI
zjac;uuW3kZZ@>1A?d(=p_-u?Z$c?Nc0f5dqy+|;iv10qZb{?}N1%cU<9b(t_>z2$D
zse`;9Q6iiCHMLa;B^ESh)w<hRzVEJPAWQvQcHh-@Omh%X&VzLTKpDI(Gz1V-ra#%C
zd=H-=?jeG6g2uAGMe?i(QP7e$f_OXi0uPxym8d!!3lO=v_zUL75&NgoMci;YZ&UXq
z2!mSkUW%pEo=x1rnzPLYoizok<K2$D$FP(IJNCuweI$OhQ;HZl(l9^VHR(QrVGaQq
zd3^XY8Bl_leG>p=Y=<_<8LelwUv0OCR~T?c2N7O>1{gfw2(-^X-XtbChW<W=C77-8
zTTec2P24wlQsoF{)7FN8)75rHiIycHPCrFk&9O=%tUeUz+kSt)VOxdL<4V4sAKCF-
zm+_xzqj-DK$XclNj3a3>5NXU+*ogLj&j%)Hgwy$MDC>nX5#@#!tnGn?zKc;P;zhiv
zy43E9fKAr9L_xu(emoHaq)O)#jMhXV3Iiw(89YIZMQJyNbQee(M%G~lBgoC>_0{7q
zY_O)_lFz)uTmCs_;*P=$ZAxy`7^0yLl7R;?DClEUVxBr+^BeduK!EAAIvhlmyt?^K
zD~gbjY<2r+EE9F~7G9~XAyr$fnuw0QxQ4hnz>5s6yBYJ~<t^#lC)D_n^H3@l?X?v?
zwPvhj<xYR#T^|YmeE?>eb~ka14P^3BML2st5x@g6T`Sf`@KR`1T2~OT&uF0#FVWw8
z(nMBy(D9H}`)5)BOc*4z$DOKGl#&COZn}_c_!>*xaQN#4Fyu7ORL7pg0mMO)8rl4|
zf!LS2aJVYEa{Ck0I5UZ&0|eB$cw-dAO3f%~2GT4Yg8)HOA*(P3Ei>V2YaM>k*N<L_
z@n-LKscw3xb_KAsW7$5ozB$Ou;BzQg?4#m6(Zp3hh!O6#rRm=>^mDO_6Bu$h^G^9(
zZEPNkr&x#LX*Eb&<Z(rV9bZU@<;Z-abzap=o1ov*qpfcK``P`Q#_%A#mpR$i=`^E-
zZ+=Hqc<0Wu{84-2hS7NS1AS-~EJEct%W(HEDas%G^oX}Uoy4#f1%#LFyx!lyd;Hps
zEx(nj9y5ByaK1frOP8<bdV|L005XAN=hO^dq)NOJziX=>WfR+q??u!??yjFN)UQ=e
zdd^rE<A5P%=63Z$%2xiklK20}v+a5LtQJRid+^@ApTop-LPUd3vSGtKC~uYFFq(Ti
zpi?dD<FXGt43k(pi3m-5y&C%;N+%mvI$i;=;pq}*6d-Q);%B_28h_!_A@io{c`|b{
z5X^LyHVhY;4v`d&yP94RN)7(0AAD4)=6nnjb)Jgj^7Y?0;Yz^o|A?gMnJR?lvJ>+T
zdVw=EvP?jXn%4zOU-cXeahp6xn=U<W-gc2p2q9DWG`?`(UT-oiTge6ql!Z_Mv$@h)
zhPIPXa;FXX!9Jm&EFljJuGZKf#w618!6{kRe#V<zmj-bdXH@c;ltB#ZT^Om^DXZfY
zclI^WS7L<^nBg;K_I?VNHs!^ue1Dg)x=QWe<DNY~=5M&C6o>kyrW5sb8rA2~IFUeY
z|E)Co7H?}yd>rw*5gXCG!7umbE_fxgg8Hu`sfg&U`>JMfpJ{csoUnA|_T^3~c6X+F
z>rgzfZ(31U7k-Jjdf-IpbsfYUP#O~kS*IWj!kLvD>RM5jzCS`}wiRps>Riw}o`exl
ztpf=l(wZ8Hh|9@Nt-+77&+)cCs@05TJPcvmpG#sQQZQzVJ!djJ^|w1;Jrf(cZ;P4>
zkuod`PO(K9pvV^%`gD{^VlIruM$^y7?#v{cq`u3zcEUw}Kg$6!R+CI#QLG|QsW(2m
z;9+x|nH5XIWMSsDZ>L+C^-*_bPP_liCj)942se5*!mSSH<{Ya`Y#zzlnVkgf^83!0
z=RrgcYyWNS)<f?HKIhbG!%UTVwZPIXruhqaYl~fuQ8@8Lu0({MPj;&T1$nD*i|0p9
z(xQ>v0j#8<H%=r{CiBlidR_1kUL<^vshZ3RSG3xa8xuu+?x$lHQ1CLUD%OUTCBISZ
zs>;v+nP!6_V(FE;g<Tnz;{kn*_9JKL*-hQG0s3otzpI`au%*`mp*KsR2ohZhEghHB
zGxottDx;Wwr3~4XLNY7`1=}hcgUrWUdU=i4{84i%T~M?xU*lBFvWRo0u~Ej(CDD><
z5bg|g%t-WG313?SPk@Niv$(5YUWw3kQD!5V8NR5Teu=>q^Sfu;U8<lMuY_J#o{Z6g
ze&@Gv@!yIC0t{0qaKE|AyNkJSFx2F$9F}wEV`~IYWMcM^?bywuC61p2uWS{w<UYUI
z<RWSCQ#?R+LA<dgcQl5w4b4ynXJqbdtay>wwWIKm40dUAK5Wkm*I4GxZz#M(o13u0
z#GmU`PFK?=ugJDW=Qnr1Eb|&0+amlt{BiTyI9lx2XY!tG?;-VV*^FheG49z^W=j+-
z<PZCaKMD!{8A4{{tS(#&3rfS7wRVd3_}4{-pDx13Up-hg*{mkwZ07kyM;qX6u@3Mz
z%niAst)6IZeJ+XvsR#O{`QXj&Z)D^RtAc}`<D0!}+>^pic~DRZQ^?UVpVYohM~5F}
z#iPMp+{yPqjITe|qe^vVO`9ERi{HGrZ$R*JV9~<wz)tkzQf|z>W=A1eBr2=p9sTI(
zWhyq(xyhXh&}DS2->zHx#^|vu!cxS##0Q1?of5KI*J$YB6UD5bvc68A3DpP<kRHN0
zp2H;yZG+%ZhJvrw>xsyq_gPgp@pNSH7Lm#pV7HiZf#dkecc{WC8fZ{%HKKWc^+)6r
zW-WiTye?$m)ELY-CH6?D_J^3ru-XA-kEhyYjSCO|C?w4?A=p6`vRJ>iIY!C~+<=iD
zN4=ot1X%X4-B)6`I6sy6LP4P&Mu@0%(>0c{t)kY3`IJtj?5khw7jTYs(;SPyDulq9
z<b6PcTV1S9l*h0>ZmhV3+HeEIS8s>6M~BBhN$(5*n$b3&aE4??$>EJOkXV$uc;Bsi
z8I+n#=3pWN%3MzzuUG}4M9rN1;6NXkDqG)=!lFqZ!_o{0JxaI>%}jHX+j=D=RC<+e
zAcQ0dqBm>h5AW->*<}NWtDlHussP0t!k)CRhsJG7aYT6XGK6ba%MxM|Iww*1Gp0fV
zG|on@N&QZ6waO_Hk}QWoYp>SM5|<~@PLjNKY|a$a@qyr6n>&MuP{|p~sSEPSE{s_t
zenq)zW@Y)qxF?slEm!1p#gtEl2J1Z&sc#)`0kny8xe1vzVrpo2dKDXh8S~HCpU6%$
zqRX!s_D@200Vdj<j2Z#V)ABt41Sie9jO~omxIC&jkY4G5aE=dn+-8m^knCnQ8<Egw
zvP%!;k9si~b6pyMwTP(MGBH*Yk$XzZ1dU#>VI&us5ky>s^S)Q#|HG<B^N`@6kcUC|
zl7z|PqhGr}T&C_1INE@SX@%9E_kDg#C$@DQhkC1~ZdtsN`|m6GKpz!4j4bw@W|$ez
z{`!#TcSfm7p7u9l*eyMx5F%-jRsbZ$NUQ5C=?w@=ecLVeL|61Qr=UqGX&47afjAia
z*RLcjAYdx_Az)Lp9qS?y29UXb9y&Q=BE=*4s7<qxUvoSdf4fr|<`iH0b0i!EsUfM!
z_xhgYh5Dh*d9~sP;hkL#&f&0?M@3bM+Wq(IoV9bzQ@`LDv{MOL)_Y`lyl7#r3SOU2
zN8#t+aLS(c7^F&{^6N>?I^${nG1MzOc{4j~9K+J!+>mnWi-|I~IW8>jdAGc@4=?kZ
zZ}$B@ISuA7b=52Rr8DxG*C-G9!e^P{fMrmLHfl@#uRTGBZB?Aw;j?bGE0h_H103qY
z>yHBP-4f2qe&;#Ss4jrmKOT5Iw%AE2M#LWnl2CJbWY>KRJWFoAM0_6h`OwC^ne8xo
z$l#<idbLi@h8%S{;gplHoM-EKp;!qgh~!s>N$<1tdM!P;w|yPw>)RJ)aE3bovZPD!
zt=OERE+>^xRL6LLOeZxAQ4QqD0pn*Tlv?*i*HrN;X^ba!AsoOL?Z{)AAx6O2FtylE
z#L{+714bsIv21x|RnqdCbf3Uc`cZa@kkJAOF{q>^W+{wCTQI*F3-|4@&x8ynl`wg)
zTL1V3-F{}IKjlv`EWO7TeHY+>bR8W2E@GqN+W>OfT<Nx>{Q*FW$F$@DHT_t(b~j29
zpRe7H=Z81nUF;$Qq`@j#@bG8M<U#^rk=Y2*k9n16`%`H=Xd(0=R0nw2EHG(8iHzCq
zMV>j6Kk@}jiFK$HDL$yA%gA1M>?fHDiC*dA!aVc?6)5Ni?Q0N-PrO14$+7E1;PKM3
zk}VLVuBaR(U@eJ<0c3ZW42(l#DFh9htdg><VQ8`6?ySGX7BwmXetkNR*u)zSU`9Go
z*=hqw6gl%lF!%*J&gL$U#2asr4$`7|p>NeS)aD}o^$@pjlTv={tvk~ppM=73q}`_0
z250f*z#{-91kZ+?a8EBbA{ev91m%{7Zr|XiZT`x<1pEmAchJfn<a;*2!u{096T7d@
zj4`F&srhxcOVC)D-w2&@rIicg;qTwq>BLczV&|+QbYAZ^s|niH)}|<>z49>K*^b7B
zts3QTeuVDl{(Cg&SAeZVLrN0%#sD>1^1)-x=zawUIHCXD7{K{a#9|995m{A1;4Zvm
zmz1{_SU43R#bRTB^HR4@tP6qKm*HTa*dP<HsexkySu|;-3Q4#T0wxC2fPGsga>9bS
zFxW8vuLE4PU58H4ytBO3$V5i@v<8WKKq<C~IdB_-nz+C|K8=bAb0$DMZ}OH4c>^$K
zrMWLDK@Cfa8{rv}Gi8~xsE>U<4SE1`_8iQq0gMS%=%C3AiZ1NlnFTUE1!q9~mfJZw
zLebJ{s9cgrf;TGo$E%Z3+5Kzg)DRwiu6f$?Fa6uPeby?+xf=6F(4i(T<58X2DRw;?
z(g(ehwXI;<D%F&$WpzSgA5gPAYWB(cl98xUP2IHZ1k`4E42j$TL>Wl*#pp#2hK-P&
zk${O#x74l6NrH~qU6PyBeif>tl-dR8mIjZ&zjhFNl`yuB@pU!>O#(LH%~u3H7VA(R
zVD}{&lv>!DY;e52y`Fo&z<;vOUlW51FNFXonYI@$AfsI&T01qHMG-&UN7UWqa3F>1
zG-!^m3<ckDm}hNUynP3WHjtzobfLP=a_7;JwQ9}e4O0!LYk)(67H&aKVZMSfB_VtQ
zvIz$uRRS59z_|&>GfmitJ6m+G5c%OIRSc-SqU9h8*+=TAdbcA)M6&tP=-w{P*m7Mv
z%{KE^%>V9ne=wGJQ4Aj<JeJCnFGRXm@j_JS>or`&v4s`wkWK$F6vuhi=yC#lq}z{N
zW!Ggs;sZXQLXwb0nE`ufYvxa0KE97c@CB93Ti+Fq*o^k*>JYslRH6qvoJSv#@GO_X
zyW1?2*~;N1wdumVjFhD3h!sL9SjLR)>ex?Wy54k=)c4{{{0#371^J9YaolVea7L)r
z+g+%T`I_qHI#qQYBgvVbJ%Km>TE%o2dJpm7uw06Q5}3EQr+vql@7K+@2c=S}+T}-T
zr3VT_um*}e9JuAs$EI{lli{_B&;Xv#*_y@h4sRBEJx0fU_vqEiK3X5=|FrOMQ}i9b
z#OYJESs=+3Qy<dnL69So5=MPm_B9uC>nqUVS<cVTTG5ylyi)uAvV%UG3gO_q^%+o5
z1!Tj^K`MQvP}R{(0E_-g`|<bIm4(a)06s+x_{H;2;gk@;!JTQFAvx8#oH$vx70lsc
zD^a)%-n|Nwam%A=FY%wrCHpLx84dT{p;z5_0FV*&A>c`w>yAI)Jw<ruGsuB#N*J~@
zjmc!xTfl25uUFTt!fm`4i-=`xguL8ivcfTAH+_j;=$J+1y*^hf({3^-7}~$DM)@Wr
zMCL!mK3P9cmcMM=UVpfDp`DJ}@aV?nuz!6ZwQJu6evKJYPl`!f_5nj$=Q>)Qp<YSt
zf?95T0Vz&5#fh;b>C5*2VJyj)*Q*!NUU2fu!VtfSFFg`W-z=m*UVhj%8PV}PGvI=`
z)7I0k#b%C$F9iP|rrt8Fs_lCN1q3A}q`RdX6a=IjrIhY2MG>VX1Q8@fQUPhCJETEC
z8l)SMkZuW)JC^77zxVDBKIf4md+)X8nsbb|#)+Eu{lzK?;ilq``BmSXpH5$vCvRpy
z>^I1Mc6>SRxF<R}P+ENYGUv%Dcu>kNntUEDQ@`J8yS&r)u=jd~In70}y=c;Flkej4
zJ!zK%{m-jjCWMM|B&~~nKELE8*6q5UVXL^~cw2GFkz7)Hv+<@g)6_Wjxy11@b?WVv
zr;plCO$<J^c@{S?iSmvMk&IxA^Nu@;(M=%<vj_Wd=uC6*VWgtneU~Kt`FkBAY>B)3
zbm`T(n!zztpNWtMg9P49PAI@Fa_aN||L&XLiH8MAR=}K>UP2vyE^<A6gYGLK5;g=p
zij`xuYvB`t>}iuEAvc|o2karpuBxuB({c)Q|CnTJo=HO;g0$lKVvG%kz6$$O*Q~<F
zv;SF2+hQg{itJ#@eUw$dL5>tyKhkgW(D|OuU;ecfY$8Sl;22)ta*|g$9u}+RL)CI(
zs@odEwxm+oL|sX#jaLi>_{7Gu_i9=UKBLq7tTG>9!#ZB6N3%iX<p|Kl{dPw^7&Fr>
zF;1RljeU1{-JA1V?Hj)d0vzvMZO9?_4{+r8Tx_tEl=B1Uv-~#RK7;eu(~%<HU}9#i
zg$=+ps-i{Z?~zDpwd=^Q5n~<M{A7MDqHuJaw(=IPh1Z~Yta%otDGnJ=g}%)q614a?
zJNnF=-828o<{T}(PQiVu>R@iTh-GnxJ<Mm(Hdbd08=b{YH7+fRQqm3=DbL2+to=}x
zrW&ipx(rx(6shy^7*6k<_SVsEOpK$U496NgV_#C1W+jQe-wTzj^R7~1GjV$iKvVxl
z**7&*Hd!G7tFh5#%{mUs{`{2!UtlKGg}ywt9Q)q|8b#rz*k>7XA2kqpZ?ZjcLVHFp
zzx5*z5M=?>6X@nJ$$Ey1-H|t@55|a?l8z{Yz1UoV#sJO8>z<j+<A*B7SyvTa8^^`t
zgm@&|2c=6r1VO2@!z@fAA>>_K#-3{erM5^^6^w8HviI-2_WP-+p{kCP>b<XQ$YnyI
zU$^p*g2nm;#&a#*oO?9qQP6>QJ}(;w@olm<lZp=9g_+yfY7mGeyjhm3Z(VZlT*uDT
zpLZu*d6d-)4yr%JAe-*$z>HPPpr1jU8}X{#vr&>(UC(Gh1|y|PI12?Sv%4u3l1<=P
z-dkV!K}ORU*DaD`PNc(R+s(S@-!k%B%ayEI7t2drK=|=MJtSyCe+N1%Tra$00r}5&
zik$LYM%d>-huL~P!{T(VF8|(w<NBX%&}KiMixB&x{R0Us0M(*(J^MnolTao;g}^Qg
z!qEEA!cg}ng?Kjdm0{*9U-(8NEr59w@eznp{fY#9ITuHmth;G#`D8)8!oK@oQ`F_z
zFSfz;9j0A_2WoucE%#Bv1R$K~++Wc0PCucU%|%oPXfk+PKMK;$P{8w=r6b32d4i(Y
zlfCfJtng_iJ)~2=_W&)ob7aK&FD?0<Xi2My=6KH#o%IYyMRAzqXc(3cMv$r^T{tYA
z+i#cPmDaI7;IK#os(EtC(jh*dSTW1ULG}T^xbsB!;cz6s(Fj6Kp`b8lnvgyi=rP3C
zo79X5xYzwhYe8usqG$*iSmgd48skLg>v>jW){bwI=s708ZXhRM!`;vJR=3wn?k_<I
z)9~dK9KfW!$!a}0w6s@L>GHT@s-qf+T#4^$?D=Nm^B3>EHvo*3>SG=GgHkUEYI)PU
zpx<LAiPIMHfbs!x$o*42EM}R|A}YBA-~YA(fil!9S0_@)fA7pczI+LTR(jz9ebj@I
zC;vV}%%rGO4k55xK7%n~YOGDGS@mO1UT#CRY(0=>Q>3QYta%Y*Fenv?!T1-9B3M9;
z(fkN<tzmB6Hztg-k+)hcA{bSzn)_iyRtU{#h;Dk+8q1O$XU^m52ug$Jp8k+Ylfo{o
zuy@V6m|f)4GH#qpU_~@&1D+zoT1{vq5w%fRCS!?1Xl}SRl@UG3tZuYu7XQ_ZXL9O_
z4T5X|1+)w!G@nDiv+w>Vi2q9`toclu7bBv+?~?kcJ$IA6vUwj+(>qIGEik{LUw7OH
zwEO0U2|VTHEzHK}oXy!u^L17DT)s#o!L*QO8$tpjmB;Z~?wDD$JG6|>=03t6Is~fH
zVkC3Fp(k?QZ5I21$c3Dvv-JYT0@tHohl<iWx1XX>l`<MXZ%RyI3n;P(oI+)1#DA53
zxD0UH<QKvJ++g1({#Vt9yhOuv|Nrkz+${NQA(?5hWqAVF+y@|eaC$fn7?+a-KgMcQ
z=?``au_c5pM@S>MPmRv{@1p}u{B_Q$C~o{SvRJ8b7=CK~hLFALb~@LY*oDoEb&nnX
zrgNzsQEzkSeCk~R&E(Wrumt#r8>kA;%DcyKGmEw#%-euD@i}GphbGwSEcZoG=^J`-
zKei*$`H(9}Ur2UEGt}b_%$2X2WZYXfmuC0(OaULHL>IC_<w+k|>4eEkJVS~$F8#80
z6L+A4ZYzJ++=>H}z<0!SwgR=*-|+`R`azLE?>Ss?au_adP6#mdZwN(zim?o^6*X?9
zDOcK#-0*-9Hj85qRFu*jA5Q={^eZWh)C3xzRXZYiJimisi+M#|1SHrB&_)$EF-L--
z-IY?&#5duH`U6DK)ZCXWAOTm9I!V~(=})CULV6PJct|LX<yfClF;wo8IO(9sNCqR|
z#6QXS^w2PpW8wwO#W$p1wuild`|W1#NvT8U3{=@7Z1B7c+b^hIb9JLQ1E^}^(wSk-
zpi&Ju*Dd7^uzfkjr*cSTr|Cgs<g73O%`}!TbQ$z3NYreg8dTDU*BXo-TY_JqBvE(0
z@(#7I^N5EdP*+Yix@HTila@)Zs}D#?B*qTGI3?>9Q9#wOz6e2ZvQ@VH#bG>kU6PPc
zDr~g?q__5Qc4>d5n{OdiAKbO_KK9uY2b;WQjU9X7Gi?L1KXfZ-YuZ~U=G_z$E`7EH
z8V3@&*%3|qd2CPc?hIu6Z!8q?$U*(@0FA5QdBNpT9muhv^sV)P?{0bU&nl0P5lAeA
zP2vQ*lYaWf2DA@+pep1afCQ4k-(e)2q!pbOv%90=X5)3zNA*Z&fvDu5dD^0T1g%as
zc$v)uHO_Fw#!~>{tUX;xb|z3=mPNXha<dk+1L&iY5fQ;p@Frbtg6x$T_dfp78DzG!
zh@CFPsJcRaQ?d`@9V%}?3F(5K!uB^6b`mI@j#jebO$4BBdfYBd^nN#eucBC6z5VSP
ze71_jdR-HbtPASxC$P8X9Hlc<3N#|6^m&0)oK~mo5Dj0}2QnU`2@$su_cK(a4=nxZ
z(DOO1AwJ-4_gj^MW5{E01cV~dQ0zrGgsJ8`^#mj1HRm?!2n!C(jvTVn-aGi^J$S`~
z_CDx6;u4uKOW`airs@XuW%C^3-*-evdc+`Lj06WwG-fv^tYqNc8n1u|*mKhWN-GqC
zUL+a?v=7dLrlUe$h{*okbI9Se0fc`~>>M*wswwFiGLrA=n~~br$Ho-VVhTfec!l`0
zb_9j-;FZ7WVenZnPtAk{|3R(>14bMvdklpBKK%(@REXUP)bJft2;v{Yg5kxiw-f5w
z*Fd*!p{`E-z`GHMOu_-}Ngco>MPN7|ANVOFey4Q%u=Nyx=e$ba5}fW%yUItMj89;U
zRmYcRC+N?dHJ?D;aAvBF0%)@*^0juGvRC4|do|Priy`Ar?oTa>l`{y?s+4)UPqfM%
z-HdWf987(VMoX3;ylHlORr2Cc+ZEymgJ>R3=G_<Hdo^o|F)XP@<4+BUXC?;C4Fo2B
zY$pW4FsWNv1@k{O9u^&c?+%u|itSxXyaPGPazgdfW`Q3=;CrDAY1!jpkuD57I=mqW
zRdHo=RaM7jasx-b;foD`w92z2W0w~Y=E#IEFK++=x<C%#RMifh&m-_YJWiHkRX`Qw
zjb|a<bn6??<ixQiX8XPw%2`y>aPKd0?SwCRQ1p|JHT|XY5mVjR!S(UHj~Od7(HeL%
zTQ?r$3{w5k+DwB(wW{_Q8atY&e-I(v)r{CDRBJHLB6J+r8#G-a_KJO^qZWN`azwqL
zj<D~1u<Hm!`*T`@4l{^Y(0!?~iHI7JHbDRB=bkmTp5GwPEPLrlF|!M;WrUps10GC|
z<&m}^H0{Jw)KrIWo{3K8j_ov@n?nAeLel6U202$)1F^mHxL(s1-MA^dhgA@{d~mw?
z^<C19bu`tlTMbCQwIFFM`(oDR=tgGQO`?pIM3W+4y^`?;w|2y&0RzyTlMU8q4CS{G
zdk~_8kXyw<X;~-ds41e4J?1S<SNjaK$|TjbsZ@>=h?^@j9{r$kKJJqEc`AqQuI~&Y
zjl!Dy-e{Cqv+na7u_N?}jMlzMDmO*k=upjI>3ga5WTp7XQ#6Cbr~DRgfF_^D&c-KP
zQS0mZ`WeR!JjzO_rO<z#N8WtoF5IRlR=k(RR&tNv8Bv;2;W`c*$9kO`sl4uc+FV{Y
zV2X|_0e(=p;|Ldo9@W?`_f{vM@N-DC*5w&!1pbf-e#-SL^)xtqs;>isxp9+@etqw}
z8vCq;gnWhwquS_ULOhxac2X_<LlwCB#^UP?ApI-(n)e`;bwZvS<<&p#IO3Lt@r1ED
zJINod>{zsux+kA(rXXB}Y_@&o`Lwf0Zn2m}5k-2E!RN$U2fENC<Ig7X0j3d2xvw4m
z7A=@Sjkq-r+bw=_eTHSkZy$_WgaFC;Wclj20ow)m&B?~%6i-O$q}@A{ewGdiyeem4
zA)Jntz^F7bQ)OSN!^!H(uO7cfV>a);gm;G)zAJ&FLw9Zgs#|uZtB$cd+hFFM^KN%7
ze-Fhz$7k;zzL=Nqb3psWcwgW2bKWwKfm~3;d%QGOK8Rb>9kkYTr8Fk^b+yF7HE%n7
z&09}v|AStGG~`d+5|sUV_WoiaboPo==EzV7k}E-w1NWQX^a-|a9(#IHu%l_7L2xvB
zgONg9z|(bkty_F@`ZXL1JL}P@5N1<lpYbRZQRMx7QW+V6;r2G&rvdE|cJr^5;0U^r
zTlc;AMSrjx4`4Kp6g^Bd#eQDv7r$-wi}@2E=OV^4Uaj!OP}-9Wm~!8|1^xN`2gM=K
zD3=8#8I#7brDgS^k)4FbCY9v+hVf+Tn6j2s?*oiKWP`nS0R-tJPASm8Q*nfKYz7b&
zghU$?ai39#LmQg_nJWoEE+iqs0-hXC3o3*Qb3;LSqv<MzaWbmL$1Y6pPDUNgEim2c
zTMVLMDm~ZSx;u*(=rS^*;V+2s1#-dxA{7Z)DXV&Bv<7OkS^$om0X?}~XI17pZWCi=
zBhUTCenXEYhVA-O$P4+ZiY_x1GFeEAQT}XI1wRY>bH4VGP8w!@<Ds6sCY&~Y?Q1f&
zur#VV;<l?cekhXND&q891w8a##XDBxUbga{WYMfJF5Pn$@|~b0Phs6HUTX@(;>8n|
z)SersciVyelLrLC-k#gQPWj~qZRanGf$2;wbx$E);XR!Lb>VXzZMw(GL?}vcA5q)g
zeU7;0NKM#>G(R4<sl;kVpMXPaO3VUOeQMK6fu@kx)ch{{6YKiAi`+NS2+xrRq>})>
zJJn{xVLEelACYjukaLRB{idTa!<7IWo|0Rn)YjhY2RQb;@=rgI`~>LHNJR|^5C{p`
zuHv*KCcnL}_4w@@&FnZ@lkRlv-hCA=0y4c5N&dP)9Fa&w{Gga-)+gj<QpAOcqI7-s
zwnn(r)&WqQgjKpTdgu*0-&IjLB!up6jWgo;vfq9IVGL8|FE%I41v>+_ULa~iI)~b9
zvlKM5p{tETcaPkEWeubc-#6j0TiXgjXXmxfxBrj*z*TIa7ADbkmJ)Wu9X(G&)9tpv
z+dLA{0<}xwDUhVjaYbk*5swVmPO>(+gpKdN4R{Jj@GTIGR8AIh813N2NkFG0QnRx4
zOE=LxdW;Z9F|o$rp3im7jwz^So!_bOj!Sogz%(P}=CJaDDwPqE%_~+(>!6w+fJjVX
zbGp!?k->O6A{vrJ!%?$L3vo^lnlIq^EOA3`06SX)tj(=U<T$*zTaq0o&^;1pS)%sP
zjUYXH3Tp2+c8Q}in(EZ}P(xlG4<Ejl&NkBlv%m9}?9qOHgi3lAEej-`+Il&REFp(i
zCDRqbpTrZ|SCd2cIN#}QSVA$XIY74v_{**kb`eg0b4Zp0ZmwdWS*&k@7RKJNpqoAi
zNX-N(5}$jk4CzdHtGs9lf4c>E^Kt*{_3%M!v8Z|<=fdbpHKXgH8cag-?5X<WmNe%E
zC{k+dQCar{0yL!*`!I~l8{lD{>=y?o_zs;yWkm$7M3R}2F&VlDUF7o7>vi{EVh@C&
z`_7Jcc$_Exj?<eiw3P*Won5=fa8<MA_Nd5<jb`{E_5l)Ibexi(LJO)P;>Qgk0)4TX
zIc_;_EtOi`9on!<*3z2SzeC1a*@JTV;>*j+zke}zKwjtcVj!K?EyiG#K7;8$e?^ox
zBz&<Wi~)UlK8gGSr~I(n2xq{vt*Oy^@Du!fcK2dSixE!mi~nzez|#gX9!MsW%#VL1
z1#D+i;YB4Nng9LV42C9+RLN=ZFG29*v`L#zuIMnU<T{1gi#YI;*?RpQR-c8onAP#N
zu#e`g-^jr6KCOHpz#)vIDB<_3qU>AH43#6=2E=Pi{oVcwN)%z1QpY&tMQpj2{CKu4
zj9r8D3|TXvuB>9)N8+9l%<!=lOq2}d=J=2R_P}A}loJtscp3pp>iK$@!&SA)J8G@G
z?(#W0qqP^*P$e{X^J@0t7~J&O1M!{Z8N|IOT7rg*q}WynRF7rE-%gNht5f&|TeAgH
z9CNH3y9gYRiGCz-d|CN|ZcsDUnB4C%HgGszyo{K+&oV;;*yN)k{QUl~afCi2qzb?e
zP<iiw8Vi3zOc*_v`Qldt>*QrUS(DrIvSg<i^_Qux$4&xw?tD>h?Cqba{p|~`4wrA9
zGHF=fr!7UetzLR)0R+?6E70JC+VUCVgnFQz<$=#0GU#cy=igfb8UXt?ODTdP5b^AT
z1j`<!PnVQSFYN}wo?bGWd7Fpu*)O7?&iQ#$G&D4#Bi?RX|6&N)eq|7>Pt7Nh`#$jp
zG2NjY@)|;IVLcbxho@=Ct6~O|bN4-z<{CYGTRwozFT<@QG{F}PS<GYt0e-(VNFm+<
zD!OL5*urHFJHdM>JndHWpdl41$At*-btC+nEg*W20U${9{@W%<4?r|iaRwI0{IR+}
z7=;PHnx4$}#|!3skbEgwHIM!EN^P0V`z70c=Jkd60W?!!Jk)co*It<6dl%}LE9^9E
z6-yx>lUVaOjcjwi$#e%sPS7oG0XCruCe0k{cZA0Hrc76GJ3H7~Ucvt4STzA$K-<h5
zaKM$1$pdV_HWLqlASy8Mp`xBhcdsyNF}SQ7L2M=s$tcVctR-NFK09DKsfNIjZ@_Q9
zdU;Kb_!fOvc-nZXe5gtq%TjC?PuF6U;$O*J%V7UvHa&1>b#}(Es#7{pNP0hU>rMWP
zjeJJAM!&$n;8ppx_Y2&!8>6mBjMikWYYv!!R0PWh*_xm^AT%k4rB-J3ji|5c4Csss
ztiJ%l2{|I57S@3TeFn}=&Kh?o$`$Y|-}4Fs(2#TF$#WR8RuO&IcMi&qUr3kVR@;C1
z_xD{a+_!O$Zpsn25ge+tHj`=Ar2ol7VkI#Pn*jLBZDb~dm*y*6I!Pn&G37{9LSXpn
zsB4ty1Bhf51qG>%6GQ`P1m0uQeB0&O)hdI+2~6d1q2Vn&v%U|a+7MGv*tgB8le@4d
z0a9Mm^7evqxv^qXQy2zA>o5yvrGpDz6kc$Qs!&}g7bLjY9425X%E`q>?LEau-kZe^
zWIpc!;#Y!Bd>Lr+!!r*|8w$HnQ<!?;0S%NDfV+eS_!Q=AK4B}z+3f^)$KYKo*uk1K
z-G)?SZB?pSjP-(xR+Q=6-X|qUJY~N%q?C_K)?>y<98XwM@*(PhI0+(nFVdoLRPQxl
zpFLS{`flx^hIx5MF8{kR{4KHMjGQ<U_Jx9c3UVOlsCerFEI2G}iORv8o+(`%3Vlqu
zt+@unB9n&o=Z0MqGWzLXmR7+Y6U5;v*9@V(7X8*;hk#&z5UEjoNP%Xqcdb|%zNj9$
z!Z<3zTnH6T&$gfx)dBU%CT5Zp0xu=!nHo)~YV+Q4Gn{jLZYb<ey}QFj0atqMmm3^Y
z8XF7?L4S=C7Kdo+=K*Tz0x`XebpXw6mu8lz;O2PY=^iP2OCSyog9~mQUM7KA9n$|9
zXHo-0Lf9B~Jvzv;Uw6Fb2`~ZTc0>{z9*l7>BlFg$Ld3H$oTS+FzYnoB`$d<k86=!4
zUZxCQ-5;UB1xc5>6+GVk)+dxLoNbFPUC@591Cx;h3QP9Zjl~JFp25Spv%ea6{)zpC
z7hg6_e2yM$9RwBdUqR(EQWF7@WL^uu<H824r!y12w#+BX-6UAp*!y*z6tLiA77pGP
z!>+w?*xj|(Djj^(P3cLqfMNxjfjSdCK^eGNgoN^>-Bg5sT7t%5WquJ4UK)Xr1hMiQ
zQeKmSzO`^><(Mu|u;={-O~>e*KHIH7pxwws#^%92Ya}p}J=O;>Kp6A26nOv=$%%ci
zx&~QuCVE9M(FTMunu48!^hmrP&!h>UiX$oJR|D+V&fnj9Y{IUQ=64_r?01f{65J&s
zoV(X})K4`)r@suv%08GGl;MNQN<=K540d>KYc<{wFnaO|DrP0`;AYlrG{DEIj&tbu
z(Y5mco-){;Zz{ftAxFID<D6Hl`o`4krzer-j|I%9T`4?XHN}<E!Ld1(>Q>^guPQWk
z1Wkcjabu4nz)Hczr3A@MeG2|<JPrt;(zv|2Rc}0CWdvd>jq(y~GM)k$geNWBOZnzE
zsNf#0_O2&X5=!%<w}Oq7VBG_AbJ4cVmVXQcM9Jf@7@wSzn=1}k#4yMB;IKb&UvN>X
z4ZKFw&M%|$gWZ4VNjlD0zQ#kFTK!05ZFY?hj`vVOM8v2Xm*XJLpchWhW)HkQzJOI%
zTKEoA2H;bkuC@>eGiA~K5im8yGvPOIvCvYlHAXdtKXWpQ79bSm<a!MfsI#*y_)$m*
zBNG1?135nK7lyLmkiDmN^+2o=PIc`aNc5sz=ht}v+B2OdUjWj*FNXg;nuGz3dI`Vy
z8WA(=9Q+ctV8O=Wocp{qV$Y&LbhnNxctYue31B7*a9Yt2reQCuet2>Qk|X03L~3f<
zM8gQLbo9=tt`zw97JR$#DY#e1ArEdOnFh_QX7aRVKoVJT$cx2765kte+OhFuX5`-?
zuh5I;aX>{jHq`$uOi>IBjBlXK`3Yx43<w1rBa5KqcesQ1^0LHm0(k2OV9+CS@Bqb#
z7077z)~nxQWl8=$v4jkTgnJJjo5gj*Z@cqwo(dj?06g!1?<=1JID=iWp4w-`w}V&@
zA^u(iP68IrhXql7ekhRx4IT&CAl;G$oRA5ie^(y-4bdlrz7f!;bwMe@3$Dnh=H}P0
zk3d9Fa6B2F3)PNR_WjiDDs?P)C-07CGUTnka(3;4&aElatR>*g2b{+&kgz%o(^n7#
zSsVlei;u2I7sG@5y0#zIqHzA_$McP!Xl3Jo>GENL8iU~O-Meq>uU)5(f*MT)V9-ne
zzWSHp=noq?1~%g+BtRT4-hs;(O4Ztrar56Lv_vHAwu3#n;8L91nX2ruEe>=BB<?<v
z`w_nk9>CGbu4v=upu3M8Fogs3>Uc>bO<4t8#B@{8`Wqt31nzM}gqQ`Z()=$qGz;%Q
z(D`c|4)yVIcNm8=TNL(GLp)-dDN>vf&j0WGU4R0Kjl-$)*2a6b*0r-1ZjM{S2_AA4
ze0ooi50>u!HTG!I>jkPnQ~e&~zI4HCCT3Vk`y<--l|co>?6LooXM-N)XrbkbF<E&e
zlU`7YMZ#C=V#Ma6{86m3b6kp*QlNbB$_ub9^)F*SQ%~TNhL$gHp2-o1!U^i1Snx~P
z|FVHI0NP}hM=xm)1$vTi70*GGq#lIGA$fpL&S?phlEvIUm*1L#ebE}Sn96{^#G7fs
z;jK^GxserNGYdPO`;ixNRX520_tEjfXNQ(xc$Uu8C8szjn`7Wmw~xZgdJ7p#(J;)y
zalQnwySf6$0BuZP;~E!fuRuT(jRQ@f_Q5}J8_rhGr+9eWOxDdmlz}s8(9+U!CQ&w_
z_69NI9`U13&w!RMl9<OxuZagNRtYT0a4AQU{mYclyFr1I)*><km9h3qRyAA#lhd2X
z8f*LC8goRbZm0Q1W3NX+@p}(o^n`xBd+EVB$UJ2NC1BBgU${|Lw@L8l3<}qZc7hgx
z#{ni+(VW2e0HMBBN+5=JgF_VaHWW50O#>f9%Xws<KZMyu-g8cLlg6NZiGowU2dEFB
ziK|_IThHkk8CAL_mco#I<_Gs-mCPhP+C!*SuwGnbD!&Uh2=;x5X@@959;Ldj4Kjcg
zyNsAaM+tO>Os3v@LE}64*0IP@(tLy7FSwZk&El#G?hqGUqTZS@0-<m8zH8(INsRMZ
zq#q^a-u*-Yc{mGlB0uH8Go>lh`M<BNx~2$i{$u-Qqz2QRBJCy`^6D`j#F1zqAO|8Q
z8B%#ndPs*Nd!~J@3Jt5rh?Ea;kUUJD$Dq1)g%qE4y9FGd?m<T<uzF5~_(Bar^Z;gI
z<bgn0eGZa{@-#DoZQS)$>5#ov>}n(Ob=l@lf#t6}g%Favyol*~xC#o1VpJY0qgou#
z<^GR`R4q)mgPpkQP2>VhySD4x_tHVZrzVKljp#lze;*jQA7~7`R^2g;tPQ1aM=nyv
zG`>7{diUI2LZ}HIU=_RnTXGl_nh9?Rd};@&aMUMfrBSdhz97og)iRhgAO$AtUqpwV
z;C2)i%!gfrXW$Y9loiq9o>mNN*7OU(z7}jRVFa9K%?=qVH~Q$H939?rp>>2^!X;P^
z*3S80{jz{c(Cru{EVPr>OU>&oa7}%uci_&b=N`cn<Kl87h+h%vMrteKc)neE<c!$E
zM$=ilk66GEd8BZS^`kK^E}^H2#RWa_ym#WwKSCqmSZf;1C|~i4Fp?>wht^JpVj0Xg
z#sMY@5Y%N2ZT=%V*J~|2u__>ES4i<#p;+Aqk>@X`ST<=n8&VrbIVt?CH^AP#&y~3p
z?Dc%(%v2Nf1_gMU8x9S~fxS}(eXghMyddl-ubKxI?NhAwMP2zS!Eo(<F)jZRJF^Y4
zJ*SsQ9x`HLVGZ55O6_t}Ip$Rpak|o`qpFXw${)0glP^q>)Y8`{zgyo=pBe`SzuD6A
zd2f`R%K4+Y`n=^(fU5CE$FUO)V9OouIB>uBOmK$<`ZCIyr>nr5^wU3Zf7t^S={M-f
zx#56#2e$Rw@jK8HnYJ0sg|uCOGs{7gMPPz2pQ)^S=E9_84z&Nz9x9t!eIV34q+!}*
zGf;~;*(3LFCFi{UI`)n`y)-qG97_rjIo{6ee=BW@eqsp^-7ji!`MN;mrbI)!w%*QH
zspG`zD3+B+NZ12@B`zv2dMz$`rFa7wdWQ=WtR1%h)(&i3Od9E7l1^PjFpDjH+ARA{
z*QP8!)FAi{q)eVY;Gt{Ts_TrTiwCvf#yD(22jrVDeC@DCmbVU4_kxpRVFZrkuE)ou
z%GYTB4oyN2TiDRGAalwCwts8D1u5&-p`WW6NCq>`ae?DZO{pY)c|>{+m1q5A188dN
zwqZlGf>O@F^A1FiYP8%sENv4((#JjyqGnaXT8bXHVp?M`SZ;fNtKnZ~DJQomJ6{W@
z^V-jA3AMy61#r>2A=^(_i6jm%Pkl-er`+<VV1-o#CW0A=%8`RI$R-mTZ{x~Mn1q5k
z57veNZ1Qg)bWe8t>-ZS0Ru_7kC{2JJyj|iz@-$Q7G4#<>s%fBhABK22C~G2kO&RAb
zT)kABCT3FD_Ti5oj;>xp_d5TkvWX`!V_kHteFBMoH@L_O%HK0?^fcop=YDP}NJ~j;
zClm}cFh|2YjN1T}vn%WU5Aoo`R72*6mpuZ{KMMpmP}-HBgAOqZCR>%k<A`Xw+b&!`
z?Fpeh?jo0c^Ak3M&#NH`<UNQ-ph&mwnLUyUF-=b&@G`*;b<)1eyX}-kqJ8D~C$~s-
zWHzm70?jpD3Kwe&kmGx{#dal#)j}l}!=*1^+Vro-{ECX{x!jw4zdu!!X8Li^5B~yD
z*Kdh8Iw}5?#fpNfpbZ=gm?A(i>-6A%&s1JIeqoRA*#c*A#SU4(j}G{%GR}0^q+GeE
z9Dnc?g~{J6P{h!IGng52G?N}tm3sqd#U&z+*h-XB#A|In0<La546{yG4_?9$FT4r}
z%aBP8qo?tWfTpyplbldK6mIl{zuVfN^kaBv-h*992E^i=unET?73p_pu-tsoR=fc#
zO|#WsjTgP4jAxRKs7o}K4Od$FX``kvjbQJYCnn@#yRKe8$`=S<jm|@+*%iMgIrCyL
z(?P0C0iiF7q;WKH3>wd&j8E-b7lr6*=d?(*5g@!|0sAdj4Zs{md{uS#AP=DOwH_o>
zuz(o5-<s_dNuK^V-Ri+o_5ltxxk%o85RThRh?O-XMN@+ezf~8($9oic#UY2C)+cG0
z*x19#k(@F}txZ(aEVYND)=KsA8f_=am5fjDoTzGnB;BD_Ke)3YNUIe97-e|IvS3%~
zUj{u>6zsJ2_L=^!0tY^FCQRZ=ulSb7k(84-t@KE8%4MpqO&N-uqx#(+U&B6iS3NQL
z#lxl~N4(+B%VgQ{Hfbd^7fC5QbZCVU43#NgK(SW_YDuNXRMXy@rJaY^sE;P{g2(?1
z8RnLD-XptZRruc%EPqX>zoy4QAS={;hDu4y4ib2+x?`0M2h-w{_|2M8`f5Id0ypkH
z<LzUp$V3IdL9Mxb@V7$&l-ZTuLsR)UJt&Db3NR)0Cp-%yD`yF_`vARL5up)&-D)0(
z&A=_mD6{Heo|e4rRcROOKB}Pu9Ce(b5<<Z+IpXXeu%{OyuDhvv!dsaw=>@|EH)$#C
z=1!p4<v;q@Acv$ILzS=$QnycW$=0Ar!+t?!cQvx02pl>+P$pLncVPEzKlzIoe(Y^X
z&VoOANTdXI?$UZ=OqXNh;y(L=Tj0}05G9++hrSfW<?qD%K^0orG25N+5F)b6wE|5=
zGi>%eC0F^gP2>azs4ogBfnbiP6_ok{pkXzB2?G=eudA7Jm>9L3K+yU!knD9!3a)a8
zSW>P&LaJ|Ztuh%f$kb0E--sg5nc&~G^}ta^TU!bmzRPJPzC4f$*&^SFRt}=k{nUz)
z+6lHCS!*MT1gA|<0}LOqR%A$H^g~*U&<Tm|Ss?>I+8ZJ;1B^(TC!iATyboc!hu&E7
z?(6kxaM@8N$UNpkZ|39X?Z$|P+YH8nhR!8Ib4o@CH8K4AyXjIHw%8-=R)_^jw|)<W
z(}dCmF0>9&2relr?@AJY948@cbrp|h4Gas?*4quLY9NhHow>xuZBhK|6d8`hn`kS)
zb+TUH5M1^bgKap8CJ$i>NK7kOs<=z>RwHr=%322k%GCe7m6MBJJjlHVn&`tusIZ|q
zq{DNnbsV;9__3fqRYYR*QhJ@|8RW`4KQ02NspAe`W*>y=jBGfAaKJDXZlkGsJ`2(e
zFor&|`}-GiUDo6;0PRrZwB-|I`mAB{^1^M^6H?5^))7O}FH1kUKv1sRGkGx+>%GH{
z;ts~;ct>&!0E7xOC0Wo{QL>!_CsiSgIFx0Nv=qKE3-qH*&qG&t^-~ILO?Eimi?(cF
z2Dw@vHRIQgT@Rgxr(BOCk!I`aL9;Ftf5LV;U^ppG4dkRC^d~kmDwGN)qhy{kUj^CF
zL(!Li>rMD~pHG>hkL)r8NX<b08`B}u-NGv!%_mfIKg5jKpc82!y(kTNe_H-1fyQh@
z&RhX(1J5YZga+q2zM?k@*!CAlG(wA5B+V5oo1PQbKt@i#5cFKY&zVUZ_f`Sb!-ae(
zgX$V9^CZ(a*r1%|=^0d`+knIY_v=K21e>kr^^nFZWIrqy=z?TL5AMW-uuY+v)({cQ
z5)1~EB=Iu32OaSk)hrx6hx`NAi!><_3Y(C(T=$O-q2nLp6wRIPyhdu&;Q1iXJz)r4
z_$c8U#?BqcOZ5!8vWptH41q*0CVBkRe3Q@YjzdQ5yc1fWX{=nOK=ae1rKT<j=igg|
zOd(I>YtzkDY8^C^#CrxOQUc*O`*tX&{h<n2KPaFxI7w?AFr$2&eu*-7N3wuWt$kzZ
z3X%O}wk@j3jUK{w^m^Vu*GupO!v)Y1PHLY#z}Y?cab*W2NOjb7Z$aZRm^%9BV=0~!
zPLpHv&b1}<yYZ(BB6OP**B5MCcJRu-E&Ogt{r2MJ&A05aIF{ZPYI1Iyi;qK^NCf0j
zi{CUo@&5br$3T0Nww@*aO@XX;adEN?uYab@yhFi?`k@@!vmDj)ROH0`-Ml!e2Xo;|
zgUJK4fwoKSCY_kOd`*%OM`<o*<_&j=pRFxk=Dk$-Mi?a<fkE@mFyi%PPgYE9%m%~w
zvemBg1#P5d!v+4aY6-fkfHG^)JK{K;7P6n-U2UaC^d){g^K=!aP4_qAAMT^CM8A{1
zxm>qY$HPghXEc94l$L?t+4S<^H=-!{>k<nCKYN<K`!~PNk}hqSmyN?dZeh5jWs1f1
zJgKd_wY#`sh2=r-5wO!UkNRyn__EDJhJ<b=Cg0cpDf8}Pqs0APiEl(i%y+J6t3;)y
zGQW7W_Pqb>W^_3!{{6pUS7%3;@4OQiH&LY{V#WyE`4;VG^>p-danX75TJ>^KY7;fC
z_w5@d5ew%rOh5e_$++;J-Oh9xbgo^XW4n2Uw()sOnpeymA@g*M_=iazb)^zwtVYh8
zS7N#`E}8!%dY`<g+utE?Noa8j`qO){bBXofW{u0^2qv|`9?$Eqv=pfo7xXZjz5t9N
z+-u472S3@8$vbjbc|#KI9OYaRZOfFgJW?tO?-u;`4q<W7Z|8{cU0)zi8Z<f;pw52s
zkZ93XhBcvOsp0j@n^tqP9NG$6AH^AzizNQ^Ht46nI+_1+ll`*q<V!qv{>(s<x)!ZC
z8|v?EWhE)U84i7|7^6DoZ<imH5AMy?6UFj;%$%%LZNgW1ud+?d#rCcLLv&_5&#y8=
z`7m+uj@u{IbMphS%G=Am?CcTL(akRhupY&-Gx?7fDTlrsDBWJ^Wycq=j?wY@9s1Ix
z1pTHeYjqgu`^?qLXsb(c>Yi#G(%2}gZ_G!HKKPxobrnx<J(g7V{c-yxE8WG%N2^^7
zzy6*+9)5e``<K|(*6r<e*4yUyd}sN;UodiyQQcNnH1-0O;WJOuf4d^GG0y*?9^0+O
z{~+$6wNV`XATW_+3jsN#vk{PKV~pvFzCOTe??G%C?BHt$(<h}N#<<9*5dxC79=u_-
zNfvV3xN37t`sxHYh_c{+B_d(Hfm<HaZX0s^qx*($@iDOtBd66L&_@|~Z7~ermm{1X
zk2|Z2J;6BJ(^aGu4WKT|=}Ea=S}eRIvJuMtgRJX9(qjeFlYVtWH{!-p99tv*`4o+O
zm@?5_S|$y0%dd-3Pp{!Khxj-HyeS!JkjB7dLo2P({SkolwI!Q}9bH|3i_RqvbG+!a
zoXc#73@k+e{uz<T)9g|64gy!fC(<99m%L_>3J`f|&cNP04tVB=M6K<FW#m^#-Dep2
zkWNa{hrh)ahUF>AfW6I*vbrsiF-D`QvEd9&*co|}$`3E0g#QB*)8)ud1k_80+Gn)~
zu?w^}6=G9UQw9Bk*?qUbFOSops4c&N%hoj~Ge%08um9;yat@UVj>fQU+<%_|J_X~4
zQ9|`)IJ)wUFCdtKeEmu9hijUJyjzf0i-d(yp0skIKruH;k7U$;w2sy5bbw&ash0&H
z4crIdPb~f=*abaZI}cBiL|tuSz5YWW34<`W4PA-?ygsZVBNF-(hwFoI{@O_g>W>00
z@$<vz%=CCOx;dTqu7Bs2Wye>bM$b3#Ya!PFy7O>kpqb<}E1_nEwYT}YvD5(93&=@c
zA5P#Z8=UzI{-dFfVm6j?yv3kzUF#?EsUbL&>G+370%|k}b1ptgVQ)PgtiyO0^vMDl
z%Ro5Q55Ub&5JSBK9(TRnqR|tN8Qm;-bs&|@6v@9q?8G_K%#5K`Z;PSx>Vm91B!)!`
zpaQVdRUDMUHTd=PyCCOh5Ml6uk|-YZF5lo76vhl5Z|jYAr+XgFt}C?RdMxvAm51I#
zaMOD=)>DNE2dp}UkS5$~ee7``ftC?y6-<W?L26beOh|QpAd(M?DU%!5#gAMgHgSWL
zl0v$F+RDlCQ=Y5?&EO5<$uje{t9crq0!-AqV9v$1AJ}~hC8}UbP*K*K#=&%XoCc2!
zXgoZ_Fngr{&43s2EG>BUHF^M<xCyLI3{+`eBquT``4HAH47u9X{>5F59Y6wsg<rxz
z{{}hvUwdYOK2jc|+>7^s64`%C;Lo^PJt&zC;cERy8c*NE^g^Mt_B(g3<)<YOY~Qi^
zT(-$a9T*r@X1q<-L*|UxYyqTe*sh3@39HbbS@P=r5JID`^M5OX1z@Mb?|%(p9pk((
zMlVL@AtNx8&tFQVM<^c#JhX}4ERdo-#>}pSIu5~sxZlk{k<(KL3o{DA`mQ{Jc``$B
zBH(@*YRA$!qNjrFOmo6B52#awmv9IYQ^C>i4XJo#Fy;hm>rjOgp#0PGO8;FDIpQh6
z6og%Zu-ZULf-ez&20#}J;GO1w>jsMvglQkbx>Ufuepn03!^*iYMZ%EN6H;8LR?Z>2
zwh^j6<MR4l>R6p0Zc+X#*U>E26k)z3l-bMBx<9c=`ScMFo~*BlZ+SV<YfIX^ASXK$
zI8<CuLc$9#l-D|!L@X*w;Obw7;{H9z-}z_e`=Bd5bZ`V@p9LI^|G)=OO;v2t3vBd3
zgKzue=vkZEedKoDA#jqpN{nUzEgjB_3sC26Ji$OSZS)OC5Cmu%>${I-Iw;EO2W@)~
z3EQ4v^kZ!iJd?E{^9)OzWY%PPH7-yR4jrGzg&=%Hy9K~DWn}CA0)1Oix(S8skraVH
zd*<2eWu)<u3_=)sNvhkJ@{!?+v>xrtpNpzD%!v?;zHY_^<2L*lQVh&L&Ot93VnM2M
zeMpaXR50P!E?m;_r+3weSFp+|p#jd<Hv*LU;M8%!g2G_5CRwU?8&>+5mm?i-GsfLJ
z)aPbp0=*pelsjbH20DU0fPS#Sbty#*j5Fi#H10Kz!;@06D1I-gWa%qb{1+-hO^d+h
zVbGZTgdr1A0Gq0U-~A`h*+ZLpMih8E^hee6zTa0F-{G|60Whr!?1>e?r--g#Y^uC|
z&<sIG9u;>3`J&k?TkdHk{poSsO*_U&hh&8Ak;1vv+l;wZ{RirHxiet|D?{a=u3jK-
zGaS=rQt$XeQ*{n=#cww$c1!{HdsM>$sTBf%<>DnEV{bObSr|hB1HYHVcW|})Ikb8i
z+KU#~er+qr#ZH(##gAoV9JCG!lr&<fjAt@fRB?ib!8ndZJxK?8znnx%LgRt&B*y6N
z$P5L(@wQQO^lsnFix)ur*FYz%_!w&W@12^gZ}O|w2K*BffU#KK_og;t!bDJ&EmVD&
zOgMYJn;ULQSEViK!olPXYF&DF5}IQF1F=|oPwf><NWUBM^19)5{u?NS7+8IE5H8Y5
zmT<ZUiCRPZsz&tf^0Kj(M1)`8G$WJ9IHjefkzMd(D`_~9X2#aPZ<5eVI($;t%cWwD
z(Kv(j5B=^ivLn504k@SeHns0dWF=adOD|xfiW|N88uS*>>29ceZX!5-oZ;d6s4D1w
zd4W$EBf1*<^hanZlBbL3y@-7X-tx**?y6sprrZGhY>y#ngn=W~KGK@pfp0l20qRd0
zbvxa+wq5A4@=T<X^!fyh|31VM@U|A4H?YOAsFEUClDc;l0is}mX$w=sEmj_j38>Sh
zNkB-^#xMMc-viFoegmTo<SJL}YdYn{8PmIVJsLhGKDlzVTyq8w+od$cCw9&X8HXkh
zaYh&Vus~%ayzq5TOfmB@mdC|wXx%saNLBz{{svXO@DgrIG0c%Pif3vL`ZcN<?BA*O
zd>0{;@lH@#QUQ-VK669xbxNV6PFr??Pml?dH(zX6eXl=7f)gNl*IK*a=5bJweB4m%
zbVT8B-!(w?H(Jv<DL)6$El-_Y{YJ3HUk3+(goz&T9-RV;(7xHclv@!q5H@?R80&=4
zoROjks<Y6O*$K*=!SQ5PMwJpZI@}i*yy7hw!4M6$-eL!N7wPr1HUV-d-6p{lq&I5H
zY>F7paiqDKU|%&je#Bia*L1y}*Xk|kthCPEq48(20ZYaA0S)vwQKzrch|6+ZRNr&F
z@2Nw2`Q`_Dt44M={lZkb8bf;>6L9&}x&qDg<>>F=W`)<R1&ud9390N96c~bR)q=?%
z5AELhS%OvJp&bq;dJ{rF*q$;IYJR}<Hvc>cCXzMcs^dg)xKMY{<Dwn}nNW_!UH~`u
ztD#!g8A-tV1$JE%61;r#!s-o(v($pT6HX`>%XG`7DS(}NaVm*4dK%7;?ZTE<Y=x}%
z*nHY0x|s+u+tf6X`8c^ww~-Zvei8Eo2dAuJP^9^<ha<lCBI)F~ACzJ1+yaA!#ALGt
zlSWrnga~5=Cl?=LHZ!0o$PwFmc`t^dIFzUdS~4=8;TQEA<eXKR)E)_qR?~E&YYON=
z&LTI%;mGFL^pRQ>Sy>;W)(YnK^%@D9SBB-2S~>T);p`pf{AL#m_D^kudOqA3=angj
zl@>d(&`OA=f`rGm>ncSxe=RPFP=_1o)IoO79WtYe+-5_5W>iu25zI>W-GaR@pkq(z
z2nlxWe{Kiyb4sd&tzSNevNr<n!%D)TGdM?{QdSPUKIMtbU?Ie>5WO4Z%>?Mo^A3dZ
z#+kq^jkc|E7jju>cK^*Ob64BSqm%>Q&u5`$>aGo_V>}O-85^A7E}+F;{lUSVy<7yt
zU#@ybg$H%)+i^Jd#kHa`dRi?!k%}xpXzE`mXtvv)Pvop5EP;^{`*=HPu#?y-jsY`d
z05?`)8~9}?ried(<A#Eh1^0GQi_<%RsU>%<Z8o7y`i*!&@Dv!BjzM%L_Wn1NXfnbP
z!VS%Dfhz2QGp$0L4^Bm%jdcG%P_{8vr1<~(s_8&5)KRH91XbRJgjtpHf#lw)|5L?(
zRTrb_o-5xLM@K?g_CE#1G4QO;-QkVWYpV)Bm6eo2?)ir=gjZ{u-Rzi;&biF+`n~<j
za^(dXF>&Ut7g6js-4qSR17~-`e-lP$AD^r>pSQUd=sUO@_s&_(la9%|^oeD>b2Bs-
zUR5vXZLAs@&uZt5YNFfkCHxsBVSL>F#;1^?T3^?Rut{qB_cuYs!7HMsO;10NSIg~%
zPmXURgvc&=Xe;Ia@gbXz8ASK@Kv_db=)qgCP%7d6DlPg;bM(jR4T|Vf0=cyA+0C#N
zlRE`zlz}FQ{0C?uc^Lb_4(L%F@W8(|gKT~zmn2O#f$)%)PO;-T;LXg9ClJzss9%!y
zocmg&#%`T`BqBUDsL0;<AmR1UcB8e|;=g+6%>yXNtU+{<<l*0oaX8+dDYE$fbP0`w
z6{CC}5#3x!FKJ_R003GbAqgxtJE)BYQ?Fdy-*Yvys0djHtSdnR#2D$^OB*1;MTA`X
zU!E7bCcas*j4OpTzj2QjvakPe{zDKo18#x&3ns&)9h`$QO&N}DtF^&T!@zE6_=pzj
ze@`Ipz+QdmPRm**z1y`8Tk1$0vmNW>*RRk&1j5o*vS@>oTeuBxXZ9?G@lMP20255y
zMi^x!=^ZZ@JBY5J7&i{CT?Q!W$0xh_RO26jF!i6R0(OTD68wJ)B>h!C<)Hw0WHNn3
z_}RmAn&a;@T^uLFct|x6KKvXOSb&m#f6B2~Ia@8UB6FDXkIb7zum%-cze_OdxM7uM
zPDHCFXSp*Dzw`d=)fkFLGc})X{M?+bz7Ix-j8(sc2U9eE-XgF+9ECmb-9Gq>qhFat
z4sb{k(rfDQYS}4*LW8F%15{A@)v(hFa3`bpUhktwf78{!>QOr3!LSxYL)A^a1!?pJ
zzrlKac%=GY*Z36&^D4JqiBx%2>&AigYrh+abe5+_J5%Y?4IJ~aH4xuJAEo<DG{6i~
z581=#Ku^n89quH6K0+{2CiC^WO@u-Rd6glQ3CQp;gp3!k>1Bgk^?M==w?)({8#o;G
zK&xz{8`9h_Aev&$C<m&4N<L1l%#dRxK>|D3z!&v&<vcdstWf8?Erx=6Ln1r(Md#*Q
zjqms5<QM^G9_Fk7&guCypXBF(uS<5fcZ%Lf(6)(ey3i+zI2)wWEo8jB)-A@@#sn3Z
zMc{e@gmbEH&o#i@>eHMQDmbG!WCS^x4%VUg_}(1(B}U%q#&RGgI>QMPsH6(z?=lpb
z@t_-hHGKoOZy)lO8IkE`s&7~VoG}L(*n*0OES-RaohrtOvVRUXq)2~WCmem-wI?>b
zvxl)<=8)-a2nqxSgk5u%f_+Pv6YpZUb()rt<&osTNh>ak+4I)p$vT%-OPia}-E5Zd
zwxb$CJCBe8hre9mqQ2n%)a*;<&mT*d#?`tG<0}VOmmEGH1z)i;ZF~O%(0#{}a6qK_
zWuh=q+0hGWVYF*ul(Zi^BQSr=(7WLYPFMz*BH2D7qfn*P>PquU>6?Su>w~_v%dcUU
ztpNlEzo4B4nOh7b1=fg<$CnFOtaO5&!|_t^PXS0=-a|`z>U1s_>wY4>8+2%}`^>@;
z&5{*Ptk{Ib&&6&Wk4+`WuDynJ7>}^uMW#(f*BWbDL#=DNoq{$w4?9Zc7(EHL@nT)g
z>fF#5p=Kn?0DRV-;9B^WZC_HB|3@%?GwGQAETN|lLZR#?ZF>r{crMgBPboe-t4(Iy
zB3O`F*aTGI>;iPG%(rjrl^38)>S8V|)}%v<XHs;~Qx((ZQoO3jUP0<|da00c8L8_M
z4bU%0>{_pX2NS`f$P$h&b{b^LH2T_ucm_jP8Pf3obpQjYVcC^z$tM7VS2z*&IY*Nm
zg9N+>nCY+MEN`nH&p-E#e5$bV+b_`C=u_3L4_`+u(0?Ldfhm@*75Iz>1G+?AD7A)g
zc@Dd=ISsM#)(CT_%55WULOyL04*Wj$`6Q1P;JOP2Rfk=y#A&}{>@}8PKboX|BwvaW
zy=`1GsN*6bk!blt!d5AC)|6bm@My(WtINH42V5TzeCcx;_Kf#}3rfBV3%;NaxDWgD
zr@M-v0C0Pr3Dx}hpW3zRki1^PLxDkJ(p%rdhG_j{Z1m*H21+73A2=MM$!br-Mg)bQ
zVkRgD5nXkVSctq7Znzt&ZZsXF);K$aCFbn9nsoqhmfqfO#pjWXCjkRFVWzHhf^`Jz
zTF^lmaH|H8YM16OTpw56!mG2IHb7d|0|g;7z}3&=L@AYAq-;bf7nfXV%cY^>G(<Ei
zn*QUi@obBaeh66=DvG$Kgb?9_&`u*TJjrF#Wyq^zGi1>4YJ&~m1K#H~jWv`~a>S;e
z?77g?Zz~-hxegW3;@Qp$*MIF*g_s=t_u)bL9cxEHy?njh8-3FJMXks*IZt773X?UO
zfU9-KVYJ!3gx5L~`mlCrQ2D$`7aXZWmQ>2VVX^|7AELemIk$^txP|5jZ4RxTja<eh
zYk%HM%PPy6-Qth9I}@yD&ltZgz?}Q159b#|F@4Rm6{r>6ulVx_6)Rrxs8_T~r06=9
zA+04j^JP%Q?IhClH_7nJzU+XNxeNiWpT+=;%PFUR7sA$oX4=IgHHb5b88Vjq4}7cm
zfN@g?*<wGJGJ^8v)l)wpDV2JNnZ#VvZw<(cUa9e-ZjguLPea5nzcb;O8dcCc9EJFL
zZX1WR+yGvz_VL<~Y@psmPR0n$x$g@Jxsv%?*N%|t_{!s0%{1y81K?ArP)p!rkZHn!
zyLf_@`T{8i)2>V6gD?Cu-dZ$!xSEr;3?^`GPwcrKBZq`44q;ST^*jE-0h~!)L~U9L
zhp~qhbTntDTj7Aa**_E!DBDXZ%z8g@4BGGf$!Vm3jFYzbf?1WQPs@}K1s|N1WV1XG
z{CtEc5lk}}S4wHS8TZcRNU3=$2ni=KRD`5H^9(yg<M~zS2|bYeId8OelToEWLn{Oa
z1v%#R<I<OESER;`*YB2<7Ld_yPTNBut%<#Y_9Sq;qCMkVF6LKIMTGLJ%U(YAluVy&
z#Pa?$LzIez8N(o30OxxQl=LnyeUa~s&5cSBE3F_RNfzxa0kg)~K_Zxof~5SXXN7J{
zwnZC<53HA@Vb$O4irObFt9IdXfn6KPRp~+eufr6i@Vpl#nzDsMOjwzT8ICIK?y|zU
zihKlj<J}aL&<FWYQF!7Qq(YpRj^N27bMV4^yERj*&D(8m%$RP6?`^(%ZEZY&6FnCX
z-;oAs0w^Bbc9E?`<-zv*7A4a`5@$aDYg?tLdf;n|aDXA}K@awZ<;RjVbV7i~R`_>=
z^ch<kxsAZ>&felLS=K_Zi$+bHA=j#=8F6J4Ol=Oo<l#28dOwD`YLB9<$ORgVoEiQG
zG0T{o7?tKy>@yd6t6>53yiHKDZ&%q;^pg~>h5_<7luQ%B-;3@DP#@8Wz@5gDBwWw(
z>&QYZ;I_J>U;HyEMGu(B7%(=k#V&0Nq%rOry=bUM=^1>@&z0TI&o_9W_=^3T)Vu;G
z`T}4T6db$OseOd0SJ*x_JAQJy(zjcB9nC9&^dszy011#y*oB3#T}1|XBqdrmK(2y3
zo$R+OjklzE(Svpyu;k=_)~<c=&n_8zidGOtgd=WK^99A<gu;y1u|#Ic`|w)%K)c;e
z;S&f0>)Wrq+E`HhrZI|b_78Y;D>vJWOCtWg4ci=gW3QTdLMu>+;)Y18QelUtN$5|J
z0IN&uE1bGrAi}Q9A*Jk)1c7M(QPc&DFcgA{D)M*@$y_?Dg)?hBxGaU9$_Xk&u^uAI
zt&Bxbo&)Juu6oJ@cRE<#2Ty2Eei!fe+67GSk=(+1vl<j1uJEt0C0@#k09VMq1I1ZQ
zf)mP^`3*t|VgiCRX}aEaE9<h#f<BW5A09NDgi-s2W`D|d85<HCTY#PtBs&ve<fb=x
zf+*`{I>?h+Eog+sj)W{@{iP_&su9g81q?3}KmGYmOfaMJ67%?!t*_z{P6OSZc<=3?
zVTD7CwgQa=`_LO{1caJSQe&m|bW+5mhnkhNs(`d(d7Gc<J&x0VLE6Oz0>fxD4D8#<
zqlOGFL98X_*3urHJoF*(&=l~!{EDf?phu#gpg?`=1#)a>g~7nNr}`1}<dRISXCL4n
zhki@b{VOi|b7T_dPnLGg)737<&U-1=yJ2jl7>#`41^iEbv}^PfX#cPnyWTqm{#H@b
zdLhsU2ko~3!lLT^9x5?W7-Hbmga=P3AH#PX>0-kx-<61-OJ(zkV-hMK&0!#d6h;**
z|6;`FbPA{9OBx5z+sn@Y=(e<6jF%O^xugUO9xuQ|8LgG)Ag7(@FjGn{Rte4YA%I4W
zbD-7v%4C;~pqGGOlJO<R|63pM2N83stv3bKib!qK1$vxkB8o5g9LfJ*TB07y8|>=3
z`%v*AMRcnX)NqU{Ymj5l19<^a;OtU?*-H(c{Rn*O0S<%rP;;r8nN=8Pggk^J`1{In
z0(XztcSQ4GdF1o&_iFxFJkaU{00I$1`~>iB7;5;{eF(%+foADw1D^G6z!m>V#h+lK
znSfX{28JK%fNXmCL1a73nnAGJEWrKuK{TNXiGx-UgF}=m?!GHUDeS<Eh~%Jq=z$`!
zAQk6Cf=jQ2zI7UAQ4yR6|MvlAFulVm1Qif@IuD`~bv=dCe;Mi;WMD_v{ks>;AXfX0
zRQq4q;fswmzpsW^Jq9>1;t_2al4d6AwjOIDv<6rRG6lohI5x_X!}$gE_1EzI6)kY)
zHelbkh6_*zA;yz+Zutd<)jY$~UT`h5pxKr5iTrmnVsAsqcmyrh8ZvB>Zk<1N3m5dm
zNHg<WP7aF%?GK!ZvG*lU+c#EW&(#79oD=-@ZalJsoXRoGAYpB)DVT=HtzR(yHFtq5
zzyuuIQE;JxPLXk-(IAxZ`tTkZiOZ8{hp4ev-Lb1E-~+q|jjfpA9Kj*LvN6+cLsy6*
zmxAdNzwEo$lW}#f2J3@I>fa}nD<wLq^S!8>Lo~rV>W?W83s66dw1A@Izx#uRCX6Y`
zV3-f`2$Q?`=j!NT1rnt^CiS^lfxz-(zE?kn1YBi+I6t(op*KWP2)nK8;3WiELu{)S
zWOMpRc(Llk4Yq==?Z5IBY+3vN(_FAXv<A;){qwGEh-E194JT5Z0TkosbK?TrF@W>K
z|GtGKIfjz#-@FKBs-MvM_Pe!t`ux{m+TnR8`i%oYbR-E%CeKUgp4S?Hm79A#ev%Tx
z*0?_3)RYM{Erfv+d|Lf9!cR{xg@h0OGp^wx*_B%0mcq-_XOMc;i9~RD0E-~RiQ`iN
z$_gH&(K*J%!SUo~)Cg{llhDRHUxk(Im`%Dp5B4u)@VSlYCv?Gri{D@yU51E@R9|NS
zMECyVxv^S+#hCQ*Bw&F;U-0fm!X6>F<#yb~6nT4GnC0ld%g#@G!T}Y_+|s%@eFlmP
z(KSH)$Ic-X?i8_ISkN51f$npxAQPl9@@utrS1+MgwvXgRFLjX>r5ES~5jd5D&y7Da
zY57po3RrgF76+L4^>PDcBKq)z_WX&OLcqR)RWiesUZr@RkBxMub)H9`uQqD5>VZJz
z6sqwLlWqTfk|!LyL5+edpYPHeqG&u1Y&3<YdU(gM(qVZc9-7Yw34Nq3pAi}j<z{-6
zeh?R%Q1D$aZP`eH{7eZ6C$v3HGlp(b2ql;v3}~a7;FU9JG65#Kf|p64R!x5yN(DF3
zST2379_rE^1uUkr!q$yF5<)g}IT5k|7k9i^eqVTQ&d4dx|JQ!kHj{yPmjXMx@Y<oX
z^xy_)b*Ca%pyl?oARQv2XH2iTZXF1k)A5Ux%2)Ur93eZJF>BY+RKU788g>ma7Q2cD
zNUw#j6)8)qkbtqFK;MS#U3+gW+q(+nu6DD5T9FBHL?2u%)v^V?0(ogSyop-_bh~T5
zG}50TAX9Grx8<eBkl$TEi78!VwY~rNf^lxk8)0Ig<@`+hJmvQ%5bLgu96UtC-ZuR7
z`6zv1s<CW~8}YzSxMBWClXC%2K)<z(1wQ&;P!i`;AXo|Zk<npao$G3Z6$~>Nv7C6k
z4a0(*2OU8hR|Xj|9*~Nd2|_%Bl@NH~_1DNqNztoZO3^m1Q;DecP)ADybMYcLvH<wu
z8yIqLft(PD#e)e~`sa`2Nhv3oRGq=U9|I%qSDzmKKg7LdSXF!X1xiV$fONNX2}rku
z0(z9r4HzJebW0;Gp^}Qna|9`+yEYx7gfxhtfOOZL%X56+`+q;(Z+Cz2Ip+a3?6rPt
z#+YM_Ne*0Ic*T^{S!U0w5%T;2Lox%EaMt9m9WkliY<%!dS-(EG0#WTq-X1iCbYjb2
zS(lydJQq4h5UFedI9Lkx7~G7`9R=)Aa`^&e&QwsQ-AfR;WzWo<D#;9xPQ&3h2Eeal
z%X^1XolNqiID~APU?#+M8Pt@2?~iC4F7v>H{a$}1zc}Nx{vV!O`(FtA{`4*|ZB4F5
zMf~hQ<`%%B8#E^Q#r?E`>iC*YJCyjVTPtsYK;Pel2vYTXhB%1p8|y-L6F-M1d-SSB
z&t`?}-z>FJfB31<zK?#&3BHLFRINym(fB@)3DU5D;$?@3h?9FC6UJHA6v=X{&%i6j
z7WPup3%oz;|8+Z~@{2xEEJ_+|!puqS`=Oeet2s=wKX49Ov_x&G3uyXOg#;VIr1O2`
z2&66$b#R*8lm=2LBDLt*Ht1g_@O^B2{5ZTFh8;b_N%D8VqAtBmRbm-^tZ{`l^j1c}
z#pbKFc6o)vlyYbb+~_hLfgVua^xVY{4FETZO#3=(4INuAnBVj-?uRPeUB-?m>x6Fj
zzN-ID@;@vD!h{^`CpPR|!28c<ClqE9&b(Rhk9^IIGnFsTgPNyLEjw5F5a!T}XQ#*X
zZEX2b>;JOUU+($n5IpDTWb><8jix*{5qBzoH^v?qGP#~|H$E57ts!txTGDB~F-0R8
z$0bO|I_{}eBqx(A#|XNJu3R?eQVOSm9M7MR*Fsv^7D<_-c10N`HdA@+{PQFt{<(bc
zKnTU$oFyuk{3W(R(r~+a;jMoTA5=a#eA;xDP{U|}JZ_JPgOKcqCZA35SGI0<CibT=
z$R_}%ah73!jx6OrOyhC)?#x>}v?u=@-z8w9=c{36S^y#WaAtpgX~3KXcq9bLDLHa~
zq9Tmpz2UXVFmM*dYoI*XBOF|-@are@+gPV_PJsibWj~ND2%&%~vXu>%>7_wwtOKPD
zM_myFf73gKMr=qzg>-xkN|^#^?6#oV)&cfq{^IF>xFkDKqanqRptYdv{R)&?p&rP5
zml633Jg`0=m{QAAg)J>$VnzL<6ncqkAy^l_f{A%L^e#uM_5XPrIU;}a27hA&5*%8C
z*7;+hv3NDaXXF{S@cqt}7485cg)-P5;RA$dI}lQV{*JjA%M#z0n(w9>2tbNMgieUP
z&k$`Ff>6PTpd0EdPGq2UR{ra<!aoK;%wijS%=!nsK>=u8FPb9^WD;NC@mxoyIw2us
zL8*{gAG{ugd~f^dje!^#&AU{Fe{1J`DgZ$A8?^7vGFyV&Rut|Ra7q^jMtWRY&M#2`
za@+lTX3!IeUZL|b0p%-zq9DmrBKcJ<5>^x3Sf2r;0mNfCr2s+aTfUSVVh9WjbPBTw
zUM+^^`uiv-BDR`ke<{u2Ugdk!9jLh6gXK!Fcbp3m9(^h@HH4u5XAdYrmdYdckcb~_
z2pTa}d1!n+wKByDuDnr%?3!x14$<4!68!#ooqvgmkUww!{wzP}z&_@w;vvBa*zzn#
zlJ+`)q@{rUmLbEyOGlB*5D8xI!-MT6JHcMo09uvxGAG+S95<MzCyU>`ku^2M0BZo;
z{A3~J;as?IpG5+D@fk7}n4PscJp+{R=oFf$td(4!b7-uxW@ex~9Br--K^I*=+w?CC
zTf?kKSl{%;oyJR}!`Genqg=*5DJl#SmWvpL^#ED!U|=5333X8adN~}mo<Vn#WKOO8
z8B@Q;Ip@1)8i|*0UpB|v$7M$Q;$|m!mdH2lZOU5=G#xjIIpDH4R5n<~sZJ8hMR=A7
z1#!=uXOZW2WNfyNwO$>;xZ04ge12=rgS|lf@yY(a-jBpBI@O)&riJj~v&tKLRAi%C
zmo{9oFd8FgmTv6MxNrR#Sk-%t>0slyx9i;WPwyJ?dOC076)SV>8I&om1$NKIv*7*U
z_08-TinqRypXoN7$QICKZM2P|gvE~C-jnfWy?@V{5}D(Pd65;NI5J|&oSE{lCJ2e&
zJS_OQE`D^r-)JUXQZoJP&wUrNUMh%P9Af8voyjj*w{hUd`AlKg1uUX#n@#im>%&I{
zpFLgHPXcf+jqVc5v8-&|-I|&qK(*O6qW4^JDp2y=ymTI#&KhZncsDnj1+^%*Hi9l}
z1T^QKpEYjb%naLw0M#<Ri;3+h0EmhGo-w#nPs_-hWE=HZF1}ish09<xa9B&&P`qO0
z7reIMSC<{KA7Y0)&C`HB{x(1*AM_`{<UAem)~yrimO7bwH~tLzBlPs_G-ylj-HfH)
z*^Fy{`=|Cr$1jBa>+76dxxe31oNJ%}-ttKN@WPLM!&~t5-_<rYN|y<G-6U~z+V|>w
z&3)iczL!!<1E~^k--UT*Dc(BL^n~jhrkJvRcEj){^~fFB24=q`nfT6BzLZH|D>A=2
zUKiiDkG|+uYt?){ZCO$1_EMLQ;B5be3@58nW8-u2Ki#ureYSsyaq!;0e0mo6TDRY>
zGUn3I^AL0i>4@Zpe1+YtWC?NcUyTE{T|0htJlN~h>*GxWp`Highd<XJizfHG2{GP6
zmkfOnP7n_f=C=)iM%CDAx$7yoAqc9f4dy|JqyHm@cssUfPfqLk-W=&HG^a`a`}uUJ
z49SZ@oWL_o`KK^Pij9dA#`qxN;WiB05C9D<?rKVqi?Tr94@e<;W$gqEpSId4^{&A)
z2Es;pr%^-zW(PAeL~?_aKkO$K6t~q<{CoGLfkzLD@K`nKvWBK%zj$Ht4={cH>l3K5
zGC!+-z2ET(oQQj1k5Cq!RjItwc0+~I36{S?F&-Cd{4A@?=8$-)f>U3H;I1d%Cecpp
zhka$&oPX2cuBZdkKSRW(u>fJJN|{jR&cmap3!kd$&u`FcU2HlP3>Uo<%9QNU_QZ&#
z(!TfCT=BrQ_vUY!V%t&1ZupzFTlw-2T=##P!_?&&62W2pM?L^O1z@Mn3sp}Nv|<lf
zN?=suTi*w`x~yM-j}5c<ibfk04~sy5Nrf)12fF^Xl-z%)bx86o1hP4-#rR_yT(FSc
za(jn}`u8g`k%3nJ-Zw+&t&yht+4Tz`R^9QPxF?pN%i*VofxY<T^<M#?7~<Gz0Dsfs
zzD+U!sSy`}Y1>~(68@n&hqm+sILqG$;Rf!X$aGkliwnyN$$&5ou93jTNmamNPPm30
zVEd#QJmzVCY=SxNJxifiEq0w7me{Quxpa!!ycGHXerF@rEGtXD^S%KVnLkpxAp;ng
zTBRdQQ-%r1vBy`%pUP%Dr4Vmf?A)9ozCEpUiH;ar2vTOb<>dQ&Ai(@S3JJ!;ryqWV
z9U6*{**1^B-s5BT?Rzg2gU<ZHGTrC#^e+PnB*V1}Dy(k+Fn~e`3s)lcFNLBg!W&GH
zwn?A}hz8mqt!;y12{PT=fObeL9I%YW&4;v`Cdo6x6Uj~K8hhR|84Bf)8cpV-Kvj<7
z9r}MWK2=hDd%s?q!otQz98zF_YAE>74E(mXOOcVhJ~3C)bXCA{1#Ue?-+oc~4U>W!
zS<e7I`RA42Mt{%^CEoPQN<)txkiw>M<tLp&w%w5guLi-x?Io{Tg|b1UDgh=Y$!>P3
zoLo2|_13uGe-q-R1MTNmip&}V&B2a97(rh$5}}^0_o1wEqp1Uu+0(tVe}5ea7+aV6
z*1*&wcOT|vmBmum|8uwfLW<#dnXf~ou(opjcNId>Zt)jKH?FMbk5_$*@EGzVXB8UI
z=*FOBT2sif0jFEP-$HGO@&G)n(zaJ%%cQz<cAFZu|L<R{{lcI5-~kA7ilzP`L?Q?5
zIHVYH?fyS<{BL{zc{>8Jg&xAbHPBC7hBJDX!|(T-#hlYwBB;KSA<Rz-pr{feSw|=r
z2oV(StOoku2`$`zb-h_4V+*9&D>SdY^Y@)1`X8IH5Tg^R?V*)ICSCu&@|TJHpD@bY
z1bwYAGBJh+GQzhG@Fm|ympK*7MhWCNAuofS3k`@<#s2y6%=x53Hn_Og&(wMq|7*H|
z6cxNjSeA&U<QRr&-x0i_X8|M>gU9e7{5DKLzAayP<0-p3VSOV=+cH8#DKUOm!t60L
zA;sWQ^h2J0thVRC1T^#0hM;I175?x23J56%vp0ivP=p2$5D>WfIKu7ua>5Mbwk4z|
z|MwNs&}0ZrWdZO^5!pH4?Y~o{8A;8jVOa>Wtnh`b*9|ZzMQ-cn@4+^FMs>?s{`((a
z(eEIPSH`Ozopc9?6*CY(Edd<kgaVi<C@AN@*Cgpyu38ubZX`kpzSK-e1L&*=9&9eC
zHMd~doEG47`3qdXtRjAWa>WfhL<<H(b;c}V<=?mb>!lTv-`~TlyyeqjIM)(hZ$Ts9
zg#6I2*Sz}d3P@sp;hDc~2Zh0E`qgQ009acC0vMphIoA;PB7}oz_xpX-Hn|swLIl0w
z3mic1Oo35Z4-oA5fXI*t9N@#F#oxa*%I44N0Ej0$fe<uEUzYD<VBF!+Qd9mz^k2^k
zc+1qNHt$(}7-#wh0b-r;-y@{0W&;ruSkv_&BDd51@8#iQS6JWlgk2bwJwp>fqcY!u
zMN7;3z}x(vi~bfoo#x)9Kut*pt3&?hL_ress+9wT3Jx$Q==%_S6X9F_w$ng9?GVku
z5#Tod^;*9VKz`NC<iGMEIGEi3>Z+0NB}g97VcLdbcAJjvzn@=z!xJV7md?q)uQ>0X
z4%7NnEf4ZgG&L#xa_#|&y4&fIXFVv88~cAop-ZQMT4&~jyz8%*>y-ru@UswuZC!M7
z-X#DSv{lzZ?Y{+FTP=vPhzr6^AW6bDlAL18|NeQtVhspPP`?hlJtxqx!tl*LIHf-Q
zp9}F?IRFSDlL}60EHZ9w|MO6QZTgQ>K%yoUK>F9X5&+od|6Cvt2PaMMuT2=jAn*Iu
z7y#agxs1@tKgS9FZ3jD|duEOBxFBN?Sh}MNQU^h(|C1p@A{1^A-peM-`#m!M<)?yN
zC}hlnoGx%4Nd>*vJq$;X%L*kZ0^459x&;SG&j0fv^g-He49`^BRb(-|+wPCsS~&{!
za$B7o^tAtt1L+~c*vdk<HUGI8$`X~oLqB^A(Qo-R(mY51C#$e)C;tEX1uQPi1Mq%8
zsO<AD(g->Un>XU6Kgj<+lQBM<R~Ha=41!Q1i!mT{Xd+<<xyDcvbVBGr1^E3wO;mpK
z4?7G26p(oM<&P_lW2_+|AvdA7+uYwzhcMj@wFfUSQBr`(qXpe1%I?2ESqnco3c#Jj
zHSpl!9tX)YVDL8(huQIZze>Q?uEU^#8`f1teOUW_{|#1SMni;Yfh3d)%P*_z5bPA3
zolbq>2A5X+_d}R(ifwp8NrxCF?mFzulsN!*B#jSvd$+(!ihg0@_ifA{qY=io1Q6h3
zwi#kX@f?tb@0`FiIogHZ5as{hKlgav&fPD?Gd$2N+qVCOF~di{l)S~2HDevFqCF_n
zo@|4gnGhx>W{m(Rr<$`7DQTo?m`kTfE6Ij@+Qew{m6MYb4`Y4(#K4Cj&|z|}aInNH
zoRC}rpJL<6ClTjH@oUdLUBMZ!Auz!cX(0#1Ct4kB4&mY5@pB~WDFGqe24fx1@uN*f
z0ld13fZDON(+_JC7mgh!DtmJHegyH9lb-RE2>gv2n96u01%BS6a!d2?4clf0^nS`u
z)*T#2bMDeqv#?*>+87Y-!rGXO?C~%=jKw*MR#=+3&FK?-Em4(odB!vOAQtB!dh)}=
zedVZY8;yF}M;i~jPlHCAkF*?%pRC!O;#G`Znb<wvKQ*>wC=O#uP)tcUyKzQ}D8N&}
z9Swc`5445t{-XU<%6fL{v7061`Pm;`C&^kR97dsE=g!S8YO$XMp1BRUuFnl{o+Y;l
zN8`wZavCw8<!UX?wF!*H$IBBWDm5zk%zCr3U7VkEisDdX?rc5ZS0YHoXvA20blRqu
ze8lBBE@Z*5zTdFW(BoiQ8M`!lS9C(M_{kD<nnN>M%<-ym#^NJ3E7Djiv&TB-7K2Q8
z%7PRP*H3GoDB*QHQT-X6^H|P|lW!w%!~MMW#zjX;y2E)MQbmfO$ZKNFv=<4EyqFwm
zET>NQk1_B9gGj4|123MeKT45hjxRa4m|&B}5-DC=BG(ckJ=OEwSih>pM0)yg`f&dk
zzNi;^HU<4Wh`!FI^gtwi75Y&5wVpnAZM_;{(nci$;)d;wzQaSU#2~j#FFEq_#K_}G
ztMgavfoB)V{rBe_jxQ{i1t%WQFL@t4YsTzSXJo6<wVY7YS2;<(X4N?riAU?b7ECq2
zj(-t;^t^}dOpB{cxasf<sbUbpo}T@LQ(2_qtqu7JhZ#ym%_zIt=J|F1HO`AIIbC;y
zcpN!^+uo0QoFN_IDfQDeVd;vjpT-FbPV{3r|LdA%wnx*aXYw>|R(_Zv^IqrEjfyEV
zt)8J_ZR;~AFTDOIC)jQ4)2*U{XJ_-*lK(gfWu8@MdAGfe<7{6Wx{%t$Iln)vFnt1B
zZ_H*QXBwAC`bQfgH-8MC^Jw0ja6r`t2A;nQ8zmjwe>nl7$CSofosCQA#WSXIQCDIH
z^W!bBc9I=fq*R~nd13Y3GEw%MsCx@@%EWdXPIRvo#tO^lLR1jT$gX@5>U_Gv+-t?V
z-2C{eeJ%cU68{N@3ZO9uZwWO2=&&$CU9CI+6DqYWXB0#E0qx~pQ3jK=_X<pYN#p4Y
zt~;5W`^R78!nZaIQBSA058}EO@EH@`CTmzKr9%a}PmB1aa(adWh*$2{X2(;k{%N#V
zenC-+OJdJ+;|5mC_^(HJ#VKo}V#SHcYeN3-W0N4hKi*smJ<Rmq^lEV@w2ePR8NtKq
z4f1@)_4pS{sKc$zbZdjjNR;rE1q$hoYcN%tC-8@!!(`ogvTDvX3v8@c0$>7V<L?K6
z5`h<!wzuwUmh&?zOPAi8{%x*0n-pllb}7bkDi+tto1s58pRUi~|AfBu1=qtn*Zz`)
z<p_Zfecju??)@hv?X~wb83G}X6X>NT`Bh-Vq@UpY<-HdCM}d5;u0B6^CHMmV^C}g#
zz-`C{g|)9Da8K^GiVu@N1XjV3Cv3sXdh!XQ?>miv5i7z1)vNf=54jrFk@%C)iYOgF
zEP^Wj!AK!YV04q<kJ5&s#1;&Nu1<8o4(P?L7r>b80ul~CvPkm(zJsF^8O$ORLD2Hc
zmygbDL_i3q1aaX48Swv!{#)+3X~N8a0>409J;3<pFS}?23<ktj>z!G(N>MFT2ALw(
zq3^<yJKi|`rv{jR=gsoVz3Eq))7F=7_<f0@TEL<4cY5Kv22l3DFN4sw|L<QgC?p~v
zKy1+3_a=aK04bkaq+$lczzi7EoDcw#fsow3XUax643(lC03v06`%VPJ#HoPWYD24h
zVER&e9rAJ-Af-J}*(|~ag`02m^Tq;o)R?EBv`5Iypi+yRto71E7Pa|&%e?E+s6%C#
zr4V3}K!HrWwV>5RvM{2<nsAQo<N%-?sd*57Ewo<+2zL%tWGe?;F}#X+8dMZM#GF<<
zrm!hlUX&x|ZSy#Y?7LujAuGrbJba)hdn5*Ilg;gIKwUJcvXQAjOqsZVz6gaaJLIKr
z!cXR3!H~2YfQ@&`CT|fA00?ckpgW2Fu&?p8AEv*yz?w!%O?e9u7c&vxoqJ3JYOa0I
zT5>}(pA2K;8i9eQ{OLf1G8q_%Vh;@w&UXO`zBx1{>>wCQLUfCyw1&RW77WZVwbwwB
zeek*&+V>sSOU4#JG)x2QrB0wZNPt@#*1JTC_S>Bs55`LJ5YH#XxdbK)u3hlQzJg(l
z7|ga$8=ysgX5e?c_b?MIprDmd#m29~P^L0m1xH4B`q&XX9tie70xOWJ7`mn|n13R3
zA!tfDp!!KztJMCw17LIyY*@%cmjEXs1vt^ypmttFW(CmZ{%D|S7S6|42Ew|}6{s<7
z)vv;h{>E!sQ5g7S0&FM_99|kByWW@*fM(%=IAt%EBBM(b7-Ky7b-AJVUy+`wa(%e~
zziG5s%5kj8lChnSHiZ_J(0=nks6;{uuz=7K%xp0<A;{RQol;Z}m!dS8D&ZV@zL0ip
zSu6#=`5!2jzyr1*AF8{6Lrf(}+`p+AL&e7k0x5UE!(~`%LH@@9@rD%q<<M})Y<2@~
zp0q-*Z!HZ<2#c<8#7?xr5TGi_-AjhdQ8xLLh+Iny_N(}S$+a!ef`t+|QjkTspP2EX
zZNtB<5Ft<kmwS^;-E{<TeJ*g}K?Zz+ec|9_*0wjn?q&d^`}^Z%1@_&!Qpwb1jd1N+
z0|eV;5C{VV4BZID1E7CbpWanxpExB~g6{St^Vo$ipytz2QVQNK1su)+m*c7=_{;I!
znc-<y6!3h7vku*7l2dA2pw_(y2{&<RL9U8h54F_%f|u4;!T@Q6BLYHWgEwIx!H4BO
ztAHF3KvEcG+?JKsfkfS7DcY_DN3#NUN@|d~Q7nV5vDU(<=|KHHseykYcs-I#vo|SG
zu^={HIxMc%`>>%feyvjVEA{(*5y5+KeCaGxS@XWH^5ppE(}_TqO#(_vWHmBo01_MD
z7IYJ}wx3=>$cIY$RbMkK3fm_3HF%HQ1As(LvF}vDf<z6HHKwp$p<en3))4?hTBiEp
z+jh^Ym$DZupUfA+-MxS1N%gZ>NBR>o0oYhmF+-nZC{oK|->a%YYv3P(dJODjEqK0c
zj*G~BF4R+rM&s{)prRx8HwX>QVtZ%7mc`Jwgir;)mt=%@G2v8$0M?c7PGJVvCTZPz
zASx(Bf0_PX?ilb^x&Xs=ilofDsT+sVor)V*^8&9hWYO>yU5!JUvU)23)~ubd7j_V8
zcSJ4>mcOz<R7gxD9|uy6_{IgqCh!<$$vrUAv;&n^=>chU%l`P?94$CRi?E+%wm8;?
zy37iA=6TeF*46%pWffas<{$a$S`vH5G)s~!LgldUMbx9#XQ7F&f{9uHxtJ49W{(RI
z))q;eyItvIetk-VkG;&S0gR0WGhIi8zd<Y=$)&Mx?MY+{+f${NaeF0)*wWf6l{7c)
zxhTbEZUL;w(5gtsb!FLdu-g5uF}%y0T<TEk>84((jK99acFUO8aBNN;y?G0o6~+|=
z4<R=1626n%xDDg2wZrfwtG!Zqlz+t8s)-WNnZZ+*=K&sfy}L*-CSjemVbF2syOO)k
z7$1Uu!oUO2!f@<e#7McS{99f@3-EO5QR^w4RbK1a_KflLlG=BfHCZn$cte<B4$=ZY
zwx@_~it|KgMM<8TP(|$u<)JqCyLjFy03y_kD|DqxZoT&+^Ui>tR8?pR7D$@V1u=ma
zio02jN0%tD*3cj@T-?~-AKlFXbG7tcsfS-)^;p7yGJO%4p$jZYHf<0ZJsuhKK0@}^
zB&=M(!;^*O8gp+f>aU)QQ8|<hAe%=yAf@+@yTJVCyt+^v=5?Atvt<MdgKKY=?C1~-
z4K=N-a@|kCkwh91twZ3rR(Q&o>J8DgRTPp4A~MWEV^tyhs2AK#DxHc@j00RTTGD5Z
zu(8Pf#eBrV7s!y`M-gcQI@1HRifhZC-_o30Q7woNIYG!a>nJ*G0LYFxXCLC>ieo$g
z5K%+>Is|ywmZ?^+bTdC1!1A3XM63Dn7%GkL{qKJP2Vj2OQ3^Ey8d8LZuUq-{^)!J@
z<~H`K;NT4EPy(ZPY?NFh0C4dz&}<*nyB1CT+7UGM#hxeDaqQ&5t^v?QR<3}(NIgXU
zS^;!(s62-5R~`ILV2*z>0A+7_*cVWb$sj(NXvl?TBWR<3ICB<NA}j10yD%kL9)%uQ
z`do>sC^R&5$7mMfqzCYty19Y}VdonfBHdR+Gd-~c(hgH>TiWeAK<#${ueQ)2nXSXp
z;9d7q5b(PE6bBXP&jT>_V+07dKs;&#HqX{f-2k@4jtq3z?m|$3xFX(Fb)8BIk*8k~
zq<RIEN3w29{Y4An(9-&vl>l5?&ucGq#VVi{0MDy19iK<MpL({y-B~&i#Diy_JNc0~
zF$9ZXr|!e^R2vUOIauAJm;EX13lb_xDe1)TK#qIF{FNQs5uWH8O0Y)G6*`8cFlHl~
z8lk(kq?Hh!S4cB?YhV=-|EH?fB6ybbNN<XEP<ZfKHq-?M9qrsl!#;s!BqJ*P3Dw()
zY7#n^TFe&o6x4Y$gHW$Xx)Uj1UO50ULHYuuIWJ@{4k~RGu)*(U=SiB(uKr-(6_5A@
zv9um^e4Z*PV~9>HdJ^yzI2i0Zzbw>V2A!Yz`df9db})p#L%=GXZ_;~j@rlPi+#6CU
zzqqLwoQo6Bw_#C|1spIx;tUFP`xguBn3ow`Ffq{;P^Ar*R)Bj`x+kC|Z)qqK5A76x
zw!4FhXb$S)u)s#Ibqo1#>f|lvcZ3XV**e4HjN;zH!n-@^h^s{-I^4`JZMDjEVMi3l
zV-3z%K>}L}<MC~r9%Oa(^*i{&{OO%mv#}Q+LwIzU?e_f`9(KdMotovVQN_I>_VlH>
zHex&y>CO+#pPs$Fmmt4q^k%f>^LsE{ko{8WT#Uy~AwTx|F#(U3H2D)^GlJF(NV!=P
zXi)`MvGCH$pz}a9#1F|Z3KUgA!X1b^PlPmIt3XyT>-J3S8mskkuH<o1!%w!Uvnuo<
zQWkg-mnj;tl?nGk28zwUxGFm!@iQXamX~nA>CMDNvJvK-{9&2uC6Wr6z!UE?*Upy|
z92(2gh(v0%u>g{L6{9e+2wT+uz-6k^1mR8ZXI8mX1fCwjW)en4*4bD$aU9Cty^URP
zSe+%Fzo?EIZ$1=?g4tn>bBA~9(p51VKz$c`U+<=VUKHA9SfJ}c4B==P3eWM7kqg2(
zK0z70S{pCdMDxb0*LtqJUbqYd!mG^IU_((ujK+S1|8d?Mi_UsvArk4RHu=Tq46+>_
z<^-P;rM`aYpUf+V9Pr?*!rkC)NE45$yTh^nkc+@Jz?Qwus5YzC`vYtSeV-B=e)Oge
zX$gC)hcA{VfV(I*-9l~5XqBH6LRUKytmG{cD5_!L>maX$c<c6r2)v7sbe^6Rg*lf!
zOQPZN%~hHtL5EpR#FF&c_1NGvCLyd@8;nqbkyXQ;H5EP?ZAzpvVNB^P+2p?F|8r7C
zK8l-=sQZJ6ebVkjD}Ru$HHkuvC0NkBRPz~v&u+^o2m$5~0MRmMR^1?KmcVH(JiZwh
z#Q!4Lm<8<zw5Eu(0*>QY-oFzKqDsSE!>ur|N=K|Pn8Dg1d1C3tGYKsgP5qIhAZx*;
zb`mrNAYHCd<)_iK^LB4kKPgmuVLInejK&*THD=tmnVeI3C+p43d=47P7d?RKUi^C=
zvx^k*A+ado*t!H^mvz>b81Fg0l2v3Cl&$(J8TNZ4*dKu^^CO;)ubdaHywC=f)DPb=
zK9nhdjB#^05%UNzE~^+d#KA4lNvd`S>&Bpql~s1+TWgpZmZ6~2q_{e+nm~$EQK*cQ
zQWSOO&O4<}Kx&{?c2_h|L@TOGx{08EH@F<iHz7<R2VAy>4g#thuX@|Dhr@6ORMP~y
zS)%;E!=T|)z~vh?gO)^Vq^mR-<oG3J@un{_=4i1naaX+2>LpMYKj?VEbi|kGD2mg)
z+APWLJlpd0PbI$i>wQLTqmS-c2gh1=o|Uz>v468E@jUKiZ9Ri0x#LR%HVtnSJK;lX
zx#qj|-{<UvKd5h9N|1-Gm3i5bDD3wMrFxtZY0P87U_ojwj?S1;Pik+X;i|%*eU!mn
zFhXdEyFvTWnM9)KgQa>?KQ$({1ZidZ3i<flgG=4miM~(x|Jn<5rd6zR3nz0;4aszk
z2)n%_cK|7mLr#1dM)pjIG1gjcP-uNnWad~1Z$2Euc#xVe9ss278JA~BTt;C)k9ziT
zo;{5E$N|}5c+_Y$l`}t&#f@d%MWfD>8iuN~E}Uz@YS7pqqBHM&rmRn#vz9^C)^q{e
zHWHKr+rFhe&m`jo=u)G`^}ZCk#98$<vBkteVSFcnMC1-^b(!6w^`*;uh}Th2oB42v
zk|Kfa?FfC7N{$9jrS6RSimPyUkLX(tgFkX<*yAY&XNIS@E-a8OkY>*Q%ovea-nXki
z2wosG6KQQ=IHw$0o3D~8TT_c7#%<tLR!+oRB&yPOm{ERqCRvs55KfF^R;o^x0Dda>
zDzK6cSvv@*-^H2SRV-^ExCy0amZ4#iD9Ua<Z%&Ak2;~VOo4&2g@<Qv1jc&drQyC%n
zzWkiL<m)$fmzk?fg>Do+#HBn-LNOZA29b9L8Yp?K7H{!!i4kJ;VNHrkSfO!m*f)*u
zrtPdP9?uQl#hA_paN_q*<LC?zD3E*!QSuh^!aK#R?++ut?NIob=f7zQyjY*;(u~<`
z+)L%O#&cKu!IYgp+rfi9bQN#N0$#6E{JKGXaI6)tc(HLg_qqO8@v+K$-)6>y{0Eqy
zald&}WtwK}a6qT)l+*a&^X0n(SKluwUCQqw*TkTu6q|Fv36J)N>4CP3NGzP7J!7ZB
zQwO;VqEUr|BEv6w7rN6v=!JwhVx=<Vj?#>@(w3|2vDq7|sp=iCdhm9&FW`SN(P<eB
z>NtSLRMn1aJ{XInS*8>#`~oJw`)5V=!MFW!l76br4zC4B^@{?ipr~3ls`r&VZqrZA
zSX~7aM`PLN^=Hgb%b%>g!D!JtBsiTSrnKE0(KbY4cuDe3d$srGAJ%(Y3!j#$C~6GT
zbWJ8wIQfpUF%YBc1=_hR#foHgbE&0Pbx0V=tmxvOOeurxzpH5B5>0Zc`5!{FSh!d=
zY7GFia7izJUVMks`=t@LzAmaIEL)gXxbut3eH%cLR3xL&T~yuGxll#;Qulmu9G)J)
z$NOtJ=dsc=sqz@iXW|@65q#*OSJ`v~Uj=Q+to+%QV-!U2FSC|Q3Un%|Vf)GrOm$uK
z^_wk)8Tb~NvO=V5%;`N?^&lA)GmFgpJpVo}$p|hyoe#4v!!NY6R4Z*C<|O>dU8C&M
zY;j~~ccv#&k;LRAI3!uWJXV~R-+gO^)QhIug@U+8pJa|eh#Td9<N1~AIxa=vue3p=
zEW&PS4T&95H#+2y`UPX0I*e7u)`dru@a8D1UbkhLRjq>>H}9GEvrJ_uS^r*{#pxkj
zATR$ot47M>@r@O;UUstYvc^|_?y-bv(~(jdi$fHM1UzBERE6qc-1ixED)YV{qF`;b
z5JMx({LNigk#ll#_qrNbf`}ujd5HJU1do-!DUU&uC~kMV=(co6y*z$!tc?*F-4%*(
zw`&r_Wb5aVyoHZLVU_MZemcJuQnN&*1XDBG3Ov-%9!A2rFs&c9UA#Am*#XxUHS%z(
zXwW>$z`sI1o)<)XRP8P9ib>Cc63D|#CvY?_elg$5%yJf7NG})vQPZnHwu&ur4_2w)
zZ;bC`BqsM+0eZg&Ql{Ij<}ngyidsvq;iiUVW?vg2U=Xo4m|hXW*ZoSwz5Ku_gO0dh
z3S5(j_N%KBgO}=HnU7G<ki_K9wn~aEyQOl3R4CT6*W(3DoI6GG_N4=D3N*(SE1ZO5
zQXJ((ltNYkwjbG*><0G4#;x&Ft>+^;nJH1P-LByAU}uJ8SP`J#zDX>toL72H-9d7Z
zpzs(4AAF~9_tT|jGe@HmE9J*Qo1IQ=tAiAoYcKw(6g>7;ji;>LxkcU3y&hk$6H3~j
zw$uPnF|?jE{{&lKHwL51E%v$fvjA{$Xf3FtSkZkZ(e*G#B!4-WQb<C&g9LT4zLveE
zx9&0bKK@?A>E47%f2<wv>4!aS_N}KN61@Ksg+nm7()s0;g4}DCi%y-{&8|v-Ok`o=
zt>#4M69(8M9meR=O6*mn`?J+fyqBQ`ah1DFS@obSRe?Dy+;kb|wnw)vWMkD0$Zf~<
z7wS;aRSg~kD)-~e1ImxQ4uLY#qK8+J#?GJE*p%1U!)pj5bB1>PCxUtLSgXvY^9n&F
z8g)_Nm|6gvN9{o5d?7)xWeQgeC9=Ttu76&Mx*5m6lSd~_x7a0bAZb^X#qf6N+NgzJ
z-=B&^Njyl4z5w&%&l-EYf+c$*Dw%@z7uqxYVJ$Vsj*diTjI@h-F^M~QTo<i3tB!#n
zho(IZT*X57u}Jnrj4?FA5g2-BF3W^?0zVn7xIV!7BGFiH6+Q$&jwh`KsjPnFG>wUw
zw;KZkrli=9cOjmQ1_)~ticag-;M2Mzjvl9fNtVpU*D~j*HCWkOXtZPRRcBoA0G!yQ
zFPNxyPrxb8(AJB?l)vx?PU^=pGMaW8gtr_Tc1A0G*!=mHSACo=-;>Jkqkt~BX4(;R
z5meDfytTrYn4KMMLgB~EJ??*gQ#(IO<@;P5ow&qG6OPH6l!LR7*_`?}Vlm3eU4<<i
zp8K!6r0wfl1$6H@#$uc2cj6Ea24c`qlE3+oU>s-QV0j~T-pU8qyc|1MM*^=^Nr$+`
z_F}VJHh-0<qKz2vO*wrikK5FaX-j8O<r3295hG@Xue5^YY(2>~yn)DP?8azp8lx64
zY+X&?lDQPdh(6hj+tf+bKO~|sz@h}K8TLaA76T=S6Y0)<<Up+B8w3`}#T5|cWb1Q8
zQ4!O?ez8C-_h3@%w)Iu3UTVV#M428FK&{vsA5gOeNXZEO6$l&1VxUxH0S;gQo&sP}
zs{<@%A;kLmj3pSDGj*_Z*$q5~0^U`^wiHB&l?JPEHIP|5BC|yX$1r~BP{dUq109qA
zfW2vmXc+MnyAO0D#G?b2gtJ4xmIg3c4{W7<v4SeJCbn^WUb;#W=jm7srniWMY^6%j
zARp)4=IaO8kK6_CYX_s`eiQ-!Y7m%_2?D&B1h{jxTm&i@0GV!}<JkdW_@wAos<k5G
zUyR_ta_=a?xD>SuP#PlnLO5r-*>dBD-e8qf0Mrg&#^8Znz|CY>wqbM)JON}S1)?!H
zi8W}Uo=B1c^CP8^Cg6-uUHQ~T&A&RWe>qI-F?2T7a`BF|a`D;f(<+BpWtM}*J!8OD
zwx2X>@E^A`w@tP_1`I6W(|`um^k>T*rIydey=AromqoZpM%>hFm2HecxcZ_8)_{E-
zE5Az?G)~2lxE3xN<?1jnuX2e)yW1cT)t9Q?C7rzu&*ar~1oO?acjVr>z^I2%5`;3N
z4kph54mKZYbq&t+{KS+hKVJ>v(XT8K`KuuA@&pA)J4jJC^%Jav4xvnx<ylvv6FO>U
z<Dj4>7-5bE&E!W<5N&SjPgKK_f;6RkJRt*>_BdhonDi@7lW#I_S3L`Y%cO5;cB??U
zAk!S->A>#jZh+xmBtW1tT?edXZFgmk&>5^_dSA#4SFb`ecnW|SLV__Hc?h%)`vs$N
zny5NY=yaGAp$+}GSqmQM>FA`P&wzu}U!4FBJ?!}^?^yt_$h}Mdu}ynS7h(^U83U}s
zPomE_G)bWl-3kZ%vkS%}$UYKe_K*C@Jqxg)IuW=8KdL??$gUPAVLpP5Nr)6PtEblE
zdp=z(Jk&|BVp$#8`~ktj>JHW+<6b(bosyyAy#=hDS2>4(oDDlR15VikFtd3)TggxO
zkP@=JP5`g;2S^%tCx-8~k|}l~<BnsEKQ2$!c=j9~z+-6#eM>S-P4ou>z=2S5`xxjG
zH~;>F@0TKNg@`V?6RYy49$+!W`>+~;>;qHWAzZp2rCZRTA8NjQ%vZqyis-p!YQY^^
z6>wVnix#fWR)+CyfV9v6tiBl+UEU90?-S5jeq#HK$&YBD`KiQ?GHc8`0gauU*4u`D
z=Nz_|Ofn;OGu|{a?dYo{&^fS>^?FB+)An5%B5s6kX?0xPAoR=_1}3DE_DS`2&fnlF
zI|MiaO)#$_jQNUpA$UX!^;r5WQm3!6i}#v$U;(7Tk6S*2tY&!b%i+K%E}Y-Urm!#i
zb5;Cu{t{0bs>5D)#7e-dYEUK?aa1|bWJ_@IKLP|w_Lt@PxlF*3N4lq|&MCm*^IMtm
z0)qapQE@=<7!_Jc0KBsjnO3AP0<w|8jH+5u1Q*Sj@9uDAIvVMJP2vn*geNP%$aq=U
z!$^#nV+t*b0*m$2A|h|@ad&Mp0jT`c7jBzLnw2)Qs4595)!?i+dx?DA2u!Q|x3(z|
z>Fmc+Cv689zq}rvc&RM)Y-qk|%r`fNQZjWMxJA<sXCDAcSyKd#Yu$E-AQ9Yc`w3>(
zp1@em4#J4JxN3Sm`Z_?eOo%00wp=EGvdd;Op?H*ab^Xa?lLB2c-ie}-u)h^|8N{~E
zQmElc$SKvSx@$@;!L_w);^sJPH%FJ=ALb5VY`*Q@8xjEXS6G%r8fu(va3jJKF@rvK
z7Jtd>1m}8@C0ee<^&Z?5bNj6JyW3Dd?zUiXW0$Iw%$#L50K3{eV&Q`9s+1^msiGuJ
zz}zoG6@So}<YkAU2z0-E0yBfNMP6kaNapj5IPYBs?~&q@ziPqrhB{he!%m)0<r@+6
zKoUo!PO;$5KCF{T-1dW1d)KF}PzRr04d>mPxgYee1$bfvdfz{uR);Ru6DAGB0z0E)
zK+3_T5{ZBiuy~@_6y12LM$$8+*FmZ*=twq>uht*}&<7esU`u6=uoS$;5>`dMiI>4~
z7>ezPGhP)gGOhu!Gd*i7iRDD5zy+L|D1S^Eg27w;woaLJY6*-o7ay48F!x>si;Mw(
zoG!qTU-fJ#T79l~XnOY!2^Q`F{l0U<A-DK_K3&KbUhy=H=m_-AY+2yz=S?*6&Qsr~
z>uVL9vV1<-MziUR4sS|92!jD`yNq!CPI91;X%A`3yihF$UN*0kh)erhNG<)zn!`;a
z^lC(8BOj#7cw*iFfVDh!3<<|P4UE(xO+HQlJ2^d9nA9W5Qy&(}r|-I|j}3pexOFE&
z%*qQB7m9(7xAkhceQ5?;;n5m!Fyc&Yze6gz-Pl2pO<h)B!Z>dEi1s|=8Zd@rPOuGL
zSp`M9+KOTG=w{3^rXa?rFCohPS_h?SS39eM-6750RH||)m>srcn%RWSP1U?I7u5Pi
z_eEz4KvmPImp*zM#tEoU;Bo%ghputxA?!QoTRY+wiFH)tmuN)0>H4asW*|($Qd}-k
z=`LlTkPucHF?=wI2CL6v?3;+KA(`9GXvynv)1GSGN3=KU5DjPm<G7UC^cR>n;+iCV
z4lNVtO^zzWNENKAb&F~6_?fnV^A>!x^0X-jpA#)y9FNMN=w+OJwg?TQix26$FY{_7
zhOW_ayGhE2cR*U@(F+USn}=YmvUd2bA84>^H|bGUFKYRdn$H-<!@ZH6?Izi=qZ0D9
z<QU~De@UlR-XD$#64@fWvC$fKx&$%xg8;<>k?~Xp2^CE>y~MrQUb!~kPDb?A5nTpb
z@W_lOS>;Nu!jD|5>9JC48oh<fk;DTN>(84JO@)=cj(NZ$@e=ZzkLK~93oY3@6%fj>
z_P05AtPhT(>nc@13vgXQioe3<+qeC#_E*OtVL?i%=^d7s%g%jFfho=yJl{mcMey^;
zHP1k7gdad_G<T2MBS?0`tm*ZbMb*Gr>!5oj)+}gC3m|vTnlPnZocA=KTUkA@iE({0
zt^WLyw)+OHHfND;FpaUT+9P14x^}gdP4}u}I7AR)*?JQ<^UF%y*0@wuuhwBpojW;H
zBUo4ABZxCx2+E?O`sPCUlqeB8s7#F6#EB@mSgq_L<5YF=L#LfPx2`Po?M$~2C_3?S
zRjTk+*KbO7IKdhFU^xm#H$TQcIHadd+rV5U&P)zH{R5*oVUc!SZMvlmk5&qqtM)#Z
z8YqQTT1=+*9wjV<!H`xKv6W$3z}-uyjeTP#f_TnOk?!?5*KI~v<SOZtD4Q^Xb2pBc
zAVt(g2H1eaYr=NQA|E@cd<P>Gd)d|MMzD)ZY)2Uo;CyHATOEQl;)6_OtpL4JHKxL>
zEBhXzp&wN|-AU=WihqrYSHH<8c=abvLMP#3QKxR3ceC;mMBO61qM*~=^!|z{)*^xt
zlj6VG-(oahNSzvkO^+%$VPR%|3(h;&%Tz467(dOQWAWIJP%71B%M-=nlb>iNvY-g*
z!leId3CF-O0ttQ5v5{N^r584jF>QHgBEefZv<Z9I7K1>!J(G=Dz69j!x+7XK*Fy3Q
zlH$i%7g<*C4yjE)Q+BZ5Z6jzPh-bqOA8?D~xD^^zSP0qeYJyba>66WbfIn+<=}cJ0
z7=lniPGsa9E)gG1&Gc23dM&!6P!|g$Kf2{dDS;oII>D`7tFlJXj#c0_Qd0o_>G9qA
zF6`Fou<89$-WGL{AGwHMa_OXA<D>D!NdK5p?s`&xzcAAi*YKeMcUZERxO`PLn|C;+
zG(Th0GvlYa3;K>dPEdv&WtTj3$mB|r{iak7rJe7`MIp+LohPOJ5sxz|OM9ou8C}>T
zSkojE!zuaWd~Bt3VQbc1XO$pf#|0Q6599U$tg}aZjk_#fYuJ&2$MEM7Y2K#`c4cEU
zCi`I-_lcE7SH2SA+7Gl}5iJcx{6@_qa%sCqDZZ+V5T`+%bxm(_Ro*^o5?TJ^$!IM8
zUOz3o^l`MJ$aWUNw;MSM<}8|r?_{`3(wBk6ag(JrT%;B@jXr*GLXvSvfoXbj&YBxB
zN=6o1*ID>A?j@B0;*eY_2UEher%^<;w3@U%of{prAME2_)?oI4f?%<X$t+G4m&5n5
zO^&nJ;B^r%@G?GG(9cKKe;pE+T`1%+l8*X-`*wrPNfA@r@MYr2!|-H=7ds0WR0Wp2
z;;I@n+GH@|E8uaE&MUiOg8QOru4znH^9&R#J_6<(Td#x6U=Zd}XWVmfZIGW-8D|n1
zLHG+{-R9Cx#TWO(9k(3euiSgv=&gX|gdbPEQm<xv_r@b;ztvKaAQ^jm{oZ^BR`K4c
zuS70uUnK87dO4oX;Xb-!^nMz=3vv@UZl!nb^c+EjzT3tq9z0#;%F$~{OyB>K=7p!3
zbx<4;=5pmdp^|Z)%1!$bSsdC8+IYcy!h$;QVzsK};Az*+cTav0N56S2GHyAxPoGiB
z7-H;IuU=H)H1$L7(j%!%d;=R~|J&i?OrgnV;o+3b{`VHNd2cjr%*E0%6d9_!ZaqFz
zU)Cf~qNBW?!09zE!OJ3!*JYHzE7q4>6d*lFE+_YTG)dAb*qFMM7%%q`@P)i&HAHoo
z#TZ-`FJ;E!3y{xoq9?S7d#l{jHy?xt2+^~0wDw4>br4)i%OlHY>VDMM@c9cZ<A6FY
zme3tm=#06dN{ZE8x^3-^ouObOergOuZVQq>GH)6UCs0<x)eXO#)V?hmxK_V}(N{aP
zg#YB{lpQKBD5I9yN{u4iHEO}s>_luq^6$ms14|LExDhSt#M`kb2iu@=aW|;O-=f>4
z14R~BJLeZ2U#dYQPfD2mA*f&l)1Yr<buhxJVZ;<ot({!~+_=j29V<UkPg23G;Er;O
zyG!WZNd98!&W=^x5l4FVre?k}+`8|gkC|QVdn54dER1Mwg)`i%iL>LaE>#gXWlUvv
z#}${;*zFeKa;%C9=0Ewl=k+tg*a5h3<UecdBV<##=%uY&#T;I`t{M&v5H%C}84D*d
zDJ+Oq^ma)(@rJaIwY2lu7Fihs&S#b#Y5cQ<5lt0rp&=cpgn==!EfKL<<rzxhx31^a
zw<KCkvN!b8H<-eQNS=(stX;a*8y#+8HrP_C<ZW!6Jv$%rT{D)5@J_}_hxxjG%G|v*
zy~s!Gqs5j>EGbdIF^`FYzR%mASQ!V0Qa|wC^+U~K_FE5v`QPzsHtkn^d>~fma=S-h
z8&_eYPrz$WV^(cW`L8FtZQX>6(Vb&reO0a>!#!cKA=S@EqI6-kp4VSvYcl{Hs_04U
zW&lz^QeuS&A3rr^_j=N3a5Yx+L8O@3PQExv0!8Z9o()!+=h}*mEIy~z7DcZ>1Ob!o
zOWz$eC}!xtQHC!f6WgCFgO1bmI7+pctH&bNQIZT7G6g#^Dp|-frrm#*d0tmk_d;W5
zJbv7_#CH`)7VYDar1G`wgncU%%PI-QU`rtb`0Y1h3pOQx5Ns4zgb|~Gv;AF^Sg6hC
z`S^`gqmoZaQFWocg0JpG?kazQtqA(V+zZ;2-S#e$#4O#?O^8{4xpCF^NL$iG`MxoH
zZ({jG-C_F|QO3iK(RCqZm&^#-mH)2I)|CFPGH@y7LvS>;OAEC{W@e_=r@)pyD8U{y
zwfJ&f0a)b=4Y9ma#+v%H$mxtrvU9j-OhDd;5IJrQkrZ}sSs!eno8Fh{q@+@}ZCHN3
z+muiGGnTls#tm;V+IzD1hhy$vb*J8}h12e@bJ)2nUGV~xle9Fb=<Z1cqp-Y;=kYx<
zyQtZp8;6&v9XDJOkIxqt@{OQKaz^Sp3(@i(R@HXO)X!E-sjWttWpoaIVLtnWq7$o3
z<aQ!Wgk$!@46mFokL)H0=sfmhSCpH<?lZ4%Cz>6b<Vn(yjeKc~w@TtA)D+<&VfIm%
zai%CBChPhMFu^X=w3W-p!_y&y!IFZgeW~927DsdZuO{Lo<QXc(bU3bk?H9cC=k4f+
z*T+gZJ}vNesr%T03haGc1g{tk-QZm!nub;5n5s8cS*88R*h-ZNxw#q2L)|++RS0CW
z7y1O^)TWzC`9fdY-*GiNY2Pf`#oB;=c~^9mgM(;7NfswnGk+JayTA4MK}ZyPJe+E%
z3S&0r;>!f}^gDtb1zxxqm!rrxTHIYRti$=MI$tTzkogZTU{pg%FO*4qfB3a0ZtWoF
zIdF?yCf<hevg^OIQ!G^pz9h~%UR?4FcfXUjDWpUew30)m2~9ZK4pI5oLRdyU^)3l+
zrC?s<?dX!=h@~eVr*Qa{(mc{GmMV*euCTnDO(~XGB+eA4%taZqT-1~eTL8w+LTKy}
z0yUQ;Yj8YzMi-$FjsG{Y?y@GK!wrT*-t7kxn8K-E&$D5_$R$tQ*CMz0(yRr1=O6yX
zPN6Og6+ov$)yEhzZ?nHXv|wV8UV%CITRi-|@irIz7}%VmX7r~m?#^k`X9>m<c8rK6
z6S7d(rr<)x{u;Fg+t9ziwGpC7mHE8_8k=@rt8P%EMs{8)E6T<N439km-sOp^!Fxn?
zYA)uSv>1vJQcLGbL8W@mS%|nRr+3VBGOqx+C*B8#mA0^8xuG+7IugI+i%v~%5rEP{
z;==4<xIIPUj}cx<Ic?E^Dl4rW*fpE*^yRhj=dWP{1LkW6w7A=T?*~PW`@yAk+!c5o
zODNtC?QS~?68hD_M3u{i4w2K*Kz@tf8BkGcKoXVD8h|LD$ozK#o0YlkPgImJcy4@S
z{lu7RbBBRH)yKMecedr3LD=g9dj@GXj+o1FdZ}c&n*v9)d6{LmA^2zU+%dunG53>+
z{}4&6?N(TxGDlca%^t@Pioe|2mTgXD3_%wMpVlFx%K>mgp@fANOd%@PZCG+!boCn;
z2Z<+4w7w!(rbd-r8sr_f70h7JW|BD;RHyO#c7<EF=_}EgB1&$d<ql$YCF;N;w3<Hk
zG?8tAp<Fs2Cjh{LRVhs&k!DPVbdHZ>U^6-S#krrpuw|^gLS9LK1u)Z3o|_rpO^K=o
z9elm=lQB_V(D3_;()LiOm0Rv`<!2yuiw}umz01~PGFRIMBfWzmcOstq_s*gvTm&>N
zIUK^A1zLM`v$gpst~Ftn)~|+iGT?VSGhPEM?c(K^7~|$6VjaLEmeo7yOPvGDm5r(Z
zTMky<kTBEo>nDn=DVQOW?&08WQuqbkbIXS=iMs5AzDn#dfUyzul^HJ0gymr-Xu)pJ
z*6t|v*EHH~MVVswYF1(wQ<ZJbA9g4nb0k$3jvLR3($JB&sl0Tl1;Xj_0`KC776k^n
zCwt%a)v^KO6Q2xx{|Mj4n5R~h(l2+CqWQLehv|NoG;D+NuX2wtw+(*zG_qD#W2bUK
zRM23u2|l#?HH3bma57{xZlZ#1WUqGt@5QG%&e-eU`L43wi*c0#1cBt*BKY@{1rG7j
ziBD%bs$=85HNxW}L@+^nF4kj=^7+g#6InSj6tkVwh;eq}_wX=VGuMi9J#wG!4Q+6g
zu#gs^j6!x}{rO6BTu_Y2pxdrKY6IAVvgHq4*_v&?<ewWD@fda1HD|Q1+K%L2@D-Z-
zV36E#Q<RV>^f2R;G6Z84CHknIZ~Y1l-K1n$W&c>znhD#R*wZZll@21=iZkdGicasj
zT2phyW^*q$sq?RlNl<<^avr1E|M9uU$CZSJzwn_V(4E26NfW?TMqsFqpzL<^ZE>Xy
zCYzB9fqz7onIf(?xXgh04t84C2uR^k&h^D>QqkGpF_3tpxzT-<|6&=jets~v+0LSv
zeogRFt~1SuW>;ueO>@n?mN+F$1CQqDi+kzPrDb>d{Gk-Tdg*v~Wyvfem%2k*jEo{m
zNrWg<LVCQl1{lVll(52#zUquAj(~u_pz>0;z3XOEjh-jk3<!~{urQ&2k+u=P>RBu)
zAmxvIn7do0<N5M?+nBjUfDtStSgJl=SsNHJ=9TY1f)G%4536`1dW{%Ot+u!wSZR(O
zDi&E|ED?(r{N~U6J3B3ch5W|X7|<cuzP+^4v+Cod^wAeHDH&1+pV@C(D{l~rd$CdC
z;^psc(TKn0?O^I=T1}J>Mw9D`^v3B9$nU@CsgW*GFSoP(_^H@(hHD|>qEy`NorF^R
z<M2g*|4q8XZ*Bmn?kCWvoTKXJBha83-19{b*B6?;f#&nD-5>(GNTAG&o@1{%aNLa7
zph|;aCGE#xEl|sEOdMO?xdAZviYP|+kgIDi&c{JAzB&y0Bq`uM(Oqt3$oYOCHvr1F
z1(<;dt-#Pr;8Xh~7|Ptwy@X;iwgq3kK}WX~`FI9jSSf$<>wacr&XL}q%4U@g@pK8*
zu=NE0Uo>nCVMMG)n3eMHzK~?K3&)^=>)t+M;v1apvWHtyg|))B5zgK14I~+Rp`IkR
zFl<Y&5aN~F7TR^>O2CIrdI^xA5T)y^?I}!PoN~f$(%QO@>)0o%-wRK<Y|GBN($18c
zoEa#N>+5PwXYaYQ6BzA(f#<YyL&ct0jF_X<%(mnPekg-|TPqGpHuohqLNX!V+<mrC
zljVS@ShM91_seWZ7-?8*FBL?M1m@raIWV1CtiDv<E1=fJ8k4J0jj9o;I4B~<GdAWD
zbZPa-)s$Gn3|+cjL@j*9E$1;IV@(028qXiE3!5w=f|;+4j8h>3_K+}0qs#leswFDt
zBm$a`LS-RZjgHm<Qtv(vW1bxuUNVj{mDemC^x8x~1`y|eR$O#F=?R>*tJoiw!ya4l
zht|^u?Lia!yaR5#N+v0@>R=yXra69wD~pan$Y$6$m1s3)S+$EY)<c3qx(}U`9kh-R
zBT_AhXy{6qa0d0`BYGKcV5t~{=)xX6vEv2cf7Yz#h;|evx<)O+FB%~-#jk=DQGZsp
z>JEbc#3)@3Q0|M->={#xXfAMA_~(;jU$9+fwW3Jkd&%c2UOvdiig1O|P=@Y&C8QJP
zm25*v)0H8Zx2H@u>0lK@2!3jBMkcju!H9w}7Pq;QQj@tet@w2rUmxRgy1|_^Iy~FR
zn=0;D$i~vF&%-<Zs;#yur{UjMiUz%zk2PONWGMz&Fnr{==3sy4{ay;@iLjN-GoIS8
zY)|}LW4$VXmIlgPW0JurtvXBVQ=CD$o<y^u?Pu@#zTQ|~gL81^kiWsGLUrl=sM0K9
z`6qhtS{yEorh6coeO-hGP5U#RuP}2Cm=D7XINOpGT#g6|_G<QVKeG}mVeI$P@M)n(
z0G)hByIiyfHVv2jxJnM^<V)S=7a5rXjD9&J@VMG{l!MBqEbR+xY$UH-r$+NDeEgDp
znyjoYIW=d&w=n3R6b19;zIZ{isuCSl7u{!8jrW2_mA9Q!2dnstPXS-u_1VK<NU9X+
zC@kk-C!)y|piQqrd#iH`XnO&o_@+lRzR!KAmw|>V@d7GR*L+8TeM>T~3)$Toc2<R9
zwO7E)g;vMECFHO!6M4$JSKlf09?yhg5LxKDTMaY9&we=FQM}gMH0=4;yg_en3lpo4
zFEz=|&N}%KL+XRW!!8)&s>nZr&saYI8_9aM;QzZp_VEhfTQTQpIW6D`BXoEefbl|g
zJmR^EsKc|+qg}x61siXTj(Db?M*8p`5Qad0=U`)F6LbHjTa12KY*Eh%5}1!5<CpPR
zPNWhr(pLb34#beMZtsi3MMg$|p!(c=vLK!O*n@Rl^glc;0uSwEK-Kg|k;&5_$z<S?
zE5jM%1_Sinqe=tN(;}m!7c;`fWojUL;sX>Y1(ua|LRJ$7@@P85!X9YbJ+r{GN*c}6
zF$>b$uK@O>z_plbsb&Np5{-C9KE!K5z_P&%>>oQDNe_wlQUKscq_OZ;RyaFAF+E52
z(ZZ9e1Lh-H3-7_6B3aJIEq#ewD_QN?m4}xBF-rvwX06;Ma&lJpZ@oiHnJCOcJv9O|
zN6l%_S#OGz2RMzDG*>$UGwa#yFlI~sJB2RK*Fu-%Hrptl9on&OH<_KbQ(N;F#un0h
zjT5L*gxF8N{xqb7vK7~1N~`7HZuv^&&A6B}BK8F#mTm#@w7PKpeuM$L?9SH~qvkmG
zX_W-_oiVXQ9|wC}^>LxHs&X(2p8S)&hayFab>))&#R%rukyZ6=Nio+o;{>&aK^TZE
z6;_TI(_^A2QN@5eJLMb$@KY@)D5W1^0WNQ70GqSylGRdOL?PCxiFWkvMVG0kaz1OY
ze9b4Q?XW8TG1E=Vp`=$p^E(N1dAd;k+!{=QWonrYAIr?KC<fN`KX?u<PfJzm&UC$H
z_ad{+@B_#7-jfH5EFgHXP{K<O#(>qRmQc#Tomkc286~R+Fi$eU`bK)hp1=Ph1b2@%
ztZLb6Z7rN`oxD)}zHr5T!7lYCnt<h1N+}3xPlH5asCJgy+QgQpB!kXQ^iw>o^2x=o
zoF6W+B+v{aYmd?wfdw*nQ&XZrGjU{iwHB=Ik?^G^id!CFa@R`iRv4;6b7x-U$!bx#
zkj)ntf%PvR-Y$TrD*Y$1QyG_nOFSN(f6T60QJEt>Pr7KV0QSyH)x;*-Mym>8{@&TB
z()f<OW%X@X&wF2(zAzSpK07iFC%@AhCQqJ>Ff9L+DHB_I8)Wm9neUdP?~%aZ{XvKL
zUJg8W?wPk~nk83blg97ST)a46_5XBt=KoZuaT_noi7Yu1=P0rzm7VG&#5kx-g%+K{
zu}4Wt3@RbVSUb$fQg+oe6UwnfMP$vcnaENTG89@QO_qAD+dR)d@%XV`uk+%2?(cnn
z?$77C-dDin)t4*HDGhccPoTK-{wedj%Z+vvxQfY$7=qq`R5h;i;~Ve-cAbVLq0-Vq
z<J%5I$rW;y{nDc(x8lwerDowAuzgJwNPe~M2IpD}pTmK0As@Za_Dv;f$~b|nZ?PIX
z6X<sSnAaTP+x7YcE%s)K$U2v99xcvU|67AA+9YQ+EnUz3R6OFWOL5yg6w!7q?L*YS
zSLDZ@H5{yaX?#Ls_oE51N}G+5JWc*N2e*OTx`C@jQ489-RlvU8>gTm*TjHkhK25z(
zW!EnZydQt)X@EU4khX9#qh^Lg?~PzA?DwD&UdxIXJyl2^nY|bqE8cWSCATh~00Cl3
zAfrFteGm^xjtF;L;jwbu<HfyXo7D7t(5-cPx_VbH5D4ib5@UacN$S~CEj}zY)q)Oz
zorfNpm%@@8u{8D|;f-HzL5&$1EJ}A^uxf|NsM2rS?hfLA>x~2O@hlj)QCLPv5d9zD
zpw4H5*<5E)M4B;XHE+xAP@zhGdFJ^~ea9T<F*7f9lVoj8)mag?Y`nDsXN9Y8a&Cd8
zT(ft<jTfoWUG}u%_U`kjaJY@4s+&annH0^LQlUR`3i$LSqnlzD|FR@(L=hX0);+lx
zxa=CE+&oCRaQcXqteD|iyW?&8Bj`~Kv7^rO4I_6lI7gRXVyD=O@cV~}am{C~r8F(v
z{_rxokl`C8wxg3t_20%mU9K$-7nKG4iq^37DKq!fsP{0M%S+b38fpi*$>vYpFZU-l
z*^wr%YugKs?ynB9wr4h#n0+|gYQlUi_WgP0K`=9hvhXl>!!Yq0^L;`GYylB-q&kdW
z7a+(A7&22k>PrSwGv{H~(#5^bnmdPc0)l>3%vA1^eH`OqnfM*T>!fRHYMx>?$f`JV
z<GNMKUdjr2b!g2~P)Cf@#5?pl43*JjPe$*v3A7b6qf9NfF$_i-Sfb{QA3$izeX~9%
z!UyYvP&c+c0<+@*P%b+gpTjsY0{J-)^J0?yZVWcAXv!$uyDV@vl`;5CSz-LINs6GL
zAi*h^RUQIt#2piG0;wP;4DmA}SK!$1IL1o8rzbHu5fNh-fNC)_N(L1J7Ucw@`QmED
zp-UQM=%JuA6}dK-?N|Wxk4o;cEL`=H;IUjh331*f8WhzE_qcM6Zo(_jH3^d(nL|3l
zQldeur4Y<A16N})C7|m<ggGM!wT?;tvMc&e97jlN(<i5H<=t2B-``nU2z|zGVj~;_
zJ9Y1qtR0V9{3HykbLL^2na&OWT!aykeZc#d1vR<?;>05)vp&k@PXd0%%an++!XCqb
zRU6fkbzChfu!|6oGXzP6Em{uuRfvBW`FjzKqD-j`t;Fgp!|44X*#!N9MYu2J_k5h&
z*>-4&DXp636L<&@WNyEOD!<KvS9NRC>`4XqN{Z*M$*!8<wL>O+^9y7-F$X$DBn*91
zoXw=J6dlDe{2~iOw*8kJQL$e^KXMo52Kw0?e~CICrBVT!K-t#E-vXgM%8@?`FwpDf
zD^`nh>;d=l)OvmUP?JOIm-XON9-6}7i8{RzV@16&K>%r<E@*zUjEYiH*0${+?qSyQ
z8DMCd0F5qHZy-KK#|(0<4ml;sN&LKOmC#iP?)R`$)Ogk|*hY^M(CdFQYXTB73Y&UX
zUI5w?Id+4UrvwF-Bybq0X<jtK^meqxD{;YHewhIOfX*=8H0<V{YxfN!vt`2Bz*t{T
zHdoqdA=U5OB_cyjh>jA~6!75Z<149?roW<n!a5WAY*?~WK`BN(*+7!I&Q{1rkn-)P
zg*@m42usDG8-AbPksMDEfmZ!DQ^DzvKWM2;zo>p@H@(XM1jd$wER*kfFhm``GazX`
zTE2kQq<@zaazscT+ADK1_hdyQ^8O#u;CiRHTtg}=j)Z_hC-ZaPJJ4PHy<vn+xTrt1
z&8^JkVeUohERCfBy&8PGxojM2R*iRY{cX^hl^gnc2%OI=KxMw6HGW?@(-J`IX_8lt
z+0<zz?kazQT7bavJL?k4Q%#w#_dAwWuUE=th!j6@e)}Ho^1y|3gd_HUB*^DS1R&M^
z_6op1jf>-5NX{nz#qQxxQ5~Np(j<3uHO>HTUR^Pdjp7Uta=la<ZH$4qzkMOby92d{
z2Vsg>LvY1C9poj=!^?RYf7AAq%GtNK4aD&kjuRW8-!>0ExaiA_XK>KI;ejY^fR{Y4
zxVwP;=w*cu;32~h(w&8Wv=1ekNY+9eGxQ_iQ;MTM#y#)AwC(9>$ni$CgyuSl@nZPh
z%r&^9|7z4Oet{~{zZZs{voqG}TZ<W2i}p&b6@b|f@8d9WTeh1RxHn5R;;nU^I|(fz
zkxtkcZiT+e=nW9OnLQmf2L@3s`i6Xmck|5_)qR=yrqMWBJbgvN`1~G6hSp%@>wjV3
zSZk_H3ZkX{?n3=*3DVBz>*6h7Nli#fDDxiEYRhY$RNWhPgZ<c`j8vVYJk(^{$d|FS
z4<<Cv&}_Wr?K-jjejP@m_7{mZrxhjkB_T4F0+;GZh3I-`X4O+%!$ui(-*`|ZT*d)B
z_JzoZC=T)D<~fCCE2mGqn^1@Ke3Ky@8?7qC1zuL*1Y%c*VV^|hgqR1hE%(+d#f(}@
zhSIAi#O~>cNH&YVsDK%-Mbyco&o@a=TFu(z9DNT4s9D?)i_}W0yZ%k)GIw{iI~#0r
zBS;w5TvPT#Q9Z60U6)w}26>9^Zlz7rzCj=BWk{q7&!v8ON~3nBVLa<D_o%msp1O-S
zb~p!sa<WGpi6D}Fap9S}^aC77Cx*`@U06V0Vz%$!9j4!vr}<r1(5F_#6+rc3vAUTY
z0l3L3Kt<N`(E$$BjOYB^{`GrPu`X|&O#5b;TE28{7S-@uquoyt5_-MZ*rlusjrC6}
zkUj94Lc(R&E%A(sV~uO`)AoiF1t=*x{>o?Ve^j<CM|=BW{L^c^nw{^d<%GlZ=_3Xx
z$DR1ryLzY=k#aoXCCsZSzc=24Hy<9w&PnI82Eb$Mo_Fl|*n=~ZAZmlBjNv<Vh`fW!
zcN13p$y@Sp_Dse8b=z)V)%=u|n6D`=KO}AJ=^dRdS;22N$Q2*HoM|bPpQD8o99kAd
zmNWc)1j<3%hk>VoL^}}oZ6fJIT4wa~Q$#wg$<1NgVZ*!*-Awxh?Id-U?Ux&4g2^br
z@AcQK2g0YA1cQIY<S5EtW{%D<ay*t+Klz5fR(da=kc*;kDP#|C01v+Pxu|fnABB!^
zG=<nDbb-_jr#iDuWv5B@5vA*ck;m%d$Fo8K&cSEAFPUmhNr&HVvNlZ~#4^m#({V{Q
zXq_qrp~Bi#I)Av^%~SCb#grZApl+5d<{^3xILyt(B5kz=655^v<wYf)UE!u$G14B=
z7C-5QDphk-Kd0&o)Yy%O%;OiCf~+%mzz5CU>yX5f3|y-D5`F-YKS~wO=EaSZLl>ur
zXXle6@1mxdZq?atr{O=$X>O2Mqn#l433*6f6g!BDM@Y~s<cn6Q2|lZc)I_7_@wO~V
zNu<&|(Tj7s1aix^w}e|h|DkrpY#=<m`exJ{QK(RQvTyshhWigFy*dIML@%7%XD9m(
zz6=_b%c!8bt{UM&lKw@AZ)LrT-kg$0mH)E2BlA0)0=DxHOWk-d!$Sh8Qj9D)5$g3w
zWpszVgN}Pq$VuK3TcqI;+@9l6HAVjP1J7>Rn89AFm1f}o2Zg^iX|SoR=!+f6m8Pul
z!M<uAIhnilY3NdZ70gz2W{Yhfhp9gXF{~MG*7Oz}4;thy?p;H=-zm!bsdN?&{!Yi8
z<(7Xl4A<UB5DKJ^Wkle5;>wva7dW5z%v|cvgf`BPb<0<6^mLN$EsETr(Q$S2?U}vI
zyDilr((Va2M+yDIT#h{O(`#e{^ET+}9(97kKsWG%)50t^yJy~7>GRyxTldaAQt;gj
zXXEInE+Kl_Q8hucEql;&Duo;3Vy{*8E2#DQq}F_Csty9G*l6aO;_^+()RAZ+S=5P(
zmbeU9B01_CJ{`U+ESXRgwemaax$!`~&ivJF52=j9C=h4f97k?Ka+vc#Kgs1mhu~&>
zHG-tlVwgq3a~=X`(d}0w3T%%}E?H=m9Bw;X7a}`%f_wpv=;cuBof*CFv7b|NB&v7+
zsv18t^!SUKA8wJQRu+3O(C`m<04Ykj8<iySkyLEDi`r(h{UaEZH(|qaeX~9<VtI|G
zo66pFhE3!8;FCFD)>K*C75P<B;a_*rH4JOwW8FGlCmh=FYD}XCF5w`=Frx<6>}wS1
zbz+{D3$G~m^+mC2&CTJy0N;A#7h#e%({(AU3{SW<LD8&4i`u+0u{V6mJn7`%YvHYk
zooI6r3trm1+D6_FgIzHnmSR68{!L=gCCO{q*$OGDgG`%@9O^K&@_s_^6b#g3|LQK3
zC&UW|w#rWPLFX#(_ik2JaW$p#0oKaR?=sb3<p_E>GNp&$vj1bwJ4st9mP(I<3092c
zLo#*h{6m1OjPWPDdP(gcy|@#F#NTG+@d{V_;4Fl`-0LuB(G;Sbvi3|6JK@ANoY`KV
zeBFMge&yq{AFJf(#ImHQcg<HAxUIcvd^)p1quEoZHgCg0=9b)Nz-gEKD6`H5l|G4|
z{K&QVNSPTN%fL>|Ec%&%)K81@%C!4sWEH^5PifDVAxN=fB4%(3J)E$9Cp2~~VnTDf
zz91Vhky{Q}MAH+sUUy`%t?q+(p0`q=HPfh{J{?Zd>fTd3OKZL3n`{MsVzI}1IoYyh
z@lSQ!b}ZstgJN+T%cVuEJfBplP%F4_zcXSrT|?+BJ(bh0|7&AwYyiPCuw-nuNaJd5
zf0;EYp=PGqgSTr0JM@`3`2^uemR$5hPSIZ&8D?<A!wRtHZEKM!7?!kt%8C17(~s9f
z8$JtpFBT~C*tPp=#cMQ@IEqe@y7t@k==^hv1gB%eEUGY~+K8Gee<fhdONRnH`{FGc
zyYsb@7)mXI>*o(a!;nIZ=J`QF>57cVe?E_mUr{upToCv0VY+_62RAl#SO~8Sw?^Sh
zJTshNbtoB0wR>#WB-*+9Eh0CfaIIWkTIJ=-<?Yn}ZC{2#>E(md1+@(GU9@I;SF9!k
zUpmkPli%ktnZenJGENUgNNG9R|9021td+>R*Tt%B$NlJ@eYtN<+ChHwuM&RC4BkCE
zGr5T*z2BOg#O0}{ej=W7HBz}e6oiRWOldKj1EOn<?TLV{Z7(w~X!>0^gyYBg&m}Q(
ziz>YsT-zf_z3)(*UMda%ekAeX=kBALEC)34{v1`1Xwb33s$f<%EdE9`kSZwRnV>ba
z&GUZvTUp?CLN7;@W+JS-yH-M>I{$K5Sk9=D>54mq$`T;fTt~#4V%8F0mp3Tr@;Xly
z;#Q)`C6Sh-91$xcxu5sFQ7y_Q$Z0!;#>pG?O>V)!{*UpT)*{@O39Ij04S^x4^^um5
z6#xBz$&IK=O6Sq1ZO^CQh5^LWWQlv62gT5hgRf+SjXTuP-_b5oJPOs<oUPT`?Rku^
z425tKD!_4Ff#YZm{yq}dbjEF;CiW$zn3LW<`|!aMhM{Ob1fO3MMrkecocuK6b#r^}
zSR_Igc$Pth{*r=osTLNgVJ0jXQS`04+_V;#aJ?$&__!?5bzS1_93Uh~8WghnCYMg}
z7Y{FLM0P~0ZE2W9!&85}Q+y;QR1}%=-ZsJKfS#hA%Oa1KnMrgZY81d#31hXrDymny
zi(hzY0oo0_@GRVLN%Wb!I2Z)F{rqa1d`y7HjDB`xkBxHZ%*3TzfUuUU1?Dz|a3z?c
zYwnTHl#(IsLMgM5xyh|<*{1tvF-1GER%LoR9C1}mFzK&@NM!z;bvjnH%-4Ueol4jH
z8O@G^EoX9ImM|cpo>+(W^|qFHL5azw1;@t?X!Q*8<iZ`tew{{M%oFVYwCP-i*HB&b
z6k7XMXf%)D^ZMS4q_NRFaP3@V<qsKpke#2e^_OEF)vg<qN#=%Og5I(Aov11Fg%-2E
zq}DDr1j%pCWC}}K$^9Qy^gpfm|I)A|Rmj8s@8|!^f9#aZ{mw5gEj>T=fx%jWpIzpA
KnT0<%h5rwI6fgn+

literal 0
HcmV?d00001

diff --git a/benchmarks/beir/figures/scaling_curve.png b/benchmarks/beir/figures/scaling_curve.png
new file mode 100644
index 0000000000000000000000000000000000000000..b771a45279554b10a692e6d5ceb6ff96b6d9ca50
GIT binary patch
literal 145541
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

literal 0
HcmV?d00001

diff --git a/benchmarks/beir/requirements.txt b/benchmarks/beir/requirements.txt
index 381270f0..2e14356c 100644
--- a/benchmarks/beir/requirements.txt
+++ b/benchmarks/beir/requirements.txt
@@ -1,12 +1,39 @@
-beir
+# ordvec-beir benchmark — Python dependencies
+#
+# The canonical encoder lane is `llamacpp` (GGUF Q8_0 via llama-cpp-python,
+# CUDA). `make bench-beir-setup` installs this file, then builds
+# llama-cpp-python against the host CUDA toolkit (CMAKE_ARGS="-DGGML_CUDA=on")
+# — it is intentionally NOT listed here so `pip install -r requirements.txt`
+# never produces a throwaway CPU-only build.
+#
+# We deliberately do NOT depend on the `beir` package: it pulls the `pytrec_eval`
+# sdist, which fails to build on modern gcc. The BEIR dataset loader is vendored
+# in beir_prepare.py and evaluation uses the prebuilt `pytrec-eval-terrier`
+# wheel instead.
+
+# --- core ---
 numpy
 scipy
-sentence-transformers
-torch
-transformers
-faiss-cpu
-hnswlib
-tqdm
 requests
+tqdm
 pandas
 tabulate
+
+# --- model download for the canonical llamacpp lane ---
+huggingface-hub
+
+# --- retrieval baselines (comparison references, NOT ground truth) ---
+faiss-cpu
+hnswlib
+
+# --- evaluation: trec_eval bindings (prebuilt wheel, no C compile) ---
+pytrec-eval-terrier
+
+# --- README benchmark graphics ---
+matplotlib
+
+# --- optional: sentence-transformers lane (`--provider st`) ---
+# Heavy (pulls torch). Uncomment to enable the fp32 ST encoder lane:
+# sentence-transformers
+# torch
+# transformers
diff --git a/examples/beir_ordvec.rs b/examples/beir_ordvec.rs
deleted file mode 100644
index 9f27eaa6..00000000
--- a/examples/beir_ordvec.rs
+++ /dev/null
@@ -1,1195 +0,0 @@
-//! OrdVec BEIR evaluation driver.
-//!
-//! Loads pre-computed embeddings from the shared cache layout, runs
-//! OrdVec index methods over the BEIR query set, and writes per-query
-//! top-k JSONL + per-method summary JSON to the results directory.
-//!
-//! BEIR metrics (NDCG@10, MAP, …) are NOT computed here; they are
-//! evaluated offline in Python against the qrels files.
-//!
-//! Usage:
-//!   cargo run --release --example beir_ordvec -- \
-//!     --cache-dir .cache/ordvec-beir \
-//!     --dataset scifact \
-//!     --split test \
-//!     --methods rq2,rq4,bitmap-rq2,sign-rq2 \
-//!     --candidates 500 \
-//!     --top-k 100 \
-//!     --batch 8 \
-//!     --out-dir results/beir
-//!
-//! Cache layout (one encoder per prepare run):
-//!   <cache-dir>/<dataset>/<split>/encoder=<slug>/
-//!     corpus.f32.npy   queries.f32.npy
-//!     corpus_ids.json  query_ids.json  qrels.json
-//!     texts.manifest.json  embeddings.manifest.json  sha256s.json
-//!
-//! Results layout:
-//!   <out-dir>/<dataset>/<method-slug>.topk.jsonl
-//!   <out-dir>/<dataset>/<method-slug>.summary.json
-
-use ordvec::{Bitmap, CandidateBatch, RankQuant, SignBitmap, SubsetScratch};
-use std::io::{BufWriter, Write};
-use std::time::Instant;
-
-// ---------------------------------------------------------------------------
-// Config
-// ---------------------------------------------------------------------------
-
-struct Config {
-    cache_dir: String,
-    dataset: String,
-    split: String,
-    top_k: usize,
-    batch: usize,
-    candidates: usize,
-    methods: Vec<String>,
-    out_dir: String,
-}
-
-fn parse_args() -> Config {
-    let mut cache_dir = String::from(".cache/ordvec-beir");
-    let mut dataset = String::new();
-    let mut split = String::from("test");
-    let mut top_k = 100usize;
-    let mut batch = 8usize;
-    let mut candidates = 500usize;
-    let mut methods = vec![
-        "rq2".to_string(),
-        "rq4".to_string(),
-        "bitmap-rq2".to_string(),
-        "sign-rq2".to_string(),
-    ];
-    let mut out_dir = String::from("results/beir");
-
-    let mut args = std::env::args().skip(1);
-    while let Some(a) = args.next() {
-        match a.as_str() {
-            "--cache-dir" => cache_dir = args.next().expect("--cache-dir requires a value"),
-            "--dataset" => dataset = args.next().expect("--dataset requires a value"),
-            "--split" => split = args.next().expect("--split requires a value"),
-            "--top-k" => {
-                top_k = args
-                    .next()
-                    .expect("--top-k requires a value")
-                    .parse()
-                    .expect("--top-k must be an integer")
-            }
-            "--batch" => {
-                batch = args
-                    .next()
-                    .expect("--batch requires a value")
-                    .parse()
-                    .expect("--batch must be an integer")
-            }
-            "--candidates" => {
-                candidates = args
-                    .next()
-                    .expect("--candidates requires a value")
-                    .parse()
-                    .expect("--candidates must be an integer")
-            }
-            "--methods" => {
-                methods = args
-                    .next()
-                    .expect("--methods requires a value")
-                    .split(',')
-                    .map(|s| s.trim().to_string())
-                    .filter(|s| !s.is_empty())
-                    .collect()
-            }
-            "--out-dir" => out_dir = args.next().expect("--out-dir requires a value"),
-            other => panic!("unknown argument: {other}"),
-        }
-    }
-    assert!(!dataset.is_empty(), "--dataset is required");
-    assert!(batch >= 1, "--batch must be >= 1");
-    assert!(top_k >= 1, "--top-k must be >= 1");
-    assert!(candidates >= 1, "--candidates must be >= 1");
-
-    Config {
-        cache_dir,
-        dataset,
-        split,
-        top_k,
-        batch,
-        candidates,
-        methods,
-        out_dir,
-    }
-}
-
-// ---------------------------------------------------------------------------
-// NumPy v1 reader (2-D LE f32, C-order) — adapted from bench_rank.rs
-// ---------------------------------------------------------------------------
-
-fn load_npy_f32(path: &str) -> (Vec<f32>, usize, usize) {
-    let bytes = std::fs::read(path).unwrap_or_else(|e| panic!("read npy {path}: {e}"));
-    assert!(bytes.len() >= 10, "npy file too short: {path}");
-    assert_eq!(&bytes[..6], b"\x93NUMPY", "not a numpy file: {path}");
-    let major = bytes[6];
-    let minor = bytes[7];
-    assert!(
-        major == 1 || major == 2,
-        "unsupported npy version {major}.{minor}: {path}",
-    );
-    let (header_len, header_start) = if major == 1 {
-        let hl = u16::from_le_bytes([bytes[8], bytes[9]]) as usize;
-        (hl, 10)
-    } else {
-        let hl = u32::from_le_bytes([bytes[8], bytes[9], bytes[10], bytes[11]]) as usize;
-        (hl, 12)
-    };
-    let header = std::str::from_utf8(&bytes[header_start..header_start + header_len])
-        .expect("npy header not utf-8");
-    assert!(
-        header.contains("'descr': '<f4'"),
-        "expected <f4 dtype in {path}: {header}",
-    );
-    assert!(
-        header.contains("'fortran_order': False"),
-        "expected C order in {path}",
-    );
-    let shape_start = header.find("'shape':").expect("no shape in npy header");
-    let after = &header[shape_start..];
-    let open = after.find('(').unwrap();
-    let close = after.find(')').unwrap();
-    let dims: Vec<usize> = after[open + 1..close]
-        .split(',')
-        .filter_map(|s| s.trim().parse::<usize>().ok())
-        .collect();
-    assert_eq!(
-        dims.len(),
-        2,
-        "expected 2-D array in {path}, got {} dims",
-        dims.len()
-    );
-    let n = dims[0];
-    let dim = dims[1];
-    let data_start = header_start + header_len;
-    let n_floats = n * dim;
-    assert_eq!(
-        bytes.len() - data_start,
-        n_floats * 4,
-        "data length mismatch in {path}",
-    );
-    let mut out = vec![0.0f32; n_floats];
-    for (i, chunk) in bytes[data_start..].chunks_exact(4).enumerate() {
-        out[i] = f32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
-    }
-    (out, n, dim)
-}
-
-// ---------------------------------------------------------------------------
-// JSON helpers (no serde dep: manual string building)
-// ---------------------------------------------------------------------------
-
-fn load_json_string_array(path: &str) -> Vec<String> {
-    let text = std::fs::read_to_string(path).unwrap_or_else(|e| panic!("read {path}: {e}"));
-    // Minimal parser: split on `"`, take even-indexed non-empty tokens between quotes.
-    // Works for a JSON array of strings with no embedded quotes.
-    let mut out = Vec::new();
-    let mut in_str = false;
-    let mut cur = String::new();
-    let mut chars = text.chars().peekable();
-    while let Some(c) = chars.next() {
-        if c == '"' {
-            if in_str {
-                out.push(cur.clone());
-                cur.clear();
-                in_str = false;
-            } else {
-                in_str = true;
-            }
-        } else if in_str {
-            if c == '\\' {
-                if let Some(next) = chars.next() {
-                    match next {
-                        '"' => cur.push('"'),
-                        '\\' => cur.push('\\'),
-                        'n' => cur.push('\n'),
-                        't' => cur.push('\t'),
-                        other => {
-                            cur.push('\\');
-                            cur.push(other);
-                        }
-                    }
-                }
-            } else {
-                cur.push(c);
-            }
-        }
-    }
-    out
-}
-
-/// sha256 of a file using the system sha256sum / shasum / openssl.
-///
-/// Panics if none of those tools is available — the manifest hash is provenance
-/// that must match the Python (`hashlib`) digest, so we never emit a non-SHA-256
-/// value that merely looks like one.
-fn sha256_file(path: &str) -> String {
-    // Try sha256sum (Linux), then shasum -a 256 (macOS), then openssl.
-    for (cmd, args) in &[
-        ("sha256sum", vec![path]),
-        ("shasum", vec!["-a", "256", path]),
-        ("openssl", vec!["dgst", "-sha256", path]),
-    ] {
-        if let Ok(out) = std::process::Command::new(cmd).args(args).output() {
-            if out.status.success() {
-                let s = String::from_utf8_lossy(&out.stdout);
-                // sha256sum: "<hex>  <file>"; shasum: same; openssl: "SHA256(...)= <hex>"
-                for token in s.split_whitespace() {
-                    if token.len() == 64 && token.chars().all(|c| c.is_ascii_hexdigit()) {
-                        return token.to_string();
-                    }
-                }
-            }
-        }
-    }
-    panic!(
-        "no SHA-256 tool available (tried sha256sum / shasum -a 256 / openssl) — \
-         cannot compute the encoder-manifest digest for {path}"
-    );
-}
-
-// ---------------------------------------------------------------------------
-// Detect SIMD features
-// ---------------------------------------------------------------------------
-
-fn detected_simd() -> Vec<String> {
-    #[cfg(target_arch = "x86_64")]
-    {
-        let mut v = Vec::new();
-        if is_x86_feature_detected!("avx2") {
-            v.push("avx2".to_string());
-        }
-        if is_x86_feature_detected!("fma") {
-            v.push("fma".to_string());
-        }
-        if is_x86_feature_detected!("avx512f") {
-            v.push("avx512f".to_string());
-        }
-        v
-    }
-    #[cfg(not(target_arch = "x86_64"))]
-    {
-        Vec::new()
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Percentile helper
-// ---------------------------------------------------------------------------
-
-fn percentile_ms(mut samples: Vec<u128>, p: f32) -> f64 {
-    samples.sort_unstable();
-    let i = ((samples.len() as f32 - 1.0) * p).round() as usize;
-    // samples are nanoseconds; convert to milliseconds
-    samples[i] as f64 / 1_000_000.0
-}
-
-// ---------------------------------------------------------------------------
-// Top-k JSONL writer
-// ---------------------------------------------------------------------------
-
-/// Write one JSONL row per query to `writer`.
-/// `indices` is a flat `nq * k` slice (global doc indices, i64; -1 = padding).
-fn write_topk_jsonl<W: Write>(
-    writer: &mut W,
-    dataset: &str,
-    split: &str,
-    method: &str,
-    k: usize,
-    query_ids: &[String],
-    corpus_ids: &[String],
-    indices: &[i64],
-    scores: &[f32],
-) {
-    let nq = query_ids.len();
-    let n_corpus = corpus_ids.len();
-    for qi in 0..nq {
-        let row_indices = &indices[qi * k..(qi + 1) * k];
-        // Build doc_idxs and doc_ids arrays (skip sentinels at the end).
-        let mut doc_idxs_str = String::from("[");
-        let mut doc_ids_str = String::from("[");
-        let mut scores_str = String::from("[");
-        let mut first = true;
-        for (j, &di) in row_indices.iter().enumerate() {
-            if di < 0 {
-                break;
-            }
-            let di_usize = di as usize;
-            if !first {
-                doc_idxs_str.push(',');
-                doc_ids_str.push(',');
-                scores_str.push(',');
-            }
-            first = false;
-            doc_idxs_str.push_str(&di_usize.to_string());
-            let doc_id = if di_usize < n_corpus {
-                corpus_ids[di_usize].as_str()
-            } else {
-                ""
-            };
-            doc_ids_str.push('"');
-            doc_ids_str.push_str(doc_id);
-            doc_ids_str.push('"');
-            // Real per-doc score (results are rank-ordered; downstream eval ranks
-            // by score). Non-finite guarded to keep the JSON valid.
-            let sc = scores.get(qi * k + j).copied().unwrap_or(0.0);
-            if sc.is_finite() {
-                scores_str.push_str(&sc.to_string());
-            } else {
-                scores_str.push_str("0.0");
-            }
-        }
-        doc_idxs_str.push(']');
-        doc_ids_str.push(']');
-        scores_str.push(']');
-
-        writeln!(
-            writer,
-            r#"{{"dataset":"{dataset}","split":"{split}","method":"{method}","qid_idx":{qi},"qid":"{qid}","k":{k},"doc_idxs":{doc_idxs_str},"doc_ids":{doc_ids_str},"scores":{scores_str}}}"#,
-            qid = query_ids[qi],
-        )
-        .expect("write topk jsonl");
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Summary JSON writer
-// ---------------------------------------------------------------------------
-
-#[allow(clippy::too_many_arguments)]
-fn write_summary_json<W: Write>(
-    writer: &mut W,
-    dataset: &str,
-    split: &str,
-    method: &str,
-    dim: usize,
-    n_docs: usize,
-    n_queries: usize,
-    top_k: usize,
-    bytes_per_vector: usize,
-    index_total_mib: f64,
-    build_seconds: f64,
-    p50_ms: f64,
-    p95_ms: f64,
-    p99_ms: f64,
-    queries_per_second: f64,
-    candidate_m: usize,
-    batch: usize,
-    simd_detected: &[String],
-    encoder_manifest_sha256: &str,
-) {
-    let simd_arr: String = {
-        let parts: Vec<String> = simd_detected.iter().map(|s| format!("\"{s}\"")).collect();
-        format!("[{}]", parts.join(","))
-    };
-    let rustc = rustc_version();
-    let crate_ver = env!("CARGO_PKG_VERSION");
-    writeln!(
-        writer,
-        r#"{{"dataset":"{dataset}","split":"{split}","method":"{method}","dim":{dim},"n_docs":{n_docs},"n_queries":{n_queries},"top_k":{top_k},"bytes_per_vector":{bytes_per_vector},"index_total_mib":{index_total_mib:.3},"build_seconds":{build_seconds:.4},"query_latency_ms_p50":{p50_ms:.4},"query_latency_ms_p95":{p95_ms:.4},"query_latency_ms_p99":{p99_ms:.4},"queries_per_second":{queries_per_second:.2},"candidate_m":{candidate_m},"batch":{batch},"cpu_arch":"{arch}","simd_detected":{simd_arr},"rustc":"{rustc}","crate_version":"{crate_ver}","encoder_manifest_sha256":"{encoder_manifest_sha256}"}}"#,
-        arch = std::env::consts::ARCH,
-    )
-    .expect("write summary json");
-}
-
-fn rustc_version() -> String {
-    if let Ok(out) = std::process::Command::new("rustc")
-        .arg("--version")
-        .output()
-    {
-        if out.status.success() {
-            return String::from_utf8_lossy(&out.stdout).trim().to_string();
-        }
-    }
-    "unknown".to_string()
-}
-
-// ---------------------------------------------------------------------------
-// Output file helpers
-// ---------------------------------------------------------------------------
-
-fn open_output(out_dir: &str, dataset: &str, slug: &str, ext: &str) -> BufWriter<std::fs::File> {
-    let dir = format!("{out_dir}/{dataset}");
-    std::fs::create_dir_all(&dir).unwrap_or_else(|e| panic!("create_dir_all {dir}: {e}"));
-    let path = format!("{dir}/{slug}.{ext}");
-    let f = std::fs::File::create(&path).unwrap_or_else(|e| panic!("create {path}: {e}"));
-    BufWriter::new(f)
-}
-
-// ---------------------------------------------------------------------------
-// Validate embeddings
-// ---------------------------------------------------------------------------
-
-fn validate_embeddings(data: &[f32], n: usize, dim: usize, label: &str) {
-    assert_eq!(dim, 1024, "{label}: embedding_dim must be 1024, got {dim}");
-    assert_eq!(dim % 16, 0, "{label}: dim must be divisible by 16");
-    for (i, row) in data.chunks_exact(dim).enumerate() {
-        let norm2: f32 = row.iter().map(|x| x * x).sum();
-        let norm = norm2.sqrt();
-        assert!(
-            (norm - 1.0).abs() < 1e-3,
-            "{label} row {i}: L2 norm {norm:.6} not in [0.999, 1.001]",
-        );
-    }
-    eprintln!("  {label}: validated {n} rows (dim={dim}, L2-normalised)");
-}
-
-// ---------------------------------------------------------------------------
-// Timing helpers
-// ---------------------------------------------------------------------------
-
-/// Collect per-query latency samples (ns) for `search_fn` applied to each
-/// query row. `warmup` queries are excluded from timing.
-fn time_batched<F>(
-    queries: &[f32],
-    dim: usize,
-    n_queries: usize,
-    batch: usize,
-    warmup: usize,
-    mut search_fn: F,
-) -> Vec<u128>
-where
-    F: FnMut(&[f32]) -> Vec<i64>,
-{
-    // Warmup: run a few batches without recording.
-    let warmup_queries = warmup.min(n_queries);
-    {
-        let w_end = (warmup_queries + batch - 1) / batch * batch;
-        let w_end = w_end.min(n_queries);
-        for b_start in (0..w_end).step_by(batch) {
-            let b_end = (b_start + batch).min(n_queries);
-            let batch_q = &queries[b_start * dim..b_end * dim];
-            let _ = search_fn(batch_q);
-        }
-    }
-
-    let mut samples = Vec::with_capacity(n_queries);
-    let mut b_start = 0usize;
-    while b_start < n_queries {
-        let b_end = (b_start + batch).min(n_queries);
-        let b = b_end - b_start;
-        let batch_q = &queries[b_start * dim..b_end * dim];
-        let t0 = Instant::now();
-        let _ = search_fn(batch_q);
-        let elapsed_ns = t0.elapsed().as_nanos();
-        let per_query_ns = elapsed_ns / b as u128;
-        for _ in 0..b {
-            samples.push(per_query_ns);
-        }
-        b_start = b_end;
-    }
-    samples
-}
-
-// ---------------------------------------------------------------------------
-// Collect all predictions (flat nq*k indices)
-// ---------------------------------------------------------------------------
-
-fn collect_all_predictions<F>(
-    queries: &[f32],
-    dim: usize,
-    n_queries: usize,
-    top_k: usize,
-    batch: usize,
-    mut search_fn: F,
-) -> (Vec<i64>, Vec<f32>)
-where
-    F: FnMut(&[f32]) -> (Vec<i64>, Vec<f32>),
-{
-    let mut out_i = Vec::with_capacity(n_queries * top_k);
-    let mut out_s = Vec::with_capacity(n_queries * top_k);
-    let mut b_start = 0usize;
-    while b_start < n_queries {
-        let b_end = (b_start + batch).min(n_queries);
-        let batch_q = &queries[b_start * dim..b_end * dim];
-        let (pi, ps) = search_fn(batch_q);
-        out_i.extend_from_slice(&pi);
-        out_s.extend_from_slice(&ps);
-        b_start = b_end;
-    }
-    (out_i, out_s)
-}
-
-// ---------------------------------------------------------------------------
-// Method runners
-// ---------------------------------------------------------------------------
-
-/// Build a Bitmap→CSR helper: convert `Vec<Vec<u32>>` (one row per query)
-/// into CSR (offsets, concatenated candidates).
-fn bitmap_vecs_to_csr(vecs: Vec<Vec<u32>>) -> (Vec<usize>, Vec<u32>) {
-    let nq = vecs.len();
-    let mut offsets = Vec::with_capacity(nq + 1);
-    let mut candidates = Vec::new();
-    offsets.push(0usize);
-    for row in &vecs {
-        candidates.extend_from_slice(row);
-        offsets.push(candidates.len());
-    }
-    (offsets, candidates)
-}
-
-/// rq2 / rq4: full-scan asymmetric search.
-fn run_full_scan(
-    corpus: &[f32],
-    queries: &[f32],
-    dim: usize,
-    n_queries: usize,
-    top_k: usize,
-    batch: usize,
-    bits: u8,
-    dataset: &str,
-    split: &str,
-    query_ids: &[String],
-    corpus_ids: &[String],
-    out_dir: &str,
-    simd: &[String],
-    encoder_sha: &str,
-) {
-    let method_slug = format!("ordvec-rq{bits}");
-    eprintln!("building RankQuant b={bits} index ...");
-    let mut idx = RankQuant::new(dim, bits);
-    let t0 = Instant::now();
-    idx.add(corpus);
-    let build_seconds = t0.elapsed().as_secs_f64();
-    eprintln!("  build done in {build_seconds:.2}s ({} docs)", idx.len());
-
-    let n_docs = idx.len();
-    let bytes_per_vector = idx.bytes_per_vec();
-    let index_total_mib = idx.byte_size() as f64 / 1024.0 / 1024.0;
-
-    // Warmup: min(5, n_queries) queries.
-    let warmup = 5.min(n_queries);
-
-    // Timing pass (batched, allocation-free after warmup).
-    eprintln!("  timing {n_queries} queries (batch={batch}, warmup={warmup}) ...");
-    let samples = time_batched(queries, dim, n_queries, batch, warmup, |batch_q| {
-        let res = idx.search_asymmetric(batch_q, top_k);
-        res.indices
-    });
-
-    let p50 = percentile_ms(samples.clone(), 0.50);
-    let p95 = percentile_ms(samples.clone(), 0.95);
-    let p99 = percentile_ms(samples, 0.99);
-    let qps = 1_000.0 / p50.max(f64::EPSILON);
-
-    // Collect predictions.
-    eprintln!("  collecting predictions ...");
-    let (pred_indices, pred_scores) =
-        collect_all_predictions(queries, dim, n_queries, top_k, batch, |batch_q| {
-            let res = idx.search_asymmetric(batch_q, top_k);
-            (res.indices, res.scores)
-        });
-
-    // Write JSONL.
-    let mut jsonl_writer = open_output(out_dir, dataset, &method_slug, "topk.jsonl");
-    write_topk_jsonl(
-        &mut jsonl_writer,
-        dataset,
-        split,
-        &method_slug,
-        top_k,
-        query_ids,
-        corpus_ids,
-        &pred_indices,
-        &pred_scores,
-    );
-    jsonl_writer.flush().expect("flush topk jsonl");
-
-    // Write summary.
-    let mut summary_writer = open_output(out_dir, dataset, &method_slug, "summary.json");
-    write_summary_json(
-        &mut summary_writer,
-        dataset,
-        split,
-        &method_slug,
-        dim,
-        n_docs,
-        n_queries,
-        top_k,
-        bytes_per_vector,
-        index_total_mib,
-        build_seconds,
-        p50,
-        p95,
-        p99,
-        qps,
-        0, // candidate_m not applicable for full scan
-        batch,
-        simd,
-        encoder_sha,
-    );
-    summary_writer.flush().expect("flush summary json");
-    eprintln!("  {method_slug}: p50={p50:.3}ms p95={p95:.3}ms p99={p99:.3}ms qps={qps:.1}",);
-}
-
-/// bitmap-rq2: Bitmap candidate gen → RankQuant b=2 asymmetric rerank.
-fn run_bitmap_rq2(
-    corpus: &[f32],
-    queries: &[f32],
-    dim: usize,
-    n_queries: usize,
-    top_k: usize,
-    batch: usize,
-    candidates: usize,
-    dataset: &str,
-    split: &str,
-    query_ids: &[String],
-    corpus_ids: &[String],
-    out_dir: &str,
-    simd: &[String],
-    encoder_sha: &str,
-) {
-    let method_slug = format!("ordvec-bitmap-rq2-m{candidates}-b{batch}");
-    eprintln!("building Bitmap + RankQuant b=2 index (m={candidates}) ...");
-
-    // n_top for the bitmap: mirror bench_rank.rs (dim/4 = top quarter, b=2-equivalent).
-    let n_top = dim / 4;
-    let mut bitmap = Bitmap::new(dim, n_top);
-    let mut rq = RankQuant::new(dim, 2);
-    let t0 = Instant::now();
-    bitmap.add(corpus);
-    rq.add(corpus);
-    let build_seconds = t0.elapsed().as_secs_f64();
-    eprintln!("  build done in {build_seconds:.2}s");
-
-    let n_docs = rq.len();
-    let bytes_per_vector = bitmap.bytes_per_vec() + rq.bytes_per_vec();
-    let index_total_mib = (bitmap.byte_size() + rq.byte_size()) as f64 / 1024.0 / 1024.0;
-
-    let out_k = top_k.min(candidates).min(n_docs);
-    let warmup = 5.min(n_queries);
-
-    // Allocate pooled scratch and output buffers — reused across all batches.
-    let mut scratch = SubsetScratch::new();
-    // Size the output buffers for a full batch (worst case = `batch` queries).
-    let max_batch = batch;
-    let mut out_scores_buf = vec![f32::NEG_INFINITY; max_batch * out_k];
-    let mut out_indices_buf = vec![-1i64; max_batch * out_k];
-
-    // Helper: run one query-batch through the two-stage pipeline.
-    // Returns flat nq_batch * out_k indices (sentinel-padded).
-    let two_stage_batch = |batch_q: &[f32],
-                           bitmap: &Bitmap,
-                           rq: &RankQuant,
-                           scratch: &mut SubsetScratch,
-                           out_scores_buf: &mut Vec<f32>,
-                           out_indices_buf: &mut Vec<i64>|
-     -> (Vec<i64>, Vec<f32>) {
-        let nq_batch = batch_q.len() / dim;
-        // Resize scratch output buffers if batch shrinks (last batch may be smaller).
-        let needed = nq_batch * out_k;
-        if out_scores_buf.len() != needed {
-            out_scores_buf.resize(needed, f32::NEG_INFINITY);
-            out_indices_buf.resize(needed, -1);
-        }
-
-        // Stage 1: bitmap candidate gen → Vec<Vec<u32>>.
-        let cand_vecs = bitmap.top_m_candidates_batched(batch_q, candidates);
-        // Convert to CSR for the batched subset rerank.
-        let (offsets, cand_flat) = bitmap_vecs_to_csr(cand_vecs);
-
-        // Stage 2: pooled subset rerank.
-        rq.search_asymmetric_subset_batched_serial_into(
-            batch_q,
-            &offsets,
-            &cand_flat,
-            top_k,
-            scratch,
-            out_scores_buf,
-            out_indices_buf,
-        );
-
-        // Map candidate-local indices (already global doc ids, since cands come from
-        // bitmap which stores global doc ids) — indices are already global.
-        // Pad per-query results to `top_k` with -1 sentinels if out_k < top_k.
-        let mut result = vec![-1i64; nq_batch * top_k];
-        let mut result_scores = vec![0.0f32; nq_batch * top_k];
-        for qi in 0..nq_batch {
-            let src = &out_indices_buf[qi * out_k..(qi + 1) * out_k];
-            let src_s = &out_scores_buf[qi * out_k..(qi + 1) * out_k];
-            let dst = &mut result[qi * top_k..(qi + 1) * top_k];
-            let copy_len = src.len().min(dst.len());
-            dst[..copy_len].copy_from_slice(&src[..copy_len]);
-            result_scores[qi * top_k..qi * top_k + copy_len].copy_from_slice(&src_s[..copy_len]);
-        }
-        (result, result_scores)
-    };
-
-    eprintln!("  timing {n_queries} queries (batch={batch}, warmup={warmup}) ...");
-    let samples = {
-        // Warmup.
-        {
-            let w_end = (warmup + batch - 1) / batch * batch;
-            let w_end = w_end.min(n_queries);
-            for b_start in (0..w_end).step_by(batch) {
-                let b_end = (b_start + batch).min(n_queries);
-                let batch_q = &queries[b_start * dim..b_end * dim];
-                let _ = two_stage_batch(
-                    batch_q,
-                    &bitmap,
-                    &rq,
-                    &mut scratch,
-                    &mut out_scores_buf,
-                    &mut out_indices_buf,
-                );
-            }
-        }
-        let mut s = Vec::with_capacity(n_queries);
-        let mut b_start = 0usize;
-        while b_start < n_queries {
-            let b_end = (b_start + batch).min(n_queries);
-            let b = b_end - b_start;
-            let batch_q = &queries[b_start * dim..b_end * dim];
-            let t0 = Instant::now();
-            let _ = two_stage_batch(
-                batch_q,
-                &bitmap,
-                &rq,
-                &mut scratch,
-                &mut out_scores_buf,
-                &mut out_indices_buf,
-            );
-            let elapsed_ns = t0.elapsed().as_nanos();
-            let per_query_ns = elapsed_ns / b as u128;
-            for _ in 0..b {
-                s.push(per_query_ns);
-            }
-            b_start = b_end;
-        }
-        s
-    };
-
-    let p50 = percentile_ms(samples.clone(), 0.50);
-    let p95 = percentile_ms(samples.clone(), 0.95);
-    let p99 = percentile_ms(samples, 0.99);
-    let qps = 1_000.0 / p50.max(f64::EPSILON);
-
-    eprintln!("  collecting predictions ...");
-    let mut pred_indices = Vec::with_capacity(n_queries * top_k);
-    let mut pred_scores: Vec<f32> = Vec::with_capacity(n_queries * top_k);
-    let mut b_start = 0usize;
-    while b_start < n_queries {
-        let b_end = (b_start + batch).min(n_queries);
-        let batch_q = &queries[b_start * dim..b_end * dim];
-        let (preds, pred_s) = two_stage_batch(
-            batch_q,
-            &bitmap,
-            &rq,
-            &mut scratch,
-            &mut out_scores_buf,
-            &mut out_indices_buf,
-        );
-        pred_indices.extend_from_slice(&preds);
-        pred_scores.extend_from_slice(&pred_s);
-        b_start = b_end;
-    }
-
-    // Write outputs.
-    let mut jsonl_writer = open_output(out_dir, dataset, &method_slug, "topk.jsonl");
-    write_topk_jsonl(
-        &mut jsonl_writer,
-        dataset,
-        split,
-        &method_slug,
-        top_k,
-        query_ids,
-        corpus_ids,
-        &pred_indices,
-        &pred_scores,
-    );
-    jsonl_writer.flush().expect("flush topk jsonl");
-
-    let mut summary_writer = open_output(out_dir, dataset, &method_slug, "summary.json");
-    write_summary_json(
-        &mut summary_writer,
-        dataset,
-        split,
-        &method_slug,
-        dim,
-        n_docs,
-        n_queries,
-        top_k,
-        bytes_per_vector,
-        index_total_mib,
-        build_seconds,
-        p50,
-        p95,
-        p99,
-        qps,
-        candidates,
-        batch,
-        simd,
-        encoder_sha,
-    );
-    summary_writer.flush().expect("flush summary json");
-    eprintln!("  {method_slug}: p50={p50:.3}ms p95={p95:.3}ms p99={p99:.3}ms qps={qps:.1}",);
-}
-
-/// sign-rq2: SignBitmap candidate gen → RankQuant b=2 asymmetric rerank.
-fn run_sign_rq2(
-    corpus: &[f32],
-    queries: &[f32],
-    dim: usize,
-    n_queries: usize,
-    top_k: usize,
-    batch: usize,
-    candidates: usize,
-    dataset: &str,
-    split: &str,
-    query_ids: &[String],
-    corpus_ids: &[String],
-    out_dir: &str,
-    simd: &[String],
-    encoder_sha: &str,
-) {
-    let method_slug = format!("ordvec-sign-rq2-m{candidates}-b{batch}");
-    eprintln!("building SignBitmap + RankQuant b=2 index (m={candidates}) ...");
-
-    let mut sign = SignBitmap::new(dim);
-    let mut rq = RankQuant::new(dim, 2);
-    let t0 = Instant::now();
-    sign.add(corpus);
-    rq.add(corpus);
-    let build_seconds = t0.elapsed().as_secs_f64();
-    eprintln!("  build done in {build_seconds:.2}s");
-
-    let n_docs = rq.len();
-    let bytes_per_vector = sign.bytes_per_vec() + rq.bytes_per_vec();
-    let index_total_mib = (sign.byte_size() + rq.byte_size()) as f64 / 1024.0 / 1024.0;
-
-    let out_k = top_k.min(candidates).min(n_docs);
-    let warmup = 5.min(n_queries);
-
-    // Pooled scratch and output buffers — reused across batches (allocation-free after warmup).
-    let mut scratch = SubsetScratch::new();
-    let max_batch = batch;
-    let mut out_scores_buf = vec![f32::NEG_INFINITY; max_batch * out_k];
-    let mut out_indices_buf = vec![-1i64; max_batch * out_k];
-
-    let sign_two_stage_batch = |batch_q: &[f32],
-                                sign: &SignBitmap,
-                                rq: &RankQuant,
-                                scratch: &mut SubsetScratch,
-                                out_scores_buf: &mut Vec<f32>,
-                                out_indices_buf: &mut Vec<i64>|
-     -> (Vec<i64>, Vec<f32>) {
-        let nq_batch = batch_q.len() / dim;
-        let needed = nq_batch * out_k;
-        if out_scores_buf.len() != needed {
-            out_scores_buf.resize(needed, f32::NEG_INFINITY);
-            out_indices_buf.resize(needed, -1);
-        }
-
-        // Stage 1: SignBitmap → CSR CandidateBatch (SIMD XOR-popcount kernel).
-        let cb: CandidateBatch = sign.top_m_candidates_batched_serial_csr(batch_q, candidates);
-
-        // Stage 2: pooled subset rerank.
-        rq.search_asymmetric_subset_batched_serial_into(
-            batch_q,
-            &cb.offsets,
-            &cb.candidates,
-            top_k,
-            scratch,
-            out_scores_buf,
-            out_indices_buf,
-        );
-
-        // Pad per-query results to `top_k` with -1 sentinels if out_k < top_k.
-        let mut result = vec![-1i64; nq_batch * top_k];
-        let mut result_scores = vec![0.0f32; nq_batch * top_k];
-        for qi in 0..nq_batch {
-            let src = &out_indices_buf[qi * out_k..(qi + 1) * out_k];
-            let src_s = &out_scores_buf[qi * out_k..(qi + 1) * out_k];
-            let dst = &mut result[qi * top_k..(qi + 1) * top_k];
-            let copy_len = src.len().min(dst.len());
-            dst[..copy_len].copy_from_slice(&src[..copy_len]);
-            result_scores[qi * top_k..qi * top_k + copy_len].copy_from_slice(&src_s[..copy_len]);
-        }
-        (result, result_scores)
-    };
-
-    eprintln!("  timing {n_queries} queries (batch={batch}, warmup={warmup}) ...");
-
-    // Warmup via top_m_candidates_batched_serial_csr.
-    {
-        let w_end = warmup.min(n_queries);
-        if w_end > 0 {
-            let _ = sign.top_m_candidates_batched_serial_csr(&queries[..w_end * dim], candidates);
-        }
-    }
-
-    let samples = {
-        let mut s = Vec::with_capacity(n_queries);
-        let mut b_start = 0usize;
-        while b_start < n_queries {
-            let b_end = (b_start + batch).min(n_queries);
-            let b = b_end - b_start;
-            let batch_q = &queries[b_start * dim..b_end * dim];
-            let t0 = Instant::now();
-            let _ = sign_two_stage_batch(
-                batch_q,
-                &sign,
-                &rq,
-                &mut scratch,
-                &mut out_scores_buf,
-                &mut out_indices_buf,
-            );
-            let elapsed_ns = t0.elapsed().as_nanos();
-            let per_query_ns = elapsed_ns / b as u128;
-            for _ in 0..b {
-                s.push(per_query_ns);
-            }
-            b_start = b_end;
-        }
-        s
-    };
-
-    let p50 = percentile_ms(samples.clone(), 0.50);
-    let p95 = percentile_ms(samples.clone(), 0.95);
-    let p99 = percentile_ms(samples, 0.99);
-    let qps = 1_000.0 / p50.max(f64::EPSILON);
-
-    eprintln!("  collecting predictions ...");
-    let mut pred_indices = Vec::with_capacity(n_queries * top_k);
-    let mut pred_scores: Vec<f32> = Vec::with_capacity(n_queries * top_k);
-    let mut b_start = 0usize;
-    while b_start < n_queries {
-        let b_end = (b_start + batch).min(n_queries);
-        let batch_q = &queries[b_start * dim..b_end * dim];
-        let (preds, pred_s) = sign_two_stage_batch(
-            batch_q,
-            &sign,
-            &rq,
-            &mut scratch,
-            &mut out_scores_buf,
-            &mut out_indices_buf,
-        );
-        pred_indices.extend_from_slice(&preds);
-        pred_scores.extend_from_slice(&pred_s);
-        b_start = b_end;
-    }
-
-    // Write outputs.
-    let mut jsonl_writer = open_output(out_dir, dataset, &method_slug, "topk.jsonl");
-    write_topk_jsonl(
-        &mut jsonl_writer,
-        dataset,
-        split,
-        &method_slug,
-        top_k,
-        query_ids,
-        corpus_ids,
-        &pred_indices,
-        &pred_scores,
-    );
-    jsonl_writer.flush().expect("flush topk jsonl");
-
-    let mut summary_writer = open_output(out_dir, dataset, &method_slug, "summary.json");
-    write_summary_json(
-        &mut summary_writer,
-        dataset,
-        split,
-        &method_slug,
-        dim,
-        n_docs,
-        n_queries,
-        top_k,
-        bytes_per_vector,
-        index_total_mib,
-        build_seconds,
-        p50,
-        p95,
-        p99,
-        qps,
-        candidates,
-        batch,
-        simd,
-        encoder_sha,
-    );
-    summary_writer.flush().expect("flush summary json");
-    eprintln!("  {method_slug}: p50={p50:.3}ms p95={p95:.3}ms p99={p99:.3}ms qps={qps:.1}",);
-}
-
-// ---------------------------------------------------------------------------
-// Cache resolution
-// ---------------------------------------------------------------------------
-
-/// Resolve the single `encoder=*` subdirectory under
-/// `<cache_dir>/<dataset>/<split>/`. Panics if zero or multiple matches.
-fn resolve_encoder_dir(cache_dir: &str, dataset: &str, split: &str) -> String {
-    let parent = format!("{cache_dir}/{dataset}/{split}");
-    let entries = std::fs::read_dir(&parent).unwrap_or_else(|e| panic!("read_dir {parent}: {e}"));
-    let mut matches: Vec<String> = entries
-        .filter_map(|e| e.ok())
-        .filter(|e| e.file_name().to_string_lossy().starts_with("encoder=") && e.path().is_dir())
-        .map(|e| e.path().to_string_lossy().to_string())
-        .collect();
-    assert!(
-        !matches.is_empty(),
-        "no encoder=* subdirectory found under {parent}",
-    );
-    assert!(
-        matches.len() == 1,
-        "multiple encoder=* directories found under {parent}: {matches:?} — \
-         specify exactly one encoder per dataset/split",
-    );
-    matches.remove(0)
-}
-
-// ---------------------------------------------------------------------------
-// main
-// ---------------------------------------------------------------------------
-
-fn main() {
-    let cfg = parse_args();
-
-    eprintln!(
-        "beir_ordvec: dataset={} split={} top_k={} batch={} candidates={} methods={:?}",
-        cfg.dataset, cfg.split, cfg.top_k, cfg.batch, cfg.candidates, cfg.methods,
-    );
-
-    // Resolve encoder directory.
-    let enc_dir = resolve_encoder_dir(&cfg.cache_dir, &cfg.dataset, &cfg.split);
-    eprintln!("encoder dir: {enc_dir}");
-
-    // Compute encoder_manifest_sha256 from embeddings.manifest.json.
-    let manifest_path = format!("{enc_dir}/embeddings.manifest.json");
-    let encoder_sha = sha256_file(&manifest_path);
-    eprintln!("encoder_manifest_sha256: {encoder_sha}");
-
-    // Load corpus embeddings.
-    let corpus_npy = format!("{enc_dir}/corpus.f32.npy");
-    eprintln!("loading corpus: {corpus_npy}");
-    let t0 = Instant::now();
-    let (corpus, n_corpus, dim) = load_npy_f32(&corpus_npy);
-    eprintln!(
-        "  loaded {n_corpus} corpus vectors in {:.2}s",
-        t0.elapsed().as_secs_f64()
-    );
-
-    // Load query embeddings.
-    let queries_npy = format!("{enc_dir}/queries.f32.npy");
-    eprintln!("loading queries: {queries_npy}");
-    let t0 = Instant::now();
-    let (queries, n_queries, q_dim) = load_npy_f32(&queries_npy);
-    assert_eq!(q_dim, dim, "query dim {q_dim} != corpus dim {dim}",);
-    eprintln!(
-        "  loaded {n_queries} query vectors in {:.2}s",
-        t0.elapsed().as_secs_f64()
-    );
-
-    // Validate embeddings.
-    validate_embeddings(&corpus, n_corpus, dim, "corpus");
-    validate_embeddings(&queries, n_queries, q_dim, "queries");
-    assert_eq!(
-        n_corpus,
-        corpus.len() / dim,
-        "corpus id count / embedding count mismatch",
-    );
-    assert_eq!(
-        n_queries,
-        queries.len() / dim,
-        "query id count / embedding count mismatch",
-    );
-
-    // Load corpus_ids and query_ids.
-    let corpus_ids_path = format!("{enc_dir}/corpus_ids.json");
-    let query_ids_path = format!("{enc_dir}/query_ids.json");
-    let corpus_ids = load_json_string_array(&corpus_ids_path);
-    let query_ids = load_json_string_array(&query_ids_path);
-    assert_eq!(
-        corpus_ids.len(),
-        n_corpus,
-        "corpus_ids length {} != n_corpus {n_corpus}",
-        corpus_ids.len(),
-    );
-    assert_eq!(
-        query_ids.len(),
-        n_queries,
-        "query_ids length {} != n_queries {n_queries}",
-        query_ids.len(),
-    );
-
-    let simd = detected_simd();
-    eprintln!("simd detected: {:?}", simd);
-    eprintln!("dim={dim} n_corpus={n_corpus} n_queries={n_queries}");
-
-    // Run each requested method.
-    for method in &cfg.methods {
-        eprintln!("\n--- method: {method} ---");
-        match method.as_str() {
-            "rq2" => run_full_scan(
-                &corpus,
-                &queries,
-                dim,
-                n_queries,
-                cfg.top_k,
-                cfg.batch,
-                2,
-                &cfg.dataset,
-                &cfg.split,
-                &query_ids,
-                &corpus_ids,
-                &cfg.out_dir,
-                &simd,
-                &encoder_sha,
-            ),
-            "rq4" => run_full_scan(
-                &corpus,
-                &queries,
-                dim,
-                n_queries,
-                cfg.top_k,
-                cfg.batch,
-                4,
-                &cfg.dataset,
-                &cfg.split,
-                &query_ids,
-                &corpus_ids,
-                &cfg.out_dir,
-                &simd,
-                &encoder_sha,
-            ),
-            "bitmap-rq2" => run_bitmap_rq2(
-                &corpus,
-                &queries,
-                dim,
-                n_queries,
-                cfg.top_k,
-                cfg.batch,
-                cfg.candidates,
-                &cfg.dataset,
-                &cfg.split,
-                &query_ids,
-                &corpus_ids,
-                &cfg.out_dir,
-                &simd,
-                &encoder_sha,
-            ),
-            "sign-rq2" => run_sign_rq2(
-                &corpus,
-                &queries,
-                dim,
-                n_queries,
-                cfg.top_k,
-                cfg.batch,
-                cfg.candidates,
-                &cfg.dataset,
-                &cfg.split,
-                &query_ids,
-                &corpus_ids,
-                &cfg.out_dir,
-                &simd,
-                &encoder_sha,
-            ),
-            other => panic!("unknown method '{other}'. Supported: rq2, rq4, bitmap-rq2, sign-rq2",),
-        }
-    }
-
-    eprintln!("\ndone. Results in {}/{}", cfg.out_dir, cfg.dataset);
-}

From 3004a4176f198ee5b44125320795b308ac2ef29d Mon Sep 17 00:00:00 2001
From: Nelson Spence <nelson@projectnavi.ai>
Date: Mon, 15 Jun 2026 09:35:56 -0500
Subject: [PATCH 3/5] fix(bench): address bot review + release-publish
 invariant
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Remediate the gemini/qodo/Codex review on #237 and the failing
release-publish-invariants gate.

beir-bench (gemini HIGH/MED + qodo Bug):
- sha256_file: pure-Rust `sha2` instead of shelling out to sha256sum/shasum/
  openssl — portable (Windows / minimal containers) and byte-identical to the
  Python hashlib digest. (gemini, main.rs)
- load_json_string_array + the topk/timing/summary writers: use `serde_json`
  for both reading and writing, so document/query IDs containing quotes,
  backslashes, or unicode escapes can no longer produce invalid JSON that
  breaks downstream `json.loads` (qodo Correctness bug) or be mis-read
  (gemini unicode-escape finding). Adds sha2 + serde_json to beir-bench deps
  (both already in the workspace lock).
- local_topk: guard `k > 0` before `select_nth_unstable_by(k - 1, ..)` so a
  zero top_k can never underflow to usize::MAX. (gemini)

beir_eval.py (gemini perf): vectorize the paired bootstrap — draw all
(n_iters x n) resample indices at once and reduce along the query axis, instead
of an n_iters Python loop. Same paired resampling, NumPy-internal speed.

Release-publish invariant (CI fail): the crate `exclude` was over-broad
(`benchmarks/`), which dropped `benchmarks/rank_modes_results.txt` — a
README-linked file the publish invariant requires in the package. Narrow the
exclude to `benchmarks/beir/` + `benchmarks/beir-bench/` (the dev-only BEIR
harness + figures + bench crate); the synthetic-bench results files stay
packaged. Verified with `cargo package --list`.

README (Codex + review nits):
- Drop the false "nothing here is hand-entered / every figure regenerated"
  claim: the harness writes the figures + nDCG/timing summaries, the tables
  transcribe them, and you can regenerate/verify everything (latencies vary by
  hardware/batch). Clarify the default run covers scifact + trec-covid (nfcorpus
  /fiqa supported), not all four.
- Add a balanced above-the-fold one-liner (quality-at-compression + no-build +
  single-query latency; HNSW wins threaded graph serving).
- Remove a duplicated `### Synthetic stress test` heading.
- The relative link to the now-excluded benchmarks/beir becomes an absolute
  GitHub URL so it doesn't dangle in the published crate.

benchmarks/beir/README.md: refresh the stale page to the merged design — GGUF
Q8 llama-cpp-python canonical lane (st/ollama optional), vendored BEIR loader,
flat/hnsw/ordvec method table, timing.jsonl + figures, and a corrected
`import ordvec` rule (external driver; the hot path is the Rust beir-bench
binary; the Python ordvec package is intentionally not imported and the wheel
is not required).

Verified: fmt --all --check, clippy -p ordvec / -p beir-bench (0 warnings),
build --locked, cargo package --list (rank_modes kept, beir excluded),
py_compile, serde_json output parses + sha2 == system/Python digest, vectorized
bootstrap matches.

Signed-off-by: Nelson Spence <nelson@projectnavi.ai>
---
 Cargo.lock                        |   2 +
 Cargo.toml                        |   6 +-
 README.md                         |  24 ++--
 benchmarks/beir-bench/Cargo.toml  |   5 +
 benchmarks/beir-bench/src/main.rs | 186 ++++++++++--------------------
 benchmarks/beir/README.md         | 177 +++++++++++++---------------
 benchmarks/beir/beir_eval.py      |   9 +-
 7 files changed, 169 insertions(+), 240 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 620b2cd2..19acee93 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -113,6 +113,8 @@ dependencies = [
  "matrixmultiply",
  "ordvec",
  "rayon",
+ "serde_json",
+ "sha2",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index f4520c95..43111e50 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,7 +21,11 @@ exclude = [
     ".github/",
     ".gitignore",
     ".playwright-mcp/",
-    "benchmarks/",
+    # The BEIR harness + figures + its bench crate are dev tooling — not shipped
+    # in the published crate. (benchmarks/rank_modes_results.txt stays IN the
+    # package: the README links it and the release-publish invariant requires it.)
+    "benchmarks/beir/",
+    "benchmarks/beir-bench/",
     "CLAUDE.md",
     "CODE_OF_CONDUCT.md",
     "CONTRIBUTING.md",
diff --git a/README.md b/README.md
index 9eec7d59..eee3957b 100644
--- a/README.md
+++ b/README.md
@@ -17,6 +17,12 @@ nearest-neighbour search over high-dimensional embeddings.
 
 ## Benchmark at a glance
 
+> **ordvec matches dense retrieval quality within BEIR qrel noise at 8–16× smaller
+> vector storage — with no training and no graph build — and sub-millisecond
+> single-query retrieval on 171K Harrier embeddings. A threaded HNSW graph still
+> wins highly-parallel batched serving; ordvec wins the lightweight
+> compressed-substrate lane.**
+
 On **trec-covid** (171,332 documents, the public [BEIR](https://github.com/beir-cellar/beir)
 benchmark) with **Harrier-Q8** 1024-d embeddings, ordvec's two-stage retrieval
 keeps a near-flat per-query cost as the corpus grows, while exact brute-force
@@ -38,11 +44,15 @@ keeps a near-flat per-query cost as the corpus grows, while exact brute-force
   make benchmark-beir       # download BEIR, embed, run all methods, render graphics
   ```
 
-  Every number and figure above is regenerated from public BEIR data by that
-  command — nothing here is hand-entered. Latency is measured for all methods in
-  **one Rust process** (no Python/FFI in the hot path); see the
-  [Benchmarks](#benchmarks) section for the single-query, batched-throughput, and
-  threaded views and their caveats.
+  The figures and result tables in this README were produced by that command on
+  public BEIR data: the harness writes the figures and the nDCG/timing summaries,
+  the README tables transcribe those outputs, and you can regenerate or verify
+  every number yourself (exact latencies vary with hardware and batch size). The
+  default run reproduces **scifact + trec-covid**; the harness also supports
+  `nfcorpus` and `fiqa`. Latency for every method is measured in **one Rust
+  process** (no Python/FFI in the hot path); see the [Benchmarks](#benchmarks)
+  section for the single-query, batched-throughput, and threaded views and their
+  caveats.
 
 ## What's different
 
@@ -273,7 +283,7 @@ candidate slices passed to `Search` until the call returns.
 ### BEIR retrieval (public datasets, reproducible)
 
 A fully reproducible harness over standard [BEIR](https://github.com/beir-cellar/beir)
-datasets lives in [`benchmarks/beir/`](benchmarks/beir). It embeds the corpus
+datasets lives in [`benchmarks/beir/`](https://github.com/Fieldnote-Echo/ordvec/tree/main/benchmarks/beir). It embeds the corpus
 with **Harrier-Q8** (GGUF `Q8_0` via `llama-cpp-python`, CUDA), then measures
 ordvec's methods against two references **in a single Rust process** so the
 latency comparison is genuinely apples-to-apples — same machine, batch, and
@@ -368,8 +378,6 @@ the point is that you can regenerate all of them with `make benchmark-beir`.
 
 ### Synthetic stress test
 
-### Synthetic stress test
-
 The head-to-head benchmark generates a seeded synthetic corpus in-process, so
 the **quality numbers (R@10, candidate-recall, bytes/vec) are deterministic**
 and regenerable from a clean checkout with no external corpus file:
diff --git a/benchmarks/beir-bench/Cargo.toml b/benchmarks/beir-bench/Cargo.toml
index 13179614..5122bf5e 100644
--- a/benchmarks/beir-bench/Cargo.toml
+++ b/benchmarks/beir-bench/Cargo.toml
@@ -23,6 +23,11 @@ rayon = "1.10"
 # unfairly slow vs ordvec's SIMD paths. Default single-threaded (our rayon pool
 # owns parallelism); we never enable its `threading` feature.
 matrixmultiply = "0.3"
+# Pure-Rust SHA-256 (manifest provenance digest) + robust JSON read/write, so the
+# harness never shells out for hashing and never emits invalid JSON on IDs that
+# contain quotes/backslashes/unicode escapes. Both are already workspace deps.
+sha2 = "0.11"
+serde_json = "1"
 
 # Release profile is inherited from the workspace root (lto, codegen-units=1,
 # opt-level=3); a member-level [profile] would be ignored with a warning.
diff --git a/benchmarks/beir-bench/src/main.rs b/benchmarks/beir-bench/src/main.rs
index cbfac093..a6d63e45 100644
--- a/benchmarks/beir-bench/src/main.rs
+++ b/benchmarks/beir-bench/src/main.rs
@@ -213,72 +213,18 @@ fn load_npy_f32(path: &str) -> (Vec<f32>, usize, usize) {
 
 fn load_json_string_array(path: &str) -> Vec<String> {
     let text = std::fs::read_to_string(path).unwrap_or_else(|e| panic!("read {path}: {e}"));
-    let mut out = Vec::new();
-    let mut in_str = false;
-    let mut cur = String::new();
-    let mut chars = text.chars().peekable();
-    while let Some(c) = chars.next() {
-        if c == '"' {
-            if in_str {
-                out.push(cur.clone());
-                cur.clear();
-                in_str = false;
-            } else {
-                in_str = true;
-            }
-        } else if in_str {
-            if c == '\\' {
-                if let Some(next) = chars.next() {
-                    match next {
-                        '"' => cur.push('"'),
-                        '\\' => cur.push('\\'),
-                        'n' => cur.push('\n'),
-                        't' => cur.push('\t'),
-                        other => {
-                            cur.push('\\');
-                            cur.push(other);
-                        }
-                    }
-                }
-            } else {
-                cur.push(c);
-            }
-        }
-    }
-    out
+    serde_json::from_str(&text).unwrap_or_else(|e| panic!("parse json string array {path}: {e}"))
 }
 
-/// sha256 of a file via system sha256sum / shasum / openssl. Panics with a clear
-/// reason; never emits a non-SHA value that merely looks like one.
+/// SHA-256 of a file, pure Rust (no shelling out — portable, incl. Windows /
+/// minimal containers). Hex-encoded; matches the Python `hashlib` digest.
 fn sha256_file(path: &str) -> String {
-    if !std::path::Path::new(path).is_file() {
-        panic!("cannot compute SHA-256: file does not exist: {path}");
-    }
-    let mut tool_ran = false;
-    for (cmd, args) in &[
-        ("sha256sum", vec![path]),
-        ("shasum", vec!["-a", "256", path]),
-        ("openssl", vec!["dgst", "-sha256", path]),
-    ] {
-        if let Ok(out) = std::process::Command::new(cmd).args(args).output() {
-            tool_ran = true;
-            if out.status.success() {
-                let s = String::from_utf8_lossy(&out.stdout);
-                for token in s.split_whitespace() {
-                    if token.len() == 64 && token.chars().all(|c| c.is_ascii_hexdigit()) {
-                        return token.to_string();
-                    }
-                }
-            }
-        }
-    }
-    if tool_ran {
-        panic!("a SHA-256 tool ran but produced no digest for {path}");
-    }
-    panic!(
-        "no SHA-256 tool available (tried sha256sum / shasum -a 256 / openssl) — \
-         cannot compute the encoder-manifest digest for {path}"
-    );
+    use sha2::{Digest, Sha256};
+    let bytes = std::fs::read(path).unwrap_or_else(|e| panic!("read {path} for sha256: {e}"));
+    Sha256::digest(&bytes)
+        .iter()
+        .map(|b| format!("{b:02x}"))
+        .collect()
 }
 
 fn rustc_version() -> String {
@@ -383,47 +329,37 @@ fn write_topk_jsonl<W: Write>(
     let n_corpus = corpus_ids.len();
     for qi in 0..nq {
         let row_indices = &indices[qi * k..(qi + 1) * k];
-        let mut doc_idxs_str = String::from("[");
-        let mut doc_ids_str = String::from("[");
-        let mut scores_str = String::from("[");
-        let mut first = true;
+        let mut doc_idxs: Vec<u64> = Vec::new();
+        let mut doc_ids: Vec<&str> = Vec::new();
+        let mut row_scores: Vec<f64> = Vec::new();
         for (j, &di) in row_indices.iter().enumerate() {
             if di < 0 {
-                break;
+                break; // sentinel marks the end of this query's results
             }
             let di_usize = di as usize;
-            if !first {
-                doc_idxs_str.push(',');
-                doc_ids_str.push(',');
-                scores_str.push(',');
-            }
-            first = false;
-            doc_idxs_str.push_str(&di_usize.to_string());
-            let doc_id = if di_usize < n_corpus {
+            doc_idxs.push(di_usize as u64);
+            doc_ids.push(if di_usize < n_corpus {
                 corpus_ids[di_usize].as_str()
             } else {
                 ""
-            };
-            doc_ids_str.push('"');
-            doc_ids_str.push_str(doc_id);
-            doc_ids_str.push('"');
+            });
             let sc = scores.get(qi * k + j).copied().unwrap_or(0.0);
-            if sc.is_finite() {
-                scores_str.push_str(&sc.to_string());
-            } else {
-                scores_str.push_str("0.0");
-            }
+            row_scores.push(if sc.is_finite() { sc as f64 } else { 0.0 });
         }
-        doc_idxs_str.push(']');
-        doc_ids_str.push(']');
-        scores_str.push(']');
-
-        writeln!(
-            writer,
-            r#"{{"dataset":"{dataset}","split":"{split}","method":"{method}","qid_idx":{qi},"qid":"{qid}","k":{k},"doc_idxs":{doc_idxs_str},"doc_ids":{doc_ids_str},"scores":{scores_str}}}"#,
-            qid = query_ids[qi],
-        )
-        .expect("write topk jsonl");
+        // serde_json guarantees valid JSON (escapes quotes/backslashes/unicode in
+        // doc/query IDs), so downstream `json.loads` never trips.
+        let row = serde_json::json!({
+            "dataset": dataset,
+            "split": split,
+            "method": method,
+            "qid_idx": qi,
+            "qid": query_ids[qi],
+            "k": k,
+            "doc_idxs": doc_idxs,
+            "doc_ids": doc_ids,
+            "scores": row_scores,
+        });
+        writeln!(writer, "{row}").expect("write topk jsonl");
     }
 }
 
@@ -452,37 +388,31 @@ struct Record<'a> {
 }
 
 fn write_record_json<W: Write + ?Sized>(w: &mut W, r: &Record) {
-    let simd_arr: String = {
-        let parts: Vec<String> = r.simd.iter().map(|s| format!("\"{s}\"")).collect();
-        format!("[{}]", parts.join(","))
-    };
-    writeln!(
-        w,
-        r#"{{"dataset":"{ds}","split":"{sp}","method":"{m}","dim":{dim},"n_docs":{nd},"n_queries":{nq},"top_k":{tk},"threads":{th},"batch":{b},"candidates":{c},"bytes_per_vector":{bpv},"index_total_mib":{imib:.3},"build_seconds":{bs:.4},"query_latency_ms_p50":{p50:.5},"query_latency_ms_p95":{p95:.5},"query_latency_ms_p99":{p99:.5},"queries_per_second":{qps:.2},"cpu_arch":"{arch}","simd_detected":{simd},"rustc":"{rustc}","crate_version":"{cv}","encoder_manifest_sha256":"{sha}"}}"#,
-        ds = r.dataset,
-        sp = r.split,
-        m = r.method,
-        dim = r.dim,
-        nd = r.n_docs,
-        nq = r.n_queries,
-        tk = r.top_k,
-        th = r.threads,
-        b = r.batch,
-        c = r.candidates,
-        bpv = r.bytes_per_vector,
-        imib = r.index_total_mib,
-        bs = r.build_seconds,
-        p50 = r.p50_ms,
-        p95 = r.p95_ms,
-        p99 = r.p99_ms,
-        qps = r.qps,
-        arch = std::env::consts::ARCH,
-        simd = simd_arr,
-        rustc = rustc_version(),
-        cv = env!("CARGO_PKG_VERSION"),
-        sha = r.encoder_sha,
-    )
-    .expect("write record json");
+    let rec = serde_json::json!({
+        "dataset": r.dataset,
+        "split": r.split,
+        "method": r.method,
+        "dim": r.dim,
+        "n_docs": r.n_docs,
+        "n_queries": r.n_queries,
+        "top_k": r.top_k,
+        "threads": r.threads,
+        "batch": r.batch,
+        "candidates": r.candidates,
+        "bytes_per_vector": r.bytes_per_vector,
+        "index_total_mib": r.index_total_mib,
+        "build_seconds": r.build_seconds,
+        "query_latency_ms_p50": r.p50_ms,
+        "query_latency_ms_p95": r.p95_ms,
+        "query_latency_ms_p99": r.p99_ms,
+        "queries_per_second": r.qps,
+        "cpu_arch": std::env::consts::ARCH,
+        "simd_detected": r.simd,
+        "rustc": rustc_version(),
+        "crate_version": env!("CARGO_PKG_VERSION"),
+        "encoder_manifest_sha256": r.encoder_sha,
+    });
+    writeln!(w, "{rec}").expect("write record json");
 }
 
 // ---------------------------------------------------------------------------
@@ -633,7 +563,9 @@ fn local_topk(row: &[f32], id_offset: usize, top_k: usize) -> Vec<(f32, i64)> {
         .map(|(j, &s)| (s, (id_offset + j) as i64))
         .collect();
     let k = top_k.min(scored.len());
-    if k < scored.len() {
+    // `k > 0` guards the `k - 1` index (top_k is asserted >= 1 at the CLI, but
+    // keep this defensive so a zero can never underflow to usize::MAX here).
+    if k > 0 && k < scored.len() {
         scored.select_nth_unstable_by(k - 1, |a, b| b.0.total_cmp(&a.0));
         scored.truncate(k);
     }
diff --git a/benchmarks/beir/README.md b/benchmarks/beir/README.md
index 86aa6570..3f9887e4 100644
--- a/benchmarks/beir/README.md
+++ b/benchmarks/beir/README.md
@@ -1,13 +1,15 @@
 # ordvec BEIR benchmark harness
 
-Reproducible nDCG@10 evaluation of ordvec's rank/sign retrieval methods across
-standard BEIR datasets, using Microsoft Harrier (harrier-oss-v1-0.6b, 1024-dim)
-as the shared encoder.
+Reproducible evaluation of ordvec's rank/sign retrieval on standard
+[BEIR](https://github.com/beir-cellar/beir) datasets — quality (nDCG@10 vs
+qrels) and latency (single-query / batched / threaded) — against an exact
+inner-product baseline and a pure-Rust HNSW. The shared encoder is Microsoft
+**Harrier** (`harrier-oss-v1-0.6b`, 1024-dim), run as GGUF `Q8_0`.
 
-## Claims discipline
+All latency is measured in **one Rust process** (`benchmarks/beir-bench`); Python
+only embeds the corpus, scores nDCG against qrels, and renders the figures.
 
-The following two paragraphs reproduce the project's required claims policy
-verbatim and govern every number produced by this harness:
+## Claims discipline
 
 > **Benchmark numbers in this repository reflect synthetic or user-runnable
 > real-corpus experiments only.  No numbers are fabricated or cherry-picked.
@@ -15,81 +17,68 @@ verbatim and govern every number produced by this harness:
 > from the commands documented here, using publicly available BEIR datasets and
 > the pinned encoder revision recorded in `embeddings.manifest.json`.**
 
-> **FAISS FlatIP is a full-float dense retrieval baseline used for comparison
-> purposes — it is NOT ground truth.  nDCG@10 is computed against the official
-> BEIR qrels (human-annotated relevance judgements), not against FAISS results.
-> ANN-recall-vs-FAISS (fraction of FAISS top-k recovered by an ANN method) is
-> an optional diagnostic metric only; it does not substitute for qrel-based
-> evaluation.**
+> **The `flat` baseline is an exact full-float inner-product search (identical
+> retrieval to FAISS `IndexFlatIP`) used for comparison purposes — it is NOT
+> ground truth.  nDCG@10 is computed against the official BEIR qrels
+> (human-annotated relevance judgements), not against the `flat` results.
+> Recall-vs-`flat` is an optional diagnostic only; it does not substitute for
+> qrel-based evaluation.**
 
 ## Dataset suite
 
-| Dataset    | Domain          | #Queries | #Corpus |
-|------------|-----------------|----------|---------|
-| scifact    | Scientific claim verification | 300  | 5 183  |
-| nfcorpus   | Biomedical IR   | 323      | 3 633  |
-| fiqa       | Financial QA    | 648      | 57 638 |
-| trec-covid | COVID-19 literature | 50   | 171 332 |
+| Dataset    | Domain                        | #Queries | #Corpus |
+|------------|-------------------------------|---------:|--------:|
+| scifact    | Scientific claim verification | 300      | 5,183   |
+| nfcorpus   | Biomedical IR                 | 323      | 3,633   |
+| fiqa       | Financial QA                  | 648      | 57,638  |
+| trec-covid | COVID-19 literature           | 50       | 171,332 |
 
-All datasets are downloaded automatically via the BEIR Python library on first
-`make bench-beir-prepare` run.
+Datasets are downloaded automatically on first run by a small vendored BEIR
+reader (no `beir` PyPI package — it pulls an unbuildable `pytrec_eval`). The
+default `make benchmark-beir` reproduces **scifact** (quality) + **trec-covid**
+(scaling + latency); `nfcorpus`/`fiqa` are supported via `QUALITY_DATASETS=...`.
 
 ## Encoder
 
-**Harrier (harrier-oss-v1-0.6b)** — Microsoft's 600M-parameter bi-encoder
-producing 1024-dimensional L2-normalised float32 embeddings.
+**Harrier (`harrier-oss-v1-0.6b`)** — a 600M-parameter bi-encoder producing
+1024-dimensional L2-normalised float32 embeddings. The canonical lane runs the
+**GGUF `Q8_0`** weights via `llama-cpp-python` (CUDA), last-token pooled.
 
 - Documents receive no instruction prefix.
-- Queries receive:
-  `"Instruct: Given a web search query, retrieve relevant passages that answer the query\nQuery: "`
-- Revision is pinned in `embeddings.manifest.json` per cache directory.
-
-## Quick start
-
-### 1. Install Python dependencies
-
-```bash
-make bench-beir-setup
-```
-
-Installs from `benchmarks/beir/requirements.txt`.
+- Queries are prefixed with
+  `"Instruct: Given a web search query, retrieve relevant passages that answer the query\nQuery: "`.
+- The exact repo/file/quant + library versions are recorded in
+  `embeddings.manifest.json` per cache directory.
 
-### 2. Smoke run (scifact only, ~5 min on GPU)
-
-```bash
-make benchmark-beir-smoke
-```
+Optional alternate encoder lanes (heavier; off by default): sentence-transformers
+(`make bench-beir-prepare-st`) and Ollama (`make bench-beir-prepare-ollama`).
 
-Uses the `st` (sentence-transformers) provider with CUDA.  Encodes, runs all
-ordvec methods, runs the FAISS baseline, then evaluates nDCG@{10,100}.
-
-### 3. Full suite
-
-**Sentence-transformers / CUDA lane (default):**
+## Quick start
 
 ```bash
-make benchmark-beir
+make bench-beir-setup       # Python deps + CUDA llama-cpp-python (built from source)
+make benchmark-beir-smoke   # quick end-to-end sanity (scifact only)
+make benchmark-beir         # quality (nDCG) + scaling sweep + three figures
 ```
 
-Override encoder or device:
+`bench-beir-setup` installs `requirements.txt` and then builds `llama-cpp-python`
+against the host CUDA toolkit (`CMAKE_ARGS="-DGGML_CUDA=on"`; override
+`LLAMA_CMAKE_ARGS=` for a CPU-only build).
 
-```bash
-make benchmark-beir \
-    ENCODER_PROVIDER=st \
-    HARRIER_MODEL=microsoft/harrier-oss-v1-0.6b \
-    DEVICE=cpu \
-    ENCODE_BATCH=4
-```
+## Methods (all measured in the Rust harness)
 
-**Ollama lane (CPU, quantised, no GPU required):**
+| Method            | Bytes/vec | Description |
+|-------------------|----------:|-------------|
+| `flat`            | 4096      | Exact inner product (== FAISS `IndexFlatIP` math), pure-Rust SIMD GEMM. **Baseline, not ground truth.** |
+| `hnsw`            | 4096      | Pure-Rust HNSW (`hnsw_rs`, M=32, ef=128) — portable stand-in for C++ hnswlib. |
+| `rq2`             | 256       | RankQuant 2 bits/dim, asymmetric float-query LUT scan. |
+| `rq4`             | 512       | RankQuant 4 bits/dim, asymmetric float-query LUT scan. |
+| `bitmap-rq2`      | 384       | Two-stage: Bitmap candidate-gen → RankQuant-2 rerank. |
+| `sign-rq2`        | 384       | Two-stage: SignBitmap candidate-gen → RankQuant-2 rerank. |
 
-```bash
-ollama pull hf.co/mradermacher/harrier-oss-v1-0.6b-GGUF:Q8_0
-make bench-beir-prepare-ollama
-make bench-beir-ordvec
-make bench-beir-baselines
-make bench-beir-eval
-```
+Thread/batch knobs (per `beir-bench`): `--threads N` pins query latency to a
+rayon pool of N threads (index build still uses all cores); `--max-docs M`
+sub-samples the corpus for the scaling sweep; `--batch` sets the matched batch.
 
 ## Cache layout
 
@@ -97,62 +86,50 @@ One encoder run produces a directory per dataset/split:
 
 ```
 .cache/ordvec-beir/<dataset>/<split>/encoder=<slug>/
-    corpus.f32.npy          # float32, shape (n_docs, 1024), L2-normalised, C-order
-    queries.f32.npy         # float32, shape (n_queries, 1024), L2-normalised, C-order
-    corpus_ids.json         # list[str], sorted(corpus.keys())
-    query_ids.json          # list[str], sorted(qrels.keys())
-    qrels.json              # {qid: {doc_id: int_relevance}}
-    texts.manifest.json     # reproducibility provenance for raw text
-    embeddings.manifest.json# encoder provider/model/revision/dim/norm
-    sha256s.json            # sha256 of each npy file
+    corpus.f32.npy           # float32 (n_docs, 1024), L2-normalised, C-order
+    queries.f32.npy          # float32 (n_queries, 1024), L2-normalised, C-order
+    corpus_ids.json          # list[str], sorted(corpus.keys())
+    query_ids.json           # list[str], sorted(qrels.keys())
+    qrels.json               # {qid: {doc_id: int_relevance}}
+    texts.manifest.json      # raw-text provenance
+    embeddings.manifest.json # encoder provider/model/quant/revision/dim/versions
+    sha256s.json             # sha256 of each npy file
 ```
 
-Encoder slug format: `<provider>__<model-path-components>__<revision-or-norev>`
-with `/`, `:`, and other non-filesystem-safe characters replaced by `__`.
+`prepare` skips re-embedding if these artefacts already exist (use `--force` to
+re-embed).
 
 ## Results layout
 
 ```
 results/beir/<dataset>/
-    <method>.topk.jsonl     # one JSON line per query
-    <method>.summary.json   # aggregate latency + nDCG metrics
+    <method>.topk.jsonl   # one JSON line per query (full-corpus runs)
+    <method>.summary.json # aggregate latency + provenance (full-corpus runs)
+    timing.jsonl          # one record per (method, n_docs, threads) — drives the plots
+results/beir/figures/     # scaling_curve / bars_single_thread / bars_threaded (.png/.svg)
 ```
 
-Top-k JSONL row schema:
+Top-k JSONL row schema (emitted with `serde_json`, so IDs are always valid JSON):
 
 ```json
 {"dataset":"scifact","split":"test","method":"ordvec-rq2",
- "qid_idx":0,"qid":"0","k":100,
- "doc_idxs":[42,7,...],"doc_ids":["abc","def",...],"scores":[0.91,0.88,...]}
+ "qid_idx":0,"qid":"1","k":100,
+ "doc_idxs":[42,7],"doc_ids":["abc","def"],"scores":[0.91,0.88]}
 ```
 
-Two-stage method names include parameters, e.g. `ordvec-bitmap-rq2-m500-b8`.
-
-## Available methods
-
-| Method          | Description |
-|-----------------|-------------|
-| `rq2`           | RankQuant (2 bits/dim), asymmetric float-query LUT scoring |
-| `rq4`           | RankQuant (4 bits/dim), asymmetric float-query LUT scoring |
-| `bitmap-rq2`    | Two-stage: Bitmap candidate gen + RankQuant-2 rerank |
-| `sign-rq2`      | Two-stage: SignBitmap candidate gen + RankQuant-2 rerank |
-| `faiss-flat`    | FAISS FlatIP full-float dense baseline (comparison, not ground truth) |
-
 ## `import ordvec` rule
 
-The Python harness files in `benchmarks/beir/` **must not** contain
-`import ordvec`.  This harness is an external consumer; it uses the installed
-`ordvec` wheel.  The `bench-beir-guardrail` Make target (run automatically as
-part of `benchmark-beir`) enforces this and fails with a clear error message if
-any harness file violates it.
-
-This rule preserves the reproducibility guarantee: anyone can clone this repo,
-install the published wheel (`pip install ordvec`), and reproduce results
-without needing the ordvec source tree.
+This harness is an **external benchmark driver**. Python prepares embeddings,
+evaluates qrels, and renders plots; the ordvec hot path is the Rust `beir-bench`
+binary. The Python `ordvec` package is intentionally **not** imported — so the
+latency numbers reflect the crate, not the bindings, and the harness does not
+even require the wheel to be installed. The `bench-beir-guardrail` Make target
+(run automatically by `benchmark-beir`) fails with a clear error if any
+`benchmarks/beir/*.py` file contains `import ordvec` / `from ordvec`.
 
 ## Clean up
 
 ```bash
-make bench-beir-clean         # remove result files, keep embedding cache
+make bench-beir-clean         # remove result files + timing.jsonl, keep embedding cache
 make bench-beir-clean-cache   # remove embedding cache (re-encoding required)
 ```
diff --git a/benchmarks/beir/beir_eval.py b/benchmarks/beir/beir_eval.py
index a5490405..13d0c429 100644
--- a/benchmarks/beir/beir_eval.py
+++ b/benchmarks/beir/beir_eval.py
@@ -287,10 +287,11 @@ def paired_bootstrap(
     diff = m - b
     observed_delta = float(diff.mean())
 
-    boot = np.empty(n_iters, dtype=np.float64)
-    for i in range(n_iters):
-        idx = rng.integers(0, n, size=n)
-        boot[i] = diff[idx].mean()
+    # Vectorized paired bootstrap: draw all (n_iters x n) resample indices at once
+    # and reduce along the query axis — same paired resampling, but the loop runs
+    # in NumPy's C internals instead of Python.
+    idx = rng.integers(0, n, size=(n_iters, n))
+    boot = diff[idx].mean(axis=1)
 
     ci_low = float(np.percentile(boot, 2.5))
     ci_high = float(np.percentile(boot, 97.5))

From 4f9bae7123e0e086f3fae6a2325088c9f9ac62ae Mon Sep 17 00:00:00 2001
From: Nelson Spence <nelson@projectnavi.ai>
Date: Mon, 15 Jun 2026 09:42:04 -0500
Subject: [PATCH 4/5] fix(bench): guard BEIR zip extraction against Zip Slip
 (qodo)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`_download_beir` called `ZipFile.extractall()` on a remote archive without
validating member paths — a malicious/tampered zip could path-traverse
(`../`, absolute paths) and overwrite arbitrary files under the running user.

Validate every member before extracting: resolve `raw_dir / member` and reject
any whose resolved path isn't `raw_dir` itself or under it, raising a clear
ValueError. Verified the guard rejects `../`, `../../etc/...`, `/etc/passwd`,
and `a/../../escape` while allowing legitimate `dataset/...` members.

Signed-off-by: Nelson Spence <nelson@projectnavi.ai>
---
 benchmarks/beir/beir_prepare.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/benchmarks/beir/beir_prepare.py b/benchmarks/beir/beir_prepare.py
index d597332b..a7b61f8b 100644
--- a/benchmarks/beir/beir_prepare.py
+++ b/benchmarks/beir/beir_prepare.py
@@ -291,7 +291,17 @@ def _download_beir(dataset: str, cache_dir: pathlib.Path) -> pathlib.Path:
             for chunk in r.iter_content(chunk_size=1 << 16):
                 f.write(chunk)
                 bar.update(len(chunk))
+    # Extract with Zip Slip protection: reject any member whose resolved path
+    # escapes raw_dir (path traversal / absolute paths), rather than trusting the
+    # remote archive with a blanket extractall().
+    raw_root = raw_dir.resolve()
     with zipfile.ZipFile(zip_path) as zf:
+        for member in zf.namelist():
+            dest = (raw_dir / member).resolve()
+            if dest != raw_root and raw_root not in dest.parents:
+                raise ValueError(
+                    f"unsafe path in {dataset}.zip (Zip Slip): {member!r}"
+                )
         zf.extractall(raw_dir)
     zip_path.unlink(missing_ok=True)
     if not (data_path / "corpus.jsonl").exists():

From f34073c3e75dbd6a42c0f88eb8c6e58bc15ef115 Mon Sep 17 00:00:00 2001
From: Nelson Spence <nelson@projectnavi.ai>
Date: Mon, 15 Jun 2026 09:44:50 -0500
Subject: [PATCH 5/5] docs(bench): disclose HNSW nondeterminism in the nDCG
 table
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

flat and the ordvec rows are deterministic (byte-identical run to run, verified);
the hnsw row is approximate — hnsw_rs builds the graph with a parallel insert, so
its nDCG and latency vary slightly between runs (≈±0.003 nDCG, within the same
bootstrap-noise band). Note this in the quality section so the "regenerate every
number" claim stays honest; the story (hnsw ≈ flat within noise; ordvec within
noise at 8–16× smaller) is unchanged.

Signed-off-by: Nelson Spence <nelson@projectnavi.ai>
---
 README.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index eee3957b..e293e34e 100644
--- a/README.md
+++ b/README.md
@@ -306,7 +306,11 @@ make benchmark-beir        # quality (nDCG) + scaling sweep + graphics
 
 nDCG@10 is computed against the human-annotated qrels (not against `flat`).
 `Δ vs flat` is the paired-bootstrap mean delta; `*` marks a 95% CI that straddles
-0 (i.e. within noise of exact).
+0 (i.e. within noise of exact). `flat` and the ordvec rows are **deterministic**
+(byte-identical run to run); the `hnsw` row is **approximate** — its graph is
+built in parallel, so its nDCG and latency vary slightly between runs (≈±0.003
+nDCG here, within the same noise band). The numbers below are one representative
+run; regenerate your own with `make benchmark-beir`.
 
 | Dataset | Method | Bytes/vec | nDCG@10 | Δ vs flat (95% CI) |
 |---|---|--:|--:|---|